Communitygithub.com

Architektur-Entscheidungsprotokolle

Erfasse und dokumentiere Architekturentscheidungen aus Claude Code-Sitzungen als strukturierte ADRs. Erkennt Entscheidungsmomente automatisch, zeichnet Kontext, Alternativen und Begründung auf und pflegt ein ADR-Log, damit zukünftige Entwickler verstehen, warum die Codebasis so geformt ist wie sie ist.

Was ist Architektur-Entscheidungsprotokolle?

Dieses Skill für KI-Agenten (wie Claude Code, Cursor, Codex) erfasst Architekturentscheidungen während der Entwicklung als strukturierte Architecture Decision Records (ADRs). Es erkennt sowohl explizite als auch implizite Entscheidungssignale – etwa die Wahl zwischen Frameworks, Datenbanken oder Mustern – und erstellt standardisierte ADR-Dokumente im Format nach Michael Nygard. Das Skill legt Wert auf Benutzerkontrolle: Es schlägt ADRs vor, schreibt sie aber erst nach expliziter Freigabe. Es pflegt zudem ein versioniertes Index in `docs/adr/README.md`, unterstützt den gesamten ADR-Lebenszyklus (proposed → accepted → deprecated/superseded) und enthält eine detaillierte Entscheidungsmatrix, welche Kategorien (Technologie, Architektur, API, Datenmodell, Infrastruktur usw.) dokumentiert werden sollten. Es integriert sich mit Planungs- und Code-Review-Agenten, um Architekturänderungen systematisch nachvollziehbar zu machen.

Funktioniert mit✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/affaan-m/everything-claude-code/tree/main/skills/architecture-decision-records

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Architecture Decision Records (Architektur-Entscheidungsprotokolle)

Erfasse Architekturentscheidungen, während sie in Codierungssitzungen getroffen werden. Anstatt dass Entscheidungen nur in Slack-Threads, PR-Kommentaren oder in der Erinnerung einer Person leben, produziert dieses Skill strukturierte ADR-Dokumente, die direkt im Code liegen.

Wann zu aktivieren

  • Benutzer sagt explizit "lass uns diese Entscheidung festhalten" oder "ADR das"
  • Benutzer wählt zwischen bedeutenden Alternativen (Framework, Bibliothek, Muster, Datenbank, API-Design)
  • Benutzer sagt "wir haben uns entschieden..." oder "der Grund, warum wir X statt Y machen, ist..."
  • Benutzer fragt "warum haben wir X gewählt?" (vorhandene ADRs lesen)
  • Während Planungsphasen, wenn architektonische Abwägungen diskutiert werden

ADR-Format

Verwende das von Michael Nygard vorgeschlagene leichte ADR-Format, angepasst für KI-gestützte Entwicklung:

# ADR-NNNN: [Entscheidungstitel]

**Datum**: JJJJ-MM-TT
**Status**: vorgeschlagen | akzeptiert | veraltet | ersetzt durch ADR-NNNN
**Entscheider**: [wer beteiligt war]

## Kontext

Was ist das Problem, das diese Entscheidung oder Änderung motiviert?

[2-5 Sätze, die die Situation, Randbedingungen und Kräfte beschreiben]

## Entscheidung

Was ist die Änderung, die wir vorschlagen und/oder durchführen?

[1-3 Sätze, die die Entscheidung klar darlegen]

## Alternativen in Betracht gezogen

### Alternative 1: [Name]
- **Vorteile**: [Nutzen]
- **Nachteile**: [Nachteile]
- **Warum nicht**: [spezifischer Grund für die Ablehnung]

### Alternative 2: [Name]
- **Vorteile**: [Nutzen]
- **Nachteile**: [Nachteile]
- **Warum nicht**: [spezifischer Grund für die Ablehnung]

## Konsequenzen

Was wird durch diese Änderung leichter oder schwieriger?

### Positive
- [Nutzen 1]
- [Nutzen 2]

### Negative
- [Kompromiss 1]
- [Kompromiss 2]

### Risiken
- [Risiko und Minderung]

Arbeitsablauf

Erfassen einer neuen ADR

Wenn ein Entscheidungsmoment erkannt wird:

  1. Initialisieren (nur beim ersten Mal) — falls docs/adr/ nicht existiert, den Benutzer um Bestätigung bitten, bevor das Verzeichnis, eine README.md mit dem Index-Tabellenkopf (siehe ADR-Index-Format unten) und eine leere template.md für die manuelle Nutzung erstellt wird. Keine Dateien ohne explizite Zustimmung erstellen.
  2. Entscheidung identifizieren — die Kern-Architekturentscheidung extrahieren
  3. Kontext sammeln — welches Problem hat dazu geführt? Welche Randbedingungen gibt es?
  4. Alternativen dokumentieren — welche anderen Optionen wurden in Betracht gezogen? Warum wurden sie abgelehnt?
  5. Konsequenzen angeben — was sind die Abwägungen? Was wird einfacher/schwieriger?
  6. Nummer zuweisen — vorhandene ADRs in docs/adr/ scannen und erhöhen
  7. Bestätigen und schreiben — den ADR-Entwurf dem Benutzer zur Überprüfung vorlegen. Nur nach expliziter Genehmigung in docs/adr/NNNN-entscheidungstitel.md schreiben. Falls der Benutzer ablehnt, den Entwurf verwerfen, ohne Dateien zu schreiben.
  8. Index aktualisieren — an docs/adr/README.md anhängen

Vorhandene ADRs lesen

Wenn ein Benutzer fragt "warum haben wir X gewählt?":

  1. Prüfen, ob docs/adr/ existiert — falls nicht, antworten: "In diesem Projekt wurden keine ADRs gefunden. Möchten Sie beginnen, Architekturentscheidungen zu dokumentieren?"
  2. Falls ja, den Index docs/adr/README.md nach relevanten Einträgen durchsuchen
  3. Passende ADR-Dateien lesen und die Abschnitte Kontext und Entscheidung präsentieren
  4. Falls keine Übereinstimmung gefunden wird, antworten: "Für diese Entscheidung wurde kein ADR gefunden. Möchten Sie jetzt einen aufnehmen?"

ADR-Verzeichnisstruktur

docs/
└── adr/
    ├── README.md              ← Index aller ADRs
    ├── 0001-use-nextjs.md
    ├── 0002-postgres-over-mongo.md
    ├── 0003-rest-over-graphql.md
    └── template.md            ← leere Vorlage für manuelle Nutzung

ADR-Index-Format

# Architecture Decision Records

| ADR | Titel | Status | Datum |
|-----|-------|--------|-------|
| [0001](0001-use-nextjs.md) | Next.js als Frontend-Framework verwenden | akzeptiert | 2026-01-15 |
| [0002](0002-postgres-over-mongo.md) | PostgreSQL statt MongoDB als primären Datenspeicher | akzeptiert | 2026-01-20 |
| [0003](0003-rest-over-graphql.md) | REST-API statt GraphQL | akzeptiert | 2026-02-01 |

Signale zur Entscheidungserkennung

Achte in der Konversation auf folgende Muster, die auf eine Architekturentscheidung hindeuten:

Explizite Signale

  • "Lass uns mit X gehen"
  • "Wir sollten X statt Y verwenden"
  • "Der Kompromiss lohnt sich, weil..."
  • "Halte das als ADR fest"

Implizite Signale (schlage vor, eine ADR aufzuzeichnen — erstelle keine automatisch ohne Benutzerbestätigung)

  • Vergleich zweier Frameworks oder Bibliotheken mit Schlussfolgerung
  • Treffen einer Datenbankschema-Designentscheidung mit angegebener Begründung
  • Wahl zwischen Architekturmustern (Monolith vs. Microservices, REST vs. GraphQL)
  • Entscheidung über Authentifizierungs-/Autorisierungsstrategie
  • Auswahl der Bereitstellungsinfrastruktur nach Bewertung von Alternativen

Was eine gute ADR ausmacht

Mach

  • Sei spezifisch — "Prisma ORM verwenden" nicht "ein ORM verwenden"
  • Halte das Warum fest — die Begründung ist wichtiger als das Was
  • Schließe abgelehnte Alternativen ein — zukünftige Entwickler müssen wissen, was in Betracht gezogen wurde
  • Formuliere Konsequenzen ehrlich — jede Entscheidung hat Abwägungen
  • Halte es kurz — eine ADR sollte in 2 Minuten lesbar sein
  • Verwende die Gegenwart — "Wir verwenden X" nicht "Wir werden X verwenden"

Mach nicht

  • Halte triviale Entscheidungen nicht fest — Variablenbenennung oder Formatierungsentscheidungen brauchen keine ADRs
  • Schreibe keine Aufsätze — wenn der Kontextabschnitt mehr als 10 Zeilen überschreitet, ist er zu lang
  • Lasse Alternativen nicht aus — "wir haben es einfach so gewählt" ist keine gültige Begründung
  • Fülle nicht nach, ohne es zu kennzeichnen — wenn eine vergangene Entscheidung festgehalten wird, notiere das ursprüngliche Datum
  • Lasse ADRs nicht veralten — überholte Entscheidungen sollten auf ihren Ersatz verweisen

ADR-Lebenszyklus

vorgeschlagen → akzeptiert → [veraltet | ersetzt durch ADR-NNNN]
  • vorgeschlagen: Entscheidung wird diskutiert, noch nicht festgelegt
  • akzeptiert: Entscheidung ist in Kraft und wird befolgt
  • veraltet: Entscheidung ist nicht mehr relevant (z.B. Funktion entfernt)
  • ersetzt: eine neuere ADR ersetzt diese (immer auf den Ersatz verlinken)

Kategorien von dokumentationswürdigen Entscheidungen

KategorieBeispiele
TechnologieentscheidungenFramework, Sprache, Datenbank, Cloud-Provider
ArchitekturmusterMonolith vs. Microservices, ereignisgesteuert, CQRS
API-DesignREST vs. GraphQL, Versionierungsstrategie, Auth-Mechanismus
DatenmodellierungSchema-Design, Normalisierungsentscheidungen, Caching-Strategie
InfrastrukturBereitstellungsmodell, CI/CD-Pipeline, Monitoring-Stack
SicherheitAuth-Strategie, Verschlüsselungsansatz, Geheimnisverwaltung
TestsTest-Framework, Abdeckungsziele, E2E- vs. Integration-Test-Ausgleich
ProzessBranching-Strategie, Review-Prozess, Release-Rhythmus

Integration mit anderen Skills

  • Planer-Agent: wenn der Planer Architekturänderungen vorschlägt, das Erstellen einer ADR vorschlagen
  • Code-Reviewer-Agent: PRs markieren, die Architekturänderungen ohne entsprechende ADR einführen

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

accessibility

Design, implement, and audit inclusive digital products using WCAG 2.2 Level AA. Use when building or auditing UI that must meet WCAG 2.2 Level AA, or when reviewing a change for keyboard, contrast, or screen-reader support.

affaan-m/claude-api

Anthropic Claude API patterns for Python and TypeScript. Covers Messages API, streaming, tool use, vision, extended thinking, batches, prompt caching, and Claude Agent SDK. Use when building applications with the Claude API or Anthropic SDKs.

affaan-m/everything-claude-code

End-to-end marketing campaign planning and execution. Covers audience research, positioning, campaign angle definition, landing page copy, email sequences, social posts, ad copy, short-form video scripts, and content calendars. Use as the orchestration layer for multi-channel product launches. Use when planning or executing a multi-channel product launch, or producing landing page, email, social, or ad copy.

affaan-m/everything-claude-code

Development conventions and patterns for everything-claude-code. JavaScript project with conventional commits.

affaan-m/everything-claude-code-conventions

Development conventions and patterns for everything-claude-code. JavaScript project with conventional commits.

affaan-m/frontend-design

Create distinctive, production-grade frontend interfaces with high design quality. Use when the user asks to build web components, pages, or applications and the visual direction matters as much as the code quality.

affaan-m/gget

gget CLI and Python workflow for quick genomic database queries, sequence lookup, BLAST-style searches, enrichment checks, and reproducible bioinformatics evidence logs.

affaan-m/literature-review

Systematic literature-review workflow for academic, biomedical, technical, and scientific topics, including search planning, source screening, synthesis, citation checks, and evidence logging.

affaan-m/motion-ui

Production-ready UI motion system for React/Next.js. Use when implementing animations, transitions, or motion patterns.

affaan-m/project-guidelines-example

Example project-specific skill template based on a real production application.

affaan-m/pubmed-database

Direct PubMed and NCBI E-utilities search workflows for biomedical literature, MeSH queries, PMID lookup, citation retrieval, and API-backed literature monitoring.

affaan-m/scholar-evaluation

Structured scholarly-work evaluation for papers, proposals, literature reviews, methods sections, evidence quality, citation support, and research-writing feedback.

affaan-m/uspto-database

USPTO patent and trademark data workflow for official record lookup, PatentSearch queries, TSDR checks, assignment data, and reproducible IP research logs.

agent-architecture-audit

Full-stack diagnostic for agent and LLM applications. Audits the 12-layer agent stack for wrapper regression, memory pollution, tool discipline failures, hidden repair loops, and rendering corruption. Produces severity-ranked findings with code-first fixes. Essential for developers building agent applications, autonomous loops, or any LLM-powered feature. Use when an agent or LLM feature misbehaves and the failing layer is unknown, or before shipping an agent stack.

agent-eval

Head-to-head comparison of coding agents (Claude Code, Aider, Codex, etc.) on custom tasks with pass rate, cost, time, and consistency metrics. Use when choosing between coding agents, or when a change to an agent setup needs measured pass rate, cost, and time rather than an impression.

agent-harness-construction

Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates. Use when defining or revising an agent

agentic-engineering

Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. Use when planning or executing engineering work that agents will carry out end to end.

agentic-os

Build persistent multi-agent operating systems on Claude Code. Covers kernel architecture, specialist agents, slash commands, file-based memory, scheduled automation, and state management without external databases. Use when building a persistent multi-agent system on Claude Code with its own memory, commands, and scheduling.

agent-introspection-debugging

Structured self-debugging workflow for AI agent failures using capture, diagnosis, contained recovery, and introspection reports. Use when an agent run fails and you need a reproducible diagnosis instead of a retry.

agent-payment-x402

Add x402 payment execution to AI agents with per-task budgets, spending controls, and non-custodial wallets. Supports Base through agentwallet-sdk and X Layer through OKX Payments / OKX Agent Payments Protocol. Use when an agent must pay for something itself and needs per-task budgets, spending controls, and a non-custodial wallet.

Verwandte Skills