How to Use CLIs in Claude Code for Content Automation

Claude Code can run any CLI tool on your machine. That means every terminal command — xSeek, GitHub CLI, Ahrefs, curl, jq — becomes a building block for automated content workflows. Skills tell Claude which commands to run and when.

Most people use Claude Code for writing code. But it's just as powerful for content operations. The key: CLIs. Claude Code executes shell commands, reads the output, and uses that data to make decisions.

Install the xSeek CLI, and Claude can pull AI visibility data. Install the GitHub CLI, and Claude can create PRs for your blog posts. Install jq, and Claude can parse any JSON API response. The agent becomes as capable as your terminal.

How Claude Code Executes CLI Commands

Claude Code has a Bash tool. It runs commands, reads stdout, and uses the output in its next step. That's the entire mechanism. No plugins, no custom integrations — just shell access.

Skills are markdown files that tell Claude which commands to run in what order. The skill is the playbook. The CLIs are the instruments. You write the instructions once, and Claude follows them every time you invoke the skill.

Here's a concrete example: a skill runs xseek opportunities mysite.com --format json. Claude reads the JSON output, picks the highest-value content gap, fetches competitor articles with curl, and writes a full blog post targeting that gap. One command triggers the whole chain.

CLIs That Work Great with Claude Code for Content

Any CLI installed on your machine works inside Claude Code. These are the ones that matter most for content automation:

The xSeek CLI is purpose-built for AI visibility workflows. It handles authentication, pagination, and structured JSON output — so Claude spends less time parsing and more time acting on the data.

Building a Content Automation Skill with CLIs

A skill is a markdown file inside .claude/commands/. It contains step-by-step instructions that Claude follows when you invoke it. Here's a content pipeline skill that chains multiple CLIs together:

# content-pipeline skill
---
name: content-pipeline
description: Full content pipeline from research to PR
---

1. Run `xseek opportunities mysite.com --format json` to find content gaps
2. Pick the highest-value opportunity based on search volume and competition
3. Run `xseek web-searches mysite.com --pageSize 50 --format json` for LLM queries
4. Fetch top 3 competitor articles using curl
5. Write the article applying GEO methods (citations, statistics, authoritative tone)
6. Save to the blog directory
7. Run `gh pr create` to open a pull request

Each step uses a different CLI. Claude reads the output of each command and feeds it into the next decision. The skill file itself is just instructions — no code, no configuration, no dependencies.

Your skill files live in a simple directory structure:

.claude/commands/
├── content-pipeline.md
├── writing-rules.md
└── generate-article.md

Every file in that directory becomes an invokable skill. Type /content-pipeline in Claude Code, and the agent follows the instructions in content-pipeline.md.

Real Example — xSeek + GitHub CLI Pipeline

Here's exactly what happens when you invoke /content-pipeline end to end:

1. Trigger: You type /content-pipeline in Claude Code
2. Research: Claude runs xseek opportunities mysite.com --format json and finds “best CRM tools for startups” as a content gap with high search volume and low competition
3. Query discovery: Claude runs xseek web-searches mysite.com --format json and identifies 15 related LLM queries people are asking across ChatGPT, Perplexity, and Gemini
4. Competitor analysis: Claude runs curl to fetch 3 competitor articles ranking for the same topic, extracts their structure, claims, and data points
5. Writing: Claude writes the article — applying GEO methods like authoritative citations, concrete statistics, and structured data — and saves it to app/blogs/articles/best-crm-tools-startups/page.tsx
6. Version control: Claude runs git add and git commit with a descriptive message
7. Pull request: Claude runs gh pr create --title “New article: Best CRM Tools for Startups”
8. Review: You review the PR and merge

The whole thing takes 5-10 minutes with zero manual research. You go from “I need content” to “here's a PR to review” without opening a browser, running a keyword tool, or reading a competitor article yourself.

Tips for Using CLIs in Skills

These patterns make the difference between skills that work reliably and skills that break on the second run:

• Always use --format json: Claude parses JSON far more reliably than formatted text output. Every CLI that supports it should use it.
• Pipe wisely: xseek opportunities mysite.com --format json | head -100 keeps context windows small. Large outputs burn tokens and slow decisions.
• Chain with &&: xseek login KEY && xseek websites ensures authentication succeeds before pulling data. If the first command fails, the chain stops.
• Error handling: Skills can include fallback instructions: “If the command fails, check that the CLI is installed and the API key is configured.”
• Credentials: Store API keys in config files (~/.xseek/config), not in the skill markdown. Claude reads the config automatically. Never hardcode keys.
• Test incrementally: Build skills one CLI command at a time. Verify each step's output before adding the next. A 7-step skill that fails at step 3 wastes more time than building step by step.

The MCP Alternative

Claude Code also supports MCP (Model Context Protocol) servers. MCP provides structured tool interfaces — typed inputs, typed outputs, explicit schemas. It's the more formal approach.

CLIs are simpler. Any command-line tool works immediately — no server to build, no schema to define, no protocol to implement. You install a CLI, write a skill, and it works.

MCP makes sense when you need complex input validation, streaming responses, or tight integration with a specific platform. For most content automation — pulling data, writing articles, creating PRs — CLIs are enough. Start with CLIs. Move to MCP only when you hit a wall.

Frequently Asked Questions

Can Claude Code run any CLI tool?

Yes. Claude Code has full shell access (with permission). Any CLI installed on your machine — xSeek, gh, curl, python, node — is available. Claude runs the command, reads stdout, and uses the output to decide what to do next.

Is it safe to let Claude Code run shell commands?

Claude Code asks for permission before running commands. You can configure permission rules to auto-approve safe commands (like xseek, gh) and require manual approval for anything else. You see every command before it executes.

How do I share skills with my team?

Commit the .claude/commands/ directory to your repo. Every team member with Claude Code gets the same skills automatically. Skills are just markdown files — they version-control, diff, and review like any other code.

Can skills call APIs directly without a CLI?

Yes. Claude can use curl or fetch to call any API. But purpose-built CLIs like xSeek are easier — they handle auth, pagination, and output formatting. You write less instruction in the skill and get cleaner data back.

What's the difference between a skill and a hook?

Skills are instructions Claude follows when you invoke them (like /content-pipeline). Hooks are shell commands that run automatically on events — before or after tool calls. Use skills for workflows you trigger manually. Use hooks for automation that should happen every time.