From thommann-skills
Write, edit, or review chapters of an arc42 architecture documentation. Use when user says 'write arc42', 'update the architecture documentation', 'fill out chapter 5', 'arc42 chapter', 'architecture docs', or 'document our building blocks'. Do NOT use for ADRs (use document-decision — ADRs belong inside arc42 chapter 9) or user-facing feature docs (use document-feature).
How this skill is triggered — by the user, by Claude, or both
Slash command
/thommann-skills:arc42This skill is limited to the following tools:
The summary Claude sees in its skill listing — used to decide when to auto-load this skill
arc42 is a lightweight architecture documentation template with 12 chapters. Each chapter has a defined purpose; filling them in order produces a coherent architecture document a newcomer can read end-to-end.
arc42 is a lightweight architecture documentation template with 12 chapters. Each chapter has a defined purpose; filling them in order produces a coherent architecture document a newcomer can read end-to-end.
docs/arc42/).docs/arc42/ or equivalent — the project's existing arc42 tree. Find with find . -type d -name 'arc42*'.CLAUDE.md Architecture section — often duplicates chapter 5 content; sync as you edit.If the project has no arc42 tree yet, confirm with the user that arc42 is the right framework before creating one. Alternatives: C4 model, minimal ARCHITECTURE.md, or a single page in the docs site.
| # | Chapter | What belongs here | Quality criterion |
|---|---|---|---|
| 1 | Introduction and Goals | Top 3 business goals, top 3 quality attributes, key stakeholders | Any newcomer understands WHY this system exists in 5 minutes |
| 2 | Constraints | Technical, organizational, and regulatory constraints imposed from outside | Reader knows which rules are non-negotiable |
| 3 | Context and Scope | System boundary: users, external systems, their interactions | Clear line between "our system" and "not our system" |
| 4 | Solution Strategy | The 5–10 load-bearing architectural decisions, with 1-line rationale each | Reader grasps the shape without reading chapters 5–10 |
| 5 | Building Block View | Static structure: components and their relationships, at multiple zoom levels | A dev knows which component owns a given concern |
| 6 | Runtime View | Sequence diagrams for 3–5 important scenarios | Reader understands dynamic behavior for critical flows |
| 7 | Deployment View | Where the software runs, in what topology | On-call engineer knows what's where |
| 8 | Cross-cutting Concepts | Patterns applied across the system (auth, logging, error handling, i18n) | One place to learn "how we do X" |
| 9 | Architecture Decisions | ADRs — each an immutable record | Decisions are traceable with their context |
| 10 | Quality Requirements | Measurable quality attributes with scenarios | Quality goals are testable |
| 11 | Risks and Technical Debt | Known risks, debt items, mitigations | Team and sponsors see what's parked and why |
| 12 | Glossary | Terms with precise definitions | Ambiguous language has a single meaning |
find . -type d -name 'arc42*' -not -path '*/node_modules/*'
# Common: docs/arc42/ OR documentation/arc42/
Inside the tree, you usually find one file per chapter: 01-introduction.md … 12-glossary.md. Some projects use full chapter names in filenames.
Ask: what is the user asking for, or what did this PR change?
document-decision).Chapter 1 — avoid aspirational prose. "We want to be the best" is not a goal; "p99 latency under 500ms for tier-1 queries" is.
Chapter 4 — 5–10 decisions, one line of rationale each. If you're writing paragraphs here, move them into ADRs (chapter 9) and summarize.
Chapter 5 — use diagrams (Mermaid, PlantUML, SVG). Text alone loses the structure. Label every component and arrow.
Chapter 6 — sequence diagrams. Three to five scenarios is enough; more dilutes. Pick scenarios that exercise chapter 5's interactions.
Chapter 7 — include a real deployment diagram with the actual hosts/containers/services, not an idealized one.
Chapter 8 — one subsection per concern: auth, logging, config, error handling, i18n, caching. Name files if a concern has a canonical implementation (src/lib/errors/index.ts).
Chapter 9 — one file per ADR, linked from the chapter index. Use document-decision for the ADR body.
Chapter 10 — quality scenarios in the form "when X happens, system responds with Y within Z." Non-testable quality goals are wishes.
Chapter 11 — risks have likelihood + impact + mitigation. "Might become slow" is not a risk — "if monthly active users exceed 100k, database writes will bottleneck; mitigation: shard user table" is.
Chapter 12 — one line per term, ordered alphabetically.
The root CLAUDE.md "Architecture" section is a condensed summary of arc42 chapters 3–5. When you edit those chapters substantially, re-scan CLAUDE.md for drift:
# The edited chapter has the right section structure
# (most chapters have sub-headings like ### Building blocks, ### Interfaces)
grep -c '^##\? ' docs/arc42/<chapter>.md
# Expected: several — chapter content has subsections.
# Links between chapters resolve
grep -oE '\[([^]]+)\]\(([^)]+\.md[^)]*)\)' docs/arc42/<chapter>.md | while read link; do
# Relative path check
target=$(echo "$link" | sed -E 's/.*\(([^)]+)\).*/\1/' | cut -d'#' -f1)
[ -n "$target" ] && [ ! -f "docs/arc42/$target" ] && echo "BROKEN: $link"
done
# Docs site builds (project-specific command)
| Mistake | Correction |
|---|---|
| Filling every chapter because the template has 12 | Chapters are optional if empty. Better to have 8 load-bearing chapters than 12 skeleton-filled ones. |
| Treating chapter 4 and chapter 9 as the same | Chapter 4 is a summary (5–10 one-liners). Chapter 9 is ADRs (full immutable records). Both exist. |
| Chapter 5 with no diagram | The static structure is a diagram first, prose second. Add one (Mermaid or PlantUML). |
| Quality goals as adjectives | "Fast" is not a quality goal. Write it as a scenario: "when user clicks X, UI responds within 100ms at p95". |
npx claudepluginhub thommann/skills --plugin thommann-skillsGuides creation, editing, and verification of skills for AI coding agents using test-driven development with subagent scenarios. Use when authoring or debugging skills.