Praxislabor — CCA-F Claude Certified Architect — Foundations

Übersicht

Voraussetzungen

Schritte

1. 1.Installieren Sie Claude Code und bestätigen Sie die API-Verbindung

   Ressourcen:

   • Claude Code
   • Anthropic API

   Claude Code ist die CLI, die die CCA-F-Prüfung am direktesten testet – Konfiguration, Hooks, Slash-Befehle und Berechtigungsmodi sind hier angesiedelt. Wir beginnen damit, es global zu installieren, damit jeder spätere Schritt claude aufrufen kann.

   Nach der Installation beweist ein kurzes claude --version, dass die Binärdatei in Ihrem PATH ist, und claude --print-system-prompt bestätigt, dass der API-Schlüssel gültig ist (es führt unter der Haube einen leichtgewichtigen Aufruf durch).

   Kopieren

   # Install Claude Code globally
   npm install -g @anthropic-ai/claude-code
   
   # Verify installation
   claude --version
   
   # Confirm API connectivity (prints the built-in system prompt)
   claude --print-system-prompt | head -20

2. 2.Richten Sie die `CLAUDE.md`-Dateien auf Projekt- und Benutzerebene ein

   Ressourcen:

   • CLAUDE.md
   • Project Config

   Die Prüfung testet intensiv die dreistufige CLAUDE.md-Hierarchie: Benutzer (~/.claude/CLAUDE.md), Projekt (Repo-Root) und Modul (Unterverzeichnisse). Jede Ebene erbt von der darüberliegenden und kann diese überschreiben.

   Wir werden eine Datei auf Projektebene erstellen, die Codierungskonventionen festlegt, und eine Datei auf Benutzerebene, die persönliche Präferenzen festlegt. Wenn Claude Code das Projekt liest, führt es alle drei Ebenen zusammen – genau das Verhalten, nach dem in der Prüfung gefragt wird.

   Kopieren

   # Create project root CLAUDE.md
   cat > CLAUDE.md << 'EOF'
   # Project: CCA-F Lab
   
   ## Coding conventions
   - Use TypeScript for all new files
   - Prefer const over let
   - Use single quotes for strings
   - No semicolons (Prettier default)
   
   ## Testing
   - Run `npm test` before committing
   - All new functions must have at least one test
   EOF
   
   # Create user-level CLAUDE.md (applies to ALL your projects)
   mkdir -p ~/.claude
   cat > ~/.claude/CLAUDE.md << 'EOF'
   # User preferences
   - Be concise in responses
   - Prefer functional programming patterns
   - Always explain the "why" before showing code
   EOF
   
   # Verify Claude Code sees both files
   claude "What instructions do you see in CLAUDE.md?" --print

3. 3.Erstellen Sie einen benutzerdefinierten Slash-Befehl, der ein neues Modul generiert

   Ressourcen:

   • Slash Commands
   • Claude Code

   Benutzerdefinierte Slash-Befehle befinden sich in .claude/commands/ als Markdown-Dateien. Der Dateiname wird zum Befehlsnamen (z.B. scaffold.md → /scaffold). Der Dateiinhalt ist die Prompt-Vorlage – sie kann $ARGUMENTS für Benutzereingaben enthalten.

   Dies ist ein häufiges Prüfungsthema: wo Befehle gespeichert werden, wie Argumente übergeben werden und wie sie sich von Hooks unterscheiden.

   Kopieren

   # Create the commands directory
   mkdir -p .claude/commands
   
   # Create a scaffold command
   cat > .claude/commands/scaffold.md << 'EOF'
   Create a new TypeScript module named $ARGUMENTS with:
   1. A main source file at src/$ARGUMENTS/index.ts
   2. A test file at src/$ARGUMENTS/__tests__/index.test.ts
   3. Export the module from the project root index.ts
   
   Follow the coding conventions in CLAUDE.md.
   EOF
   
   # Test the command (Claude Code will execute it interactively)
   claude /scaffold calculator

4. 4.Konfigurieren Sie Hooks für automatisches Linting vor jedem Schreibvorgang

   Ressourcen:

   • Hooks
   • Settings

   Hooks führen Shell-Befehle als Reaktion auf Claude Code-Ereignisse aus. Die Prüfung testet drei Hook-Typen: PreToolUse (bevor ein Tool ausgeführt wird), PostToolUse (danach) und Notification (bei Statusänderungen). Hooks werden in .claude/settings.json definiert.

   Wir werden einen PostToolUse-Hook hinzufügen, der einen Linter nach jeder Dateibearbeitung ausführt – ein häufiges Produktionsmuster, nach dem in der Prüfung oft gefragt wird.

   Kopieren

   # Initialize a package.json so we have a lint script
   npm init -y
   npm install --save-dev typescript @typescript-eslint/parser
   
   # Create project-level settings with a post-tool hook
   mkdir -p .claude
   cat > .claude/settings.json << 'EOF'
   {
     "hooks": {
       "PostToolUse": [
         {
           "matcher": "Write|Edit",
           "command": "npx tsc --noEmit 2>&1 | head -5"
         }
       ]
     },
     "permissions": {
       "allow": [
         "Read",
         "Write",
         "Edit"
       ]
     }
   }
   EOF
   
   # Verify settings are recognized
   cat .claude/settings.json

5. 5.Starten Sie einen lokalen MCP-Server und verbinden Sie Claude Code damit

   Ressourcen:

   • MCP
   • stdio Transport

   Das Model Context Protocol (MCP) ist ein Kernbereich der Prüfung. MCP-Server stellen LLM-Clients Tools, Ressourcen und Prompts über ein standardisiertes JSON-RPC-Protokoll zur Verfügung. Der stdio-Transport ist der einfachste – der Server liest von stdin und schreibt nach stdout.

   Wir werden einen minimalen MCP-Server erstellen, der ein get_weather-Tool bereitstellt, und dann Claude Code so konfigurieren, dass es sich damit verbindet. Dies übt den gesamten MCP-Lebenszyklus, den die Prüfung testet: Tool-Definition, Transport-Verkabelung, Tool-Aufruf und Ergebnisbehandlung.

   Kopieren

   # Install the MCP SDK
   npm install @modelcontextprotocol/sdk
   
   # Create the MCP server
   cat > mcp-weather.mjs << 'EOF'
   import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
   import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
   
   const server = new McpServer({ name: "weather", version: "1.0.0" });
   
   server.tool("get_weather", { city: { type: "string" } }, async ({ city }) => ({
     content: [{ type: "text", text: `Weather in ${city}: 72°F, sunny` }],
   }));
   
   const transport = new StdioServerTransport();
   await server.connect(transport);
   EOF
   
   # Register the MCP server in Claude Code settings
   cat > .claude/settings.json << 'EOF'
   {
     "mcpServers": {
       "weather": {
         "command": "node",
         "args": ["mcp-weather.mjs"]
       }
     }
   }
   EOF
   
   # Ask Claude Code to use the MCP tool
   claude "What is the weather in Tokyo? Use the get_weather tool."

6. 6.Rufen Sie die Anthropic API mit Tool-Definitionen und strukturierter Ausgabe auf

   Ressourcen:

   • Tool Use API
   • Structured Output

   Die Prüfung testet den Messages API tool_use-Fluss detailliert: Sie senden tools in der Anfrage, das Modell antwortet mit einem tool_use-Inhaltsblock, Sie führen diesen aus und geben ein tool_result zurück, dann erstellt das Modell die endgültige Antwort.

   Dieser Schritt verwendet curl, um die API direkt aufzurufen – der prüfungsrelevanteste Ansatz, da die Prüfung das rohe Anforderungs-/Antwortformat testet und nicht SDK-Wrapper.

   Kopieren

   # Call the Messages API with a tool definition
   curl -s https://api.anthropic.com/v1/messages \
     -H "x-api-key: $ANTHROPIC_API_KEY" \
     -H "anthropic-version: 2023-06-01" \
     -H "content-type: application/json" \
     -d '{
       "model": "claude-sonnet-4-6",
       "max_tokens": 1024,
       "tools": [{
         "name": "calculate",
         "description": "Evaluate a math expression",
         "input_schema": {
           "type": "object",
           "properties": {
             "expression": { "type": "string", "description": "Math expression to evaluate" }
           },
           "required": ["expression"]
         }
       }],
       "messages": [{
         "role": "user",
         "content": "What is 15% tip on a $85.50 dinner bill?"
       }]
     }' | python3 -m json.tool

7. 7.Aktivieren Sie erweitertes Denken (`extended thinking`) für komplexe mehrstufige Überlegungen

   Ressourcen:

   • Extended Thinking
   • Anthropic API

   Erweitertes Denken (extended thinking) ermöglicht es dem Modell, einen thinking-Block zu verwenden, um Schritt für Schritt zu überlegen, bevor es antwortet. Die Prüfung testet, wann es verwendet werden sollte (komplexe Überlegungen, Mathematik, Code-Generierung) und wie budget_tokens konfiguriert werden.

   Wir senden ein bewusst kniffliges Logikrätsel und vergleichen Antworten mit und ohne erweitertes Denken, um den Qualitätsunterschied direkt zu erleben.

   Kopieren

   # Request WITH extended thinking
   curl -s https://api.anthropic.com/v1/messages \
     -H "x-api-key: $ANTHROPIC_API_KEY" \
     -H "anthropic-version: 2023-06-01" \
     -H "content-type: application/json" \
     -d '{
       "model": "claude-sonnet-4-6",
       "max_tokens": 16000,
       "thinking": {
         "type": "enabled",
         "budget_tokens": 10000
       },
       "messages": [{
         "role": "user",
         "content": "A farmer has 17 sheep. All but 9 run away. How many does he have left? Explain your reasoning step by step."
       }]
     }' | python3 -m json.tool
   
   # The response includes a "thinking" block showing the model's
   # internal reasoning before the final answer.

8. 8.Verwenden Sie Prompt-Caching, um Kosten für wiederholte System-Prompts zu senken

   Ressourcen:

   • Prompt Caching
   • Anthropic API

   Prompt-Caching ermöglicht es Ihnen, Teile der Anfrage als cachefähig zu kennzeichnen. Gecachte Präfixe kosten bei nachfolgenden Aufrufen 90 % weniger und haben keine zusätzliche Latenz. Die Prüfung testet die Platzierung des cache_control-Blocks und die cache-hit-Header.

   Wir senden denselben großen System-Prompt zweimal und überprüfen die Antwort-Header, um den Cache-Treffer beim zweiten Aufruf zu bestätigen.

   Kopieren

   # First call — creates the cache entry
   curl -s -D /dev/stderr https://api.anthropic.com/v1/messages \
     -H "x-api-key: $ANTHROPIC_API_KEY" \
     -H "anthropic-version: 2023-06-01" \
     -H "content-type: application/json" \
     -d '{
       "model": "claude-sonnet-4-6",
       "max_tokens": 256,
       "system": [{
         "type": "text",
         "text": "You are a helpful assistant specialized in cloud architecture. You follow AWS Well-Architected Framework principles. You always recommend infrastructure as code. You prefer Terraform over CloudFormation. You prioritize security and cost optimization.",
         "cache_control": { "type": "ephemeral" }
       }],
       "messages": [{ "role": "user", "content": "How should I set up VPC peering?" }]
     }' > /dev/null 2>&1
   
   # Second call — should hit the cache (check usage.cache_read_input_tokens)
   curl -s https://api.anthropic.com/v1/messages \
     -H "x-api-key: $ANTHROPIC_API_KEY" \
     -H "anthropic-version: 2023-06-01" \
     -H "content-type: application/json" \
     -d '{
       "model": "claude-sonnet-4-6",
       "max_tokens": 256,
       "system": [{
         "type": "text",
         "text": "You are a helpful assistant specialized in cloud architecture. You follow AWS Well-Architected Framework principles. You always recommend infrastructure as code. You prefer Terraform over CloudFormation. You prioritize security and cost optimization.",
         "cache_control": { "type": "ephemeral" }
       }],
       "messages": [{ "role": "user", "content": "What about NAT gateway sizing?" }]
     }' | python3 -c "import sys,json; d=json.load(sys.stdin); print(f\"Cache read tokens: {d['usage'].get('cache_read_input_tokens', 0)}\")"

9. 9.Führen Sie Claude Code im Headless-Modus für CI/CD-Pipelines aus

   Ressourcen:

   • Headless Mode
   • CI/CD

   Die Prüfung testet, wie Claude Code nicht-interaktiv ausgeführt wird – das --print-Flag gibt das Ergebnis ohne interaktive Sitzung an stdout aus, und --output-format json liefert eine strukturierte Ausgabe für die Skripterstellung.

   Dies ist das in CI-Pipelines verwendete Muster: einen Prompt eingeben, ein Ergebnis erhalten, es programmatisch parsen.

   Kopieren

   # Headless mode: prompt in, text out
   claude --print "List 3 TypeScript best practices, one per line"
   
   # JSON output for programmatic use
   claude --print --output-format json "What is 2+2?"
   
   # Pipe a file for code review (CI pattern)
   echo 'const x: any = "hello";' > example.ts
   claude --print "Review this TypeScript file for type safety issues: $(cat example.ts)"

10. 10.Erstellen Sie einen Multi-Agenten-Supervisor, der Aufgaben an spezialisierte Unter-Agenten delegiert

    Ressourcen:

    • Multi-Agent
    • Supervisor Pattern
    • Anthropic SDK

    Domain 1 (Agentic Architecture, 27 %) ist die am höchsten gewichtete im Examen. Das Supervisor-Muster – ein Orchestrator, der Aufgaben an spezialisierte Unter-Agenten verteilt, jeder mit eigenem System-Prompt und Tool-Set – ist die am häufigsten getestete Architektur.

    Wir werden ein eigenständiges Node.js-Skript erstellen, das einen Supervisor implementiert, der zwei Spezialisten koordiniert: einen Researcher, der Dateien liest und zusammenfasst, und einen Writer, der die Ausgabe erstellt. Der Supervisor zerlegt eine Aufgabe, delegiert an jeden Spezialisten über separate API-Aufrufe und aggregiert die Ergebnisse. Führen Sie es vom Terminal aus aus und beobachten Sie, wie die Delegation live geschieht.

    Kopieren

    # Install the Anthropic SDK
    npm install @anthropic-ai/sdk
    
    # Create sample data for the agents to work with
    cat > sales-data.csv << 'EOF'
    month,revenue,units
    Jan,12500,150
    Feb,15200,180
    Mar,11800,140
    Apr,18900,220
    May,22100,260
    Jun,19500,230
    EOF
    
    # Create the multi-agent supervisor script
    cat > supervisor.mjs << 'SCRIPT'
    import Anthropic from "@anthropic-ai/sdk";
    import { readFileSync } from "fs";
    
    const client = new Anthropic();
    
    async function callAgent(role, systemPrompt, userMessage) {
      console.log(`\n--- ${role} agent ---`);
      const response = await client.messages.create({
        model: "claude-sonnet-4-6",
        max_tokens: 1024,
        system: systemPrompt,
        messages: [{ role: "user", content: userMessage }],
      });
      const text = response.content
        .filter((b) => b.type === "text")
        .map((b) => b.text)
        .join("\n");
      console.log(text);
      return text;
    }
    
    // --- Supervisor: decompose, delegate, aggregate ---
    const data = readFileSync("sales-data.csv", "utf-8");
    
    console.log("=== SUPERVISOR: Decomposing task ===");
    console.log("Task: Analyze sales data and write a brief executive summary.\n");
    console.log("Step 1: Delegate analysis to Researcher agent");
    console.log("Step 2: Delegate writing to Writer agent");
    console.log("Step 3: Combine results\n");
    
    // Sub-agent 1: Researcher — extracts insights
    const analysis = await callAgent(
      "Researcher",
      "You are a data analyst. Extract key trends, highs, lows, and growth rates. Be precise with numbers. Output bullet points only.",
      `Analyze this CSV data:\n\n${data}`
    );
    
    // Sub-agent 2: Writer — produces the summary from the analysis
    const summary = await callAgent(
      "Writer",
      "You are a business writer. Write a 3-sentence executive summary from the analysis provided. Use a professional tone. Include specific numbers.",
      `Write an executive summary based on these findings:\n\n${analysis}`
    );
    
    console.log("\n=== SUPERVISOR: Final aggregated output ===");
    console.log(summary);
    SCRIPT
    
    # Run the supervisor
    node supervisor.mjs

Bereinigung

# Remove the lab directory
cd .. && rm -rf cca-f-lab

# Optionally remove the user-level CLAUDE.md we created
rm -f ~/.claude/CLAUDE.md

# Optionally uninstall Claude Code
npm uninstall -g @anthropic-ai/claude-code