Stop typing interactively. Start piping Claude into everything.
From: x.com/adocomplete
Introduction
There's something deeply satisfying about automation. That moment when you realize a task you've done a hundred times can be reduced to a single command—or better yet, run automatically while you sleep. It's the difference between working hard and working smart.
But here's the thing: most AI coding assistants are designed for interactive use. You type, they respond, you type again. Great for exploration, but useless when you need AI to work as part of a larger automated system.
What if you could pipe the output of git diff directly into Claude? What if your CI pipeline could ask Claude to review code, fix lint errors, or generate documentation—all without human intervention? Welcome to Day 7, where we explore Headless Mode—the feature that turns Claude Code into a programmable AI utility.
The Problem
Interactive AI tools have a fundamental limitation: they require a human at the keyboard. This creates several pain points:
In scripting: You can't easily incorporate AI assistance into bash scripts, build tools, or custom automation. The interactive prompt blocks everything.
In CI/CD: Your pipelines run unattended. There's no one to type prompts or hit enter. Traditional AI assistants simply don't fit.
In data pipelines: You want to process output from other commands—pipe in data, get analysis out. Interactive mode breaks the Unix philosophy of composable tools.
For batch operations: Sometimes you need to run the same prompt against multiple files or inputs. Manually typing each one? Nobody has time for that.
The interactive paradigm, while user-friendly, boxes AI into a narrow use case. We need something more flexible.
The Solution
Claude Code's headless mode transforms the AI from an interactive assistant into a command-line utility that plays nicely with the Unix ecosystem.
How to Use It
The magic flag is -p (for "print" or "pipe"—think of it like echo):
claude -p "Your prompt here"
This sends the prompt to Claude, prints the response to stdout, and exits. No interactive session. No waiting for user input. Just prompt → response → done.
Practical Examples
Fix lint errors automatically:
claude -p "Fix the lint errors in src/utils.js"
Filter and search AI output:
claude -p "List all the functions in this codebase" | grep "async"
Pipe data INTO Claude:
git diff | claude -p "Explain these changes in plain English"
Chain with other commands:
cat error.log | claude -p "What's causing these errors?" > analysis.txt
Use in a script:
#!/bin/bash
for file in src/*.js; do
claude -p "Add JSDoc comments to $file"
done
CI/CD Integration
Here's a GitHub Actions example that uses Claude to review pull requests:
- name: AI Code Review
run: |
git diff origin/main...HEAD | claude -p "Review this diff for:
1. Potential bugs
2. Security issues
3. Performance concerns
Provide actionable feedback." > review.md
- name: Post Review Comment
uses: actions/github-script@v6
with:
script: |
const review = fs.readFileSync('review.md', 'utf8');
github.rest.issues.createComment({
owner: context.repo.owner,
repo: context.repo.repo,
issue_number: context.issue.number,
body: review
});
Pro Tips
1. Combine with xargs for batch processing
find . -name "*.py" | xargs -I {} claude -p "Check {} for type hints and suggest improvements"
2. Use heredocs for multi-line prompts
claude -p << 'EOF'
Analyze the following requirements and suggest a database schema:
- Users can create posts
- Posts can have multiple comments
- Users can follow other users
- Posts can be liked by users
EOF
3. Capture exit codes for conditional logic
if claude -p "Does this code have any security vulnerabilities? Answer only YES or NO" | grep -q "YES"; then
echo "Security review needed!"
exit 1
fi
4. Set environment variables for context
PROJECT_TYPE="React TypeScript" claude -p "Generate a component for a login form"
5. Combine with watch for monitoring
watch -n 60 'tail -100 /var/log/app.log | claude -p "Summarize any errors or warnings"'
Real-World Use Case
Imagine you're maintaining a large codebase and want to generate a changelog from your git commits. Traditionally, you'd either write it manually or use a rigid conventional-commits parser.
With headless mode:
#!/bin/bash
# generate-changelog.sh
VERSION=$1
LAST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "")
if [ -z "$LAST_TAG" ]; then
COMMITS=$(git log --oneline)
else
COMMITS=$(git log --oneline $LAST_TAG..HEAD)
fi
echo "$COMMITS" | claude -p "Generate a user-friendly changelog for version $VERSION.
Group changes into: Features, Bug Fixes, Performance, and Documentation.
Make it readable for non-technical stakeholders." > CHANGELOG_$VERSION.md
echo "Changelog generated: CHANGELOG_$VERSION.md"
Run it: ./generate-changelog.sh v2.1.0
The result? A polished, human-readable changelog generated from your commit history—in seconds, without manual effort.
Conclusion
Headless mode transforms Claude Code from a conversational tool into a programmable AI primitive. It's the difference between having an assistant you talk to and having an assistant you can deploy.
Whether you're automating code reviews, building smart scripts, or integrating AI into your CI/CD pipeline, the -p flag is your gateway. Once you start thinking about Claude as just another Unix tool—one you can pipe, redirect, and compose—the possibilities become endless.
Coming up tomorrow: You've been using Claude Code for a while now, but do you know what's actually eating your tokens? Day 8 reveals The /context Command—your X-ray vision into the context window. See exactly where your tokens are going and optimize your usage like a pro.
This is Day 7 of the "31 Days of Claude Code Features" series. Follow along to discover a new powerful feature every day.