Claude AI Code Generation Integration Workflows: A Practical Enterprise Tutorial

1# Python setup
2pip install anthropic==0.34.0 fastapi uvicorn pydantic
3
4# Or Node.js setup
5npm install @anthropic-ai/[email protected] express zod

1export ANTHROPIC_API_KEY="sk-ant-your-key-here"
2export GITHUB_TOKEN="ghp_your-token-here"
3export N8N_WEBHOOK_URL="https://your-n8n-instance.com/webhook/claude-pipeline"

1# pr_review_service.py
2import os
3import json
4import hmac
5import hashlib
6from fastapi import FastAPI, Request, HTTPException
7from anthropic import Anthropic
8
9app = FastAPI()
10client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
11
12GITHUB_WEBHOOK_SECRET = os.environ.get("GITHUB_WEBHOOK_SECRET", "")
13
14REVIEW_SYSTEM_PROMPT = """You are a senior code reviewer for an APAC enterprise team.
15Review the following PR diff and provide:
161. A severity rating (critical/warning/info) for each issue
172. Specific line references
183. Suggested fixes as code blocks
194. A summary suitable for async review across time zones (HK, SG, AU)
20
21Format your response as JSON with this structure:
22{
23  "summary": "string",
24  "issues": [{"severity": "string", "file": "string", "line": int, "description": "string", "suggestion": "string"}],
25  "approval_recommendation": "approve|request_changes|comment"
26}
27"""
28
29def verify_github_signature(payload: bytes, signature: str) -> bool:
30    expected = "sha256=" + hmac.new(
31        GITHUB_WEBHOOK_SECRET.encode(), payload, hashlib.sha256
32    ).hexdigest()
33    return hmac.compare_digest(expected, signature)
34
35@app.post("/webhook/pr-review")
36async def handle_pr_webhook(request: Request):
37    payload = await request.body()
38    signature = request.headers.get("X-Hub-Signature-256", "")
39    
40    if GITHUB_WEBHOOK_SECRET and not verify_github_signature(payload, signature):
41        raise HTTPException(status_code=401, detail="Invalid signature")
42    
43    event = json.loads(payload)
44    
45    if event.get("action") not in ["opened", "synchronize"]:
46        return {"status": "skipped"}
47    
48    pr_diff = event["pull_request"].get("diff_url", "")
49    pr_title = event["pull_request"]["title"]
50    pr_body = event["pull_request"].get("body", "")
51    
52    # Fetch the actual diff content
53    import httpx
54    async with httpx.AsyncClient() as http_client:
55        diff_response = await http_client.get(
56            pr_diff,
57            headers={"Authorization": f"token {os.environ['GITHUB_TOKEN']}"}
58        )
59        diff_content = diff_response.text
60    
61    # Send to Claude for review
62    message = client.messages.create(
63        model="claude-sonnet-4-20250514",
64        max_tokens=4096,
65        system=REVIEW_SYSTEM_PROMPT,
66        messages=[{
67            "role": "user",
68            "content": f"PR Title: {pr_title}\nPR Description: {pr_body}\n\nDiff:\n{diff_content[:100000]}"
69        }]
70    )
71    
72    review = json.loads(message.content[0].text)
73    return {"status": "reviewed", "review": review}

1uvicorn pr_review_service:app --host 0.0.0.0 --port 8000

1{
2  "status": "reviewed",
3  "review": {
4    "summary": "PR adds pagination to the customer list API. Two issues found: SQL injection risk in the sort parameter and missing index on the created_at column.",
5    "issues": [
6      {
7        "severity": "critical",
8        "file": "src/api/customers.py",
9        "line": 47,
10        "description": "Sort parameter is interpolated directly into SQL query",
11        "suggestion": "Use parameterized query or whitelist allowed sort columns"
12      }
13    ],
14    "approval_recommendation": "request_changes"
15  }
16}

1{
2  "name": "Claude Ticket Triage Pipeline",
3  "nodes": [
4    {
5      "parameters": {
6        "httpMethod": "POST",
7        "path": "ticket-triage",
8        "responseMode": "responseNode"
9      },
10      "type": "n8n-nodes-base.webhook",
11      "name": "Ticket Webhook",
12      "position": [240, 300]
13    },
14    {
15      "parameters": {
16        "url": "https://api.anthropic.com/v1/messages",
17        "method": "POST",
18        "headers": {
19          "x-api-key": "={{$env.ANTHROPIC_API_KEY}}",
20          "anthropic-version": "2023-06-01",
21          "content-type": "application/json"
22        },
23        "body": {
24          "model": "claude-sonnet-4-20250514",
25          "max_tokens": 1024,
26          "system": "Classify this support ticket. Return JSON: {\"priority\": \"p0|p1|p2|p3\", \"category\": \"billing|technical|shipping|account\", \"language\": \"detected language\", \"suggested_team\": \"team name\", \"summary_en\": \"English summary regardless of input language\"}",
27          "messages": [{"role": "user", "content": "={{$json.ticket_content}}"}]
28        }
29      },
30      "type": "n8n-nodes-base.httpRequest",
31      "name": "Claude Triage",
32      "position": [460, 300]
33    },
34    {
35      "parameters": {
36        "conditions": {
37          "string": [{
38            "value1": "={{JSON.parse($json.content[0].text).priority}}",
39            "operation": "equals",
40            "value2": "p0"
41          }]
42        }
43      },
44      "type": "n8n-nodes-base.if",
45      "name": "P0 Check",
46      "position": [680, 300]
47    }
48  ]
49}

1name: Claude Code Generation
2
3on:
4  issues:
5    types: [labeled]
6
7jobs:
8  generate-code:
9    if: contains(github.event.label.name, 'claude-generate')
10    runs-on: ubuntu-latest
11    permissions:
12      contents: write
13      pull-requests: write
14    
15    steps:
16      - uses: actions/checkout@v4
17      
18      - name: Set up Python
19        uses: actions/setup-python@v5
20        with:
21          python-version: '3.11'
22      
23      - name: Install dependencies
24        run: pip install anthropic==0.34.0 PyGithub
25      
26      - name: Generate code from issue spec
27        env:
28          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
29          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
30        run: |
31          python scripts/claude_codegen.py \
32            --issue-number ${{ github.event.issue.number }} \
33            --repo ${{ github.repository }}
34      
35      - name: Create PR with generated code
36        env:
37          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
38        run: |
39          git config user.name "claude-codegen[bot]"
40          git config user.email "[email protected]"
41          BRANCH="claude/issue-${{ github.event.issue.number }}"
42          git checkout -b $BRANCH
43          git add -A
44          git commit -m "feat: auto-generated from issue #${{ github.event.issue.number }}"
45          git push origin $BRANCH
46          gh pr create \
47            --title "[Claude Generated] Issue #${{ github.event.issue.number }}" \
48            --body "Auto-generated code from issue spec. Review required before merge." \
49            --base main \
50            --head $BRANCH

1#!/usr/bin/env python3
2import os
3import argparse
4from pathlib import Path
5from anthropic import Anthropic
6from github import Github
7
8def main():
9    parser = argparse.ArgumentParser()
10    parser.add_argument("--issue-number", type=int, required=True)
11    parser.add_argument("--repo", type=str, required=True)
12    args = parser.parse_args()
13    
14    gh = Github(os.environ["GITHUB_TOKEN"])
15    repo = gh.get_repo(args.repo)
16    issue = repo.get_issue(args.issue_number)
17    
18    # Gather repository context
19    tree = repo.get_git_tree("main", recursive=True)
20    file_list = [item.path for item in tree.tree if item.path.endswith((".py", ".ts", ".js"))]
21    
22    client = Anthropic()
23    
24    message = client.messages.create(
25        model="claude-sonnet-4-20250514",
26        max_tokens=8192,
27        system="""You are a code generator for an enterprise APAC development team.
28        Given an issue specification and the repository file structure, generate
29        production-ready code. Output as a JSON object where keys are file paths
30        and values are file contents. Include tests. Follow existing project conventions.""",
31        messages=[{
32            "role": "user",
33            "content": f"""Issue Title: {issue.title}
34            
35Issue Body:
36{issue.body}
37
38Existing files in repo:
39{chr(10).join(file_list[:200])}
40
41Generate the required code files."""
42        }]
43    )
44    
45    import json
46    files = json.loads(message.content[0].text)
47    
48    for filepath, content in files.items():
49        path = Path(filepath)
50        path.parent.mkdir(parents=True, exist_ok=True)
51        path.write_text(content)
52        print(f"Generated: {filepath}")
53
54if __name__ == "__main__":
55    main()

1Generated: src/services/customer_enrichment.py
2Generated: src/services/tests/test_customer_enrichment.py
3Generated: src/api/routes/enrichment.py

1# multi_step_workflow.py
2from anthropic import Anthropic
3import json
4
5client = Anthropic()
6
7def execute_plan(task_description: str, codebase_context: str) -> dict:
8    # Step 1: Generate plan
9    plan_response = client.messages.create(
10        model="claude-sonnet-4-20250514",
11        max_tokens=2048,
12        system="""Break this task into ordered steps. Return JSON:
13        {"steps": [{"id": 1, "action": "description", "files_affected": ["path"], "depends_on": []}]}""",
14        messages=[{"role": "user", "content": f"Task: {task_description}\nCodebase: {codebase_context}"}]
15    )
16    plan = json.loads(plan_response.content[0].text)
17    
18    results = {}
19    
20    # Step 2: Execute each step sequentially
21    for step in plan["steps"]:
22        step_context = json.dumps({
23            "current_step": step,
24            "previous_results": results,
25            "full_plan": plan
26        })
27        
28        execution = client.messages.create(
29            model="claude-sonnet-4-20250514",
30            max_tokens=4096,
31            system="Execute this step of the plan. Return the code changes as a JSON object with file paths as keys.",
32            messages=[{"role": "user", "content": step_context}]
33        )
34        
35        results[step["id"]] = json.loads(execution.content[0].text)
36        print(f"Completed step {step['id']}: {step['action']}")
37    
38    return results
39
40# Usage
41result = execute_plan(
42    task_description="Migrate the customer API from REST to GraphQL",
43    codebase_context="FastAPI app with SQLAlchemy ORM, 12 endpoints..."
44)

1Completed step 1: Analyze existing REST endpoints and data models
2Completed step 2: Generate GraphQL schema from SQLAlchemy models
3Completed step 3: Create resolver functions
4Completed step 4: Update API router configuration
5Completed step 5: Generate migration tests