Bash Integration

Shell Power + AI Intelligence

In the previous lesson, we explored file operations. Now let’s build on that foundation. Shell commands are powerful but dumb. They do exactly what you say, nothing more.

Claude is intelligent but can’t directly affect your system.

Together? You get intelligent automation. Claude runs commands, interprets outputs, and decides next steps.

Basic Command Execution

Ask Claude to run commands:

> Run the tests and show me the output

Claude executes npm test (or your project’s test command) and shows results.

> Check if port 3000 is in use

Claude runs lsof -i :3000 and interprets what it finds.

> What's using the most disk space in this project?

Claude runs du -sh * and summarizes.

The Run-and-Interpret Pattern

This is where Bash integration shines.

> Run the tests. If any fail, analyze why and fix them.

Claude:

1. Runs tests
2. Sees failures
3. Analyzes error messages
4. Identifies the problem
5. Fixes the code
6. Runs tests again
7. Confirms they pass

What would take you several manual cycles happens automatically.

Practical Bash Workflows

Debugging Workflow

> The server won't start. Diagnose and fix.

Claude might:

• Check if the port is in use
• Look at recent changes
• Check for missing dependencies
• Review error logs
• Find and fix the issue

Dependency Management

> Check for outdated dependencies and tell me which ones are safe to update.

Claude runs npm outdated, researches breaking changes, and gives recommendations.

Git Operations

> Show me what changed since yesterday

Claude runs appropriate git log and diff commands.

> Create a feature branch, make this change, and commit it

Claude handles the full git workflow.

Environment Checks

> Verify the development environment is set up correctly for this project.

Claude checks Node version, dependencies, environment variables, database connections, etc.

Command Categories

Safe to Run Freely

• Read-only commands: ls, cat, git status, git log
• Test commands: npm test, pytest
• Build commands: npm run build
• Linting: eslint, prettier --check

Review Before Running

• Git write operations: git commit, git push
• Package installation: npm install, pip install
• File modifications via shell: mv, cp
• Service restarts: pm2 restart

Be Careful With

• Destructive commands: rm, especially with -rf
• System-level changes: sudo anything
• Network operations: curl to unknown URLs
• Global installations: npm install -g

Quick check: Before moving on, can you recall the key concept we just covered? Try to explain it in your own words before continuing.

Claude will usually ask for confirmation on risky operations. Pay attention.

Building Automated Workflows

Test-Driven Bug Fix

> There's a bug where users can't log in with email addresses containing '+'.
> Write a failing test, then fix the bug, then run tests to confirm.

Claude:

1. Writes test that demonstrates the bug
2. Runs test (fails as expected)
3. Fixes the code
4. Runs tests (all pass)

Migration Workflow

> Create a database migration to add the 'phone_number' column to users.
> Run the migration and verify it worked.

Claude:

1. Creates migration file
2. Runs migration command
3. Checks database schema
4. Confirms success

Deploy Preparation

> Run all checks needed before deployment:
> - Tests
> - Linting
> - Type checking
> - Build
> Report any issues.

Claude runs everything and gives you a go/no-go summary.

Error Handling

When commands fail, Claude sees the error output.

> Run the tests

# Tests fail with error output

Claude: "Tests failed. Looking at the errors...
The issue is in login.test.js line 45. The mock isn't returning the expected shape.
Should I fix this?"

Claude interprets errors and suggests fixes. This is the power of the feedback loop.

Output Processing

Claude can process command output:

> Run git log --oneline for the last 20 commits.
> Summarize what features and fixes were shipped.

> Run npm audit.
> Categorize the vulnerabilities by severity and tell me which need immediate attention.

> Run the performance benchmark.
> Compare to the baseline and highlight any regressions.

Safety Practices

1. Review destructive commands

When Claude proposes something destructive, read before confirming.

2. Use dry-run when available

> Use rm --dry-run first to show what would be deleted

3. Sandbox risky experiments

> Create a test file in the scratchpad to try this approach
> Don't modify the actual source yet

4. Check before pushing

> Show me what commits will be pushed to origin/main

Review before any remote operations.

Key Takeaways

• Bash integration creates intelligent feedback loops
• Claude can run commands, interpret outputs, and adapt
• Use “run and interpret” pattern for automated troubleshooting
• Know which command categories need extra review
• Let Claude handle repetitive multi-step processes
• Always review destructive operations before confirming

Next: advanced workflows that combine everything we’ve learned.

Up next: In the next lesson, we’ll dive into Advanced Workflows.