Claude Code iwwer de ganze Software Life Cycle

Claude Code ass dem Anthropic säin agentescht Coding-Tool, dat an Ärem Terminal leeft an Iech bei all Schrëtt vum Software Life Cycle begleede kann. Dëse Guide verbënnt déi siwe Phasen — vun den Ufuerderunge bis zum Betrib — mat de konkrete Prompts, der Configuratioun an den Diagrammer, déi en Expert-Entwéckler wierklech benotzt.

Den SDLC a siwe Phasen

All Phas huet eng Aufgab fir den Agent. Bei all Schrëtt entscheet Dir, wat Dir ofgitt a wat Dir selwer iwwerpréift. Hei ass de Loop, duerno all Phas am Detail.

flowchart LR
    R[1. Requirements] --> P[2. Planning]
    P --> D[3. Design]
    D --> I[4. Development]
    I --> T[5. Testing]
    T --> C[6. CI / CD]
    C --> O[7. Operations]
    O -. feedback loop .-> R

1. Ufuerderungen

De Claude mécht aus rouen Notizen e strukturéierte Backlog a weist virun allem drop hin, wat zweedeiteg ass, ier et zu engem Bug gëtt. Gitt him d'Quell an e strenge Output-Format:

Turn notes/requirements.md into a structured backlog:
- Rewrite each functional requirement as "As a <role>, I want <goal>,
  so that <value>".
- List non-functional requirements (security, performance, availability)
  as separate items.
- Flag anything ambiguous or missing as an open question.
- Output a markdown table: ID | Requirement | Priority | Acceptance criteria.

2. Planung an Estimatioun

Brécht Epics an Dages-Aufgaben, no Ofhängegkeet geuerdnet. Den Agent ass gutt am Sequenzéieren, well en d'Kopplung tëscht Dateien a Servicer gesäit:

Break this epic into tasks no larger than one day, ordered by dependency.
For each task give: title, affected files, effort (S/M/L), and definition
of done. Start with the riskiest task.

Epic: migrate order checkout from REST to async messaging.

Fir grouss Ännerungen fänkt am Plan-Modus un, sou datt de Claude d'Approche an d'Aufgabelëscht virschléit, ier en Dateien beréiert. Liest den Plan no a passt en un, da loosst en ausféieren. De Plan gëtt Äre Gantt:

gantt
    title Sprint plan for checkout migration
    dateFormat  YYYY-MM-DD
    section Design
    ADR & event schema      :a1, 2026-10-08, 2d
    section Build
    Order service producer  :a2, after a1, 3d
    Consumer + DLQ          :a3, after a2, 3d
    section Test
    Contract tests          :a4, after a3, 2d
    section Ship
    Canary + rollout        :a5, after a4, 2d

3. Architektur an Design

Frot de Claude, e Systemdiagramm ze produzéieren, a widerspriecht him dann. En kritiséiert gär d'Kopplung, Single Points of Failure an d'Konsistenz-Kompromisser:

flowchart TD
    subgraph Client["Client"]
        A[Web App]
    end
    subgraph Edge["Edge"]
        B[API Gateway]
    end
    subgraph Core["Core services"]
        C[Order Service]
        D[Payment Service]
    end
    subgraph Data["Data"]
        E[(Order DB)]
        F[(Payment DB)]
    end
    A --> B
    B --> C
    B --> D
    C --> E
    D --> F
    C -. async events .-> D

Halt d'Resultat an engem Architecture Decision Record fest, sou datt déi nächst Sessioun — Mënsch oder Agent — mam selwechte Kontext ufänkt:

# ADR-007: Move checkout to async messaging

## Status
Proposed

## Context
Checkout currently calls the payment service synchronously over REST.
Under peak load this couples availability and pushes latency past SLO.

## Decision
Publish an OrderPlaced event to the broker; the payment service consumes
it and publishes PaymentCaptured. Use an outbox pattern for reliability.

## Consequences
- Lower coupling and better tail latency.
- New failure modes need a dead-letter queue and idempotent consumers.

4. Entwécklung

E produktiounsreif CLAUDE.md ass de gréissten Hebel fir konsistent Resultater. Et codéiert Build-Kommandoen, Architektur, Sécherheetsreegelen a Stil, sou datt all Sessioun vun Äre Standards ausgeet:

# CLAUDE.md

## Build & test
- `dotnet build` — build the solution (src/Orders.sln)
- `dotnet test` — run the xUnit suite
- `dotnet format` — apply code style from .editorconfig
- `dotnet ef migrations add <Name>` — add an EF Core migration

## Architecture
- `src/Orders.Api` — HTTP API (ASP.NET Core minimal APIs)
- `src/Orders.Application` — use cases, no I/O
- `src/Orders.Infrastructure` — EF Core, Azure Service Bus
- `src/Orders.Domain` — entities and value objects, no dependencies
- `tests/Orders.UnitTests` — one xUnit project per layer

## Security rules (never break these)
- Never log or commit secrets, tokens, or appsettings.Production.json
- Use parameterized queries; never concatenate SQL strings
- Do not add a package without mentioning it in the summary

## Testing
- New code ships with unit tests (xUnit + FluentAssertions)
- Mock external calls (HTTP, DB) — no network in unit tests
- Integration tests use Testcontainers

## Style
- Enable nullable reference types in every project
- Prefer records for DTOs and primary constructors for services
- Comments only explain "why", never "what"

Widderhuelbar Routinen ginn zu Skills. Schreift d'Prozedur eemol a léist se iwwer den Numm aus:

---
name: write-tests
description: Add unit tests for a changed class following project conventions.
---

1. Read the diff and find every public method that changed.
2. Write an xUnit test (with FluentAssertions) for the happy path plus one edge case each.
3. Mock dependencies with NSubstitute — no real I/O.
4. Run `dotnet test` and fix anything red before reporting.

Schwéier, isoléiert Aufgabe ginn un Subagents mat engem enken Toolset, fir d'Haaptsessioun fokusséiert a bëlleg ze halen:

---
name: code-reviewer
description: Expert reviewer for pull requests.
tools: Read, Grep, Bash
model: sonnet
---

Review the diff for correctness, performance, and security.
Return findings ordered by severity (blocker, major, minor).

Heefeg Prompts ginn zu Slash Commands, an $ARGUMENTS mécht se komposéierbar am ganze Code:

---
description: Generate unit tests for a given file.
---

Read the file at $ARGUMENTS and its dependencies. Write an xUnit
test at `tests/` covering the public methods, the happy path, and
one failure case. Run `dotnet test` and fix anything red.

5. Tester

Maacht Test-driven Development als enk Loop: Dir schreift den Test, deen feeler, de Claude implementéiert de minimale Fix, an d'Suite ass de Kontrakt. Iteréiert bis gréng, da refaktoréiert:

flowchart LR
    W[Write failing test] --> R[Claude implements]
    R --> G{Suite green?}
    G -- No --> F[Claude fixes]
    F --> G
    G -- Yes --> RF[Refactor & review]
    RF --> W

Act as the implementer. I have written this failing xUnit test:

<test code>

Implement the minimal change that makes it pass. Do not add features
the test does not require. Run `dotnet test` and confirm green.

Ier Dir merged, gitt den Diff un e Review-Subagent. E kontrolléiert Richtegkeet, Sécherheet a Konventiounen, ouni Är eegen Opmierksamkeet ze verbrennen.

6. CI/CD a Release

De Claude Code gehéiert an de Pipeline. E Merge geschitt eréischt no Lint, Tester, Sécherheetsscan an automatescher Review — dann Deployment mat Smoke-Test a Rollback-Wee:

flowchart LR
    PR[Pull request] --> L[Lint & typecheck]
    L --> T[Unit tests]
    T --> S[Security scan]
    S --> R[Claude Code review]
    R --> M[Merge]
    M --> D[Deploy]
    D --> P[Smoke tests]
    P --> V{Pass?}
    V -- No --> RB[Rollback]
    V -- Yes --> O[Release]

name: Claude Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v4
        with:
          dotnet-version: 8.0.x
      - run: dotnet restore
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: >
            Review the changes in this pull request. Summarize the
            behaviour change, flag correctness and security issues,
            and post inline comments on the files.

Den Headless-Modus mécht den Agent skriptbar, sou datt Release-Checklisten an eemoleg Migratiounen aus dem Terminal oder engem Workflow-Schrëtt lafen:

claude -p "Run the release checklist and report failures" \
  --output-format stream-json \
  --permission-mode acceptEdits

Hooks setzen d'Politik um Tool-Niveau duerch a blockéieren geféierlech Kommandoen, ier se lafen:

#!/usr/bin/env bash
# .claude/hooks/guard.sh — block destructive commands
set -euo pipefail

read -r INPUT

if echo "$INPUT" | grep -qE 'rm -rf|git push --force|DROP TABLE'; then
  echo "Blocked a potentially destructive command." >&2
  exit 2
fi

exit 0

7. Betrib an Ënnerhalt

Bei On-Call verbënnt de Claude mat dem Code, der Datebank an dem Ticketing-System iwwer MCP, da frot en, en Incident ze triagen, wéi e Senior-Ingenieur et géif:

flowchart LR
    CC[Claude Code] <-->|MCP| GH[GitHub MCP]
    CC <-->|MCP| DB[(Database MCP)]
    CC <-->|MCP| TK[Ticketing MCP]

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "<token>" }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost:5432/app"]
    }
  }
}

Wann d'Servere vun der Stang net duerginn, baut Ären eegene mam offiziellen SDK. E Server exponéiert typiséiert Tools, déi de Claude opriffe kann:

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
import { z } from 'zod'

const server = new McpServer({ name: 'ticketing', version: '1.0.0' })

server.tool(
  'search_tickets',
  'Search support tickets by keyword',
  { query: z.string().describe('Search term') },
  async ({ query }) => {
    const rows = await db.tickets.find({ subject: { $like: `%${query}%` } })
    return { content: [{ type: 'text', text: JSON.stringify(rows, null, 2) }] }
  },
)

const transport = new StdioServerTransport()
await server.connect(transport)

Zum Schluss

Behandelt de Claude Code als Teammember iwwer de ganzen SDLC: kloert Ufuerderungen, sequenzéiert de Plang, iwwerpréift den Design, implementéiert an testt, séchert de Merge a triagéiert an der Produktioun. D'Experten, déi am meeschten erauskréien, sinn déi, déi de Kontext definéieren, hir Standards codéieren an op all Entscheidungspunkt am Loop bleiwen.