Developer Toolchain Integration

Integrate Claude Code CLI with essential development tools for faster, more reliable code.

What You'll Learn

• Essential tool integrations for professional development
• MCP servers for extending Claude CLI capabilities
• CI/CD pipeline integration
• Database and API development tools
• Monitoring and observability integration

The Claude Code CLI Toolchain

A professional development setup integrates Claude CLI with:

┌─────────────────────────────────────────────────────────────────┐
│                    Your Development Workflow                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐            │
│  │  IDE    │  │  Git    │  │ Testing │  │  CI/CD  │            │
│  │(VS Code)│  │ (gh)    │  │ (Jest)  │  │(Actions)│            │
│  └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘            │
│       │            │            │            │                   │
│       └────────────┴─────┬──────┴────────────┘                  │
│                          │                                       │
│                 ┌────────▼────────┐                             │
│                 │  Claude Code    │                             │
│                 │      CLI        │                             │
│                 └────────┬────────┘                             │
│                          │                                       │
│       ┌──────────────────┼──────────────────┐                   │
│       │                  │                  │                   │
│  ┌────▼────┐       ┌─────▼─────┐      ┌────▼────┐              │
│  │   MCP   │       │  Hooks    │      │ Commands │              │
│  │ Servers │       │           │      │          │              │
│  └────┬────┘       └───────────┘      └──────────┘              │
│       │                                                          │
│  ┌────▼────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐            │
│  │Database │  │  n8n    │  │ GitHub  │  │ Slack   │            │
│  │(Postgres)│  │         │  │   API   │  │         │            │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘            │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Essential MCP Integrations

Database Access

Direct database access from Claude CLI:

// ~/.claude/settings.json
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-postgres"],
      "env": {
        "POSTGRES_CONNECTION_STRING": "${DATABASE_URL}"
      }
    },
    "sqlite": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-sqlite"],
      "env": {
        "SQLITE_DB_PATH": "./data/app.db"
      }
    }
  }
}

Usage in terminal:

> Show me the schema for the users table

> Find users created in the last 24 hours

> What are the most common error types in the logs table?

GitHub Integration

Full GitHub access from your terminal:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

Terminal workflows:

> List open PRs assigned to me

> Create an issue for the bug we just found in auth.ts

> What are the failing checks on PR #234?

> Add a comment to issue #56 summarizing our fix

Filesystem Extended Access

Access files outside working directory:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-fs", "/home/user/projects", "/etc/nginx"],
      "env": {}
    }
  }
}

Web Browsing

Fetch documentation and resources:

{
  "mcpServers": {
    "browser": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-browser"]
    }
  }
}

Usage:

> Fetch the latest React hooks documentation

> What does the Express.js error handling middleware docs say?

CI/CD Integration

GitHub Actions with Claude CLI

# .github/workflows/claude-review.yml
name: Claude Code Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install Claude Code CLI
        run: npm install -g @anthropic-ai/claude-code

      - name: Run Claude Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          # Get the diff
          DIFF=$(git diff origin/main...HEAD)

          # Run Claude review
          REVIEW=$(claude -p "Review this diff for bugs, security issues, and best practices violations. Be concise. Diff: $DIFF")

          # Post as PR comment
          gh pr comment ${{ github.event.pull_request.number }} --body "$REVIEW"
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Pre-Deployment Checks

#!/bin/bash
# scripts/pre-deploy-check.sh

set -e

echo "Running Claude Code CLI pre-deployment analysis..."

# Check for common issues
ISSUES=$(claude -p "Analyze this codebase for deployment readiness:
1. Check for console.log statements
2. Look for TODO/FIXME comments
3. Verify no hardcoded secrets
4. Check error handling completeness
Reply with READY if ok, or list issues.")

if [[ "$ISSUES" != *"READY"* ]]; then
  echo "❌ Pre-deployment check failed:"
  echo "$ISSUES"
  exit 1
fi

echo "✅ Pre-deployment check passed"

Integration Test Helper

#!/bin/bash
# scripts/integration-test.sh

# Run tests and analyze failures with Claude
npm test 2>&1 | tee test-output.log

if [ ${PIPESTATUS[0]} -ne 0 ]; then
  echo "Tests failed. Analyzing with Claude Code CLI..."

  claude -p "Analyze these test failures and suggest fixes:

  $(cat test-output.log)

  Focus on:
  1. Root cause of each failure
  2. Specific code changes needed
  3. Any patterns in the failures"
fi

Language-Specific Toolchains

Node.js / TypeScript

// package.json scripts integration
{
  "scripts": {
    "dev": "tsx watch src/index.ts",
    "build": "tsc",
    "test": "jest",
    "lint": "eslint . --fix",
    "typecheck": "tsc --noEmit",
    "claude:review": "claude 'Review recent changes for TypeScript best practices'",
    "claude:test": "claude 'Run tests and help fix any failures'",
    "claude:refactor": "claude 'Suggest refactoring opportunities in src/'"
  }
}

Essential TypeScript hooks:

// .claude/settings.json
{
  "hooks": {
    "post-tool-use": [
      {
        "matcher": "Edit:*.ts",
        "command": "npx tsc --noEmit 2>&1 | head -20"
      },
      {
        "matcher": "Edit:*.tsx",
        "command": "npx eslint --fix ${file} 2>&1 | head -10"
      }
    ]
  }
}

Python

# pyproject.toml
[tool.pytest.ini_options]
testpaths = ["tests"]
addopts = "-v --tb=short"

[tool.black]
line-length = 100

[tool.ruff]
line-length = 100
select = ["E", "F", "I", "N", "W"]

[tool.mypy]
strict = true

// .claude/settings.json for Python
{
  "hooks": {
    "post-tool-use": [
      {
        "matcher": "Edit:*.py",
        "command": "ruff check --fix ${file} && black ${file}"
      }
    ]
  }
}

Go

// .claude/settings.json for Go
{
  "hooks": {
    "post-tool-use": [
      {
        "matcher": "Edit:*.go",
        "command": "gofmt -w ${file} && go vet ${file}"
      }
    ]
  }
}

Rust

// .claude/settings.json for Rust
{
  "hooks": {
    "post-tool-use": [
      {
        "matcher": "Edit:*.rs",
        "command": "rustfmt ${file} && cargo check 2>&1 | head -20"
      }
    ]
  }
}

API Development Tools

REST API Testing with Claude CLI

# Test API endpoints directly from Claude
> Test the /api/users endpoint with a POST request containing:
  { "name": "Test User", "email": "test@example.com" }

# Claude uses curl or httpie to test and shows results

OpenAPI/Swagger Integration

# Generate API client from OpenAPI spec
> Read the openapi.yaml file and generate TypeScript types for all endpoints

# Validate API responses
> Test all endpoints in openapi.yaml and verify responses match the spec

GraphQL Development

> Analyze the GraphQL schema and suggest optimizations for the User type

> Generate TypeScript types from schema.graphql

> Find N+1 query issues in the resolvers

Docker Integration

Docker Compose Workflows

> Start the development environment with docker-compose

> Show me the logs from the api container

> Rebuild only the worker container

> What's using the most memory in Docker?

Dockerfile Optimization

> Review my Dockerfile for security issues and size optimization

> Convert this Dockerfile to a multi-stage build

> Add health checks to the docker-compose.yml

Monitoring & Observability

Log Analysis

> Analyze the last 100 lines of logs for errors and patterns

> Find all requests that took longer than 1 second in access.log

> What are the most common error messages in the last hour?

Performance Analysis

> Profile the application and identify slow functions

> Analyze this flame graph and suggest optimizations

> Find memory leaks by analyzing heap snapshots

Custom Tool Scripts

Claude-Powered Code Generator

#!/bin/bash
# scripts/generate-component.sh

COMPONENT_NAME=$1
COMPONENT_TYPE=${2:-"functional"}

if [ -z "$COMPONENT_NAME" ]; then
  echo "Usage: ./generate-component.sh ComponentName [type]"
  exit 1
fi

claude -p "Generate a React $COMPONENT_TYPE component named $COMPONENT_NAME following the patterns in src/components. Include:
1. TypeScript types
2. Proper prop handling
3. Basic styling setup
4. Unit test file

Output each file with clear file path comments."

Dependency Analyzer

#!/bin/bash
# scripts/analyze-deps.sh

echo "Analyzing dependencies with Claude Code CLI..."

# Get outdated packages
OUTDATED=$(npm outdated --json 2>/dev/null || echo "{}")

# Get security audit
AUDIT=$(npm audit --json 2>/dev/null || echo "{}")

claude -p "Analyze these npm dependencies:

Outdated packages:
$OUTDATED

Security audit:
$AUDIT

Provide:
1. Critical updates needed
2. Security vulnerabilities to address
3. Recommendations for deprecated packages"

Database Migration Helper

#!/bin/bash
# scripts/generate-migration.sh

DESCRIPTION="$*"

claude -p "Generate a database migration for: $DESCRIPTION

Use the Prisma migration format. Include:
1. Up migration
2. Down migration
3. Any data backfill needed

Reference existing schema in prisma/schema.prisma"

Integration Patterns

Pattern 1: Full-Stack Development

# Terminal 1: Claude Code CLI
claude

# In session:
> I'm adding a new user profile feature. Help me:
  1. Design the database schema
  2. Create the API endpoint
  3. Build the React component
  4. Write tests for all layers

Pattern 2: Bug Triage

# Quick bug analysis
claude -p "Analyze GitHub issue #123 and:
1. Identify likely root cause
2. Find related code
3. Suggest a fix approach"

Pattern 3: Code Review Pipeline

# In CI/CD
git diff main...HEAD > /tmp/changes.diff
claude -p "Review this diff: $(cat /tmp/changes.diff)" > review.md
gh pr comment $PR_NUMBER --body "$(cat review.md)"

Try It Yourself

Exercise: Build an Integrated Workflow

1. Set up MCP servers:

   # Add GitHub and database MCP servers to your config
   claude "Help me configure MCP servers for GitHub and PostgreSQL"
   

2. Create CI integration:

   # Add Claude review to your CI
   claude "Create a GitHub Action that reviews PRs with Claude"
   

3. Build custom tools:

   # Create a code generator
   claude "Create a script that generates CRUD endpoints for a given model"
   

4. Test the integration:

   # Create a PR and see the full workflow
   git checkout -b feat/test-integration
   # Make changes...
   git push -u origin feat/test-integration
   gh pr create
   

What's Next?

Master debugging and troubleshooting with Claude Code CLI in 07-debugging-mastery.

---

Summary: - MCP servers extend Claude CLI to databases, GitHub, filesystems, and web - CI/CD integration enables automated reviews and pre-deployment checks - Language-specific hooks ensure code quality on every edit - Custom scripts leverage claude -p for automation - Docker, API testing, and monitoring tools integrate seamlessly - Build integrated workflows that span the entire development lifecycle

---

Learning Resources

Featured Video

Fireship: MCP Toolchain Integration (3M+ subscribers)

Integrate Claude with databases, CI/CD pipelines, and language-specific development tools.

Additional Resources

Type	Resource	Description
🎬 Video	MCP Server Integration	All About AI - Toolchain patterns
📚 Official Docs	MCP Documentation	Tool integration guide
📖 Tutorial	MCP Servers Repo	Official integrations
🎓 Free Course	Microsoft MCP Guide	Multi-language MCP examples
💼 Commercial	Cursor Integration	Toolchain automation