create-adr

OverviewHistoryStatsSecurity

npx skills add ...

Documentation

SKILL.md

Creates Architecture Decision Records (ADRs) to document significant architectural choices and their rationale for future team members. Use when the user says "write an ADR", "document this decision", "record why we chose X", "add an architecture decision record", "create an ADR for", or wants to capture the reasoning behind a technical choice so the team understands it later. Do NOT use when the decision hasn't been made yet (use create-rfc instead), for implementation planning (use technical-design-doc-creator), or for general documentation.

npx skills add tech-leads-club/agent-skills --skill create-adr

Documentation

SKILL.mdView source

ADR Creator

You are an expert in creating Architecture Decision Records (ADRs) — concise, durable documents that capture the context, decision, and consequences of significant architectural choices so future team members understand why things are the way they are.

When to Use This Skill

Use this skill when:

User asks to "write an ADR", "create an ADR", "add an architecture decision record"
User wants to "document why we chose X", "record this decision", "capture this architectural choice"
A significant technical decision has been made (or is being finalized) and needs to be recorded
The team wants to preserve the reasoning behind a choice for future engineers
User asks "why did we choose X" and the answer should be written down permanently

Do NOT use for:

Decisions not yet made — use create-rfc to drive the decision process first
Implementation planning after the decision — use technical-design-doc-creator
Simple configuration choices or trivial code decisions
Meeting notes or general documentation

ADR vs RFC — Critical Distinction

Aspect	ADR	RFC
Timing	Decision already made (or being finalized)	Before the decision (seeking input)
Purpose	Record for future team members	Proposal seeking approval
Audience	Engineers joining months or years later	Current stakeholders
Length	Short — 200–500 words	Long — thorough comparison
Mutability	Immutable — superseded, never edited	Iterative — evolves during review
Tone	Historical record	Deliberative proposal

If the user says "I need to decide whether to do X" → use create-rfc. If the user says "We decided to do X, let me document it" → use this skill.

Language Adaptation

CRITICAL: Always generate the ADR in the same language as the user's request. Detect the language automatically.

Keep technical terms in English when appropriate (e.g., "ADR", "API", "microservices")
All section headers and content should be in the user's language
Company/product names remain in original form

ADR Format Selection

Three formats are widely used. Detect the right one from context, or ask:

Format	Best For	Length
MADR (Markdown ADR)	Teams that want structured options comparison	Medium
Nygard (original)	Minimal, fast recording; obvious decisions	Short
Y-Statement	Inline documentation, very compact contexts	One paragraph

Default to MADR unless the user specifies otherwise or the decision is very simple.

Interactive Workflow

Step 1: Gather Context (if not provided)

If the user provides minimal context, use AskQuestion to collect essential information:

{
  "title":

Step 2: Validate Mandatory Fields

MANDATORY fields — ask if missing:

Decision title (noun phrase, not a question — e.g., "Use Redis for session storage")
Date of the decision (or today's date)
Status (Accepted / Proposed / Deprecated / Superseded)
Context — the forces, constraints, and situation that made this decision necessary
The decision itself — what was chosen and why
Consequences — what becomes easier, harder, or different as a result

RECOMMENDED fields:

Decision drivers — the key criteria or constraints
Options considered — what alternatives were evaluated
Pros/cons per option — honest trade-off assessment
Decision outcome rationale — why this option over the others
Links — related ADRs, RFCs, tickets, or documentation

If any mandatory fields are missing, ask IN THE USER'S LANGUAGE before generating the document.

Step 3: Assign ADR Number

Scan the existing ADR directory for the next sequential number:

Check if an ADR directory exists (docs/adr/, docs/decisions/, .adr/, or adr/)
Find the highest existing number
Assign the next number (e.g., if ADR-007 exists, this becomes ADR-008)
If no directory exists, start at ADR-001 and suggest creating the directory

Step 4: Generate the ADR

Generate the ADR following the format selected in Step 1.

Step 5: Offer File Placement

After generating, ask where to save it:

Document Templates

MADR Format (Default)

Nygard Format (Minimal)

Y-Statement Format (Compact)

ADR Quality Checklist

Before finalizing, verify:

ADR File Naming Convention

Zero-padded numbers: 001, 002, ... 099, 100
Kebab-case title
.md extension
Common directories: docs/adr/, docs/decisions/, adr/, .adr/

Common Anti-Patterns to Avoid

Title as a Question

BAD: # ADR-001: Should we use PostgreSQL?

GOOD: # ADR-001: Use PostgreSQL for Primary Storage

Titles should record the decision, not the question. Future readers need to know what was decided, not what was considered.

Vague Context

BAD:

GOOD:

Context should explain the forces — why wasn't the alternative obviously better?

Consequences Without Trade-offs

BAD:

GOOD:

Honest trade-offs are what make ADRs valuable years later.

Editing Instead of Superseding

BAD: Editing an old ADR to change the decision after the fact.

GOOD: Creating a new ADR with Status: Superseded by ADR-{NNN} on the old one and linking back.

ADRs are historical records. The old decision was correct given what was known at the time. Superseding preserves that context.

Missing the "Why Not" Rationale

BAD:

GOOD:

The rationale is why this option and not the others — not just what was chosen.

Important Notes

ADRs are immutable — never edit the decision. Supersede with a new ADR.
Short is better — 200–500 words is ideal. If it needs to be longer, move detail to a linked TDD or RFC.
Context ages — always date the ADR; what seems obvious now won't be in 3 years.
Honest consequences — a one-sided ADR loses credibility. Future engineers will hit the downsides regardless.
Link everything — related ADRs, the RFC that drove the decision, tickets, PR references.
Language adaptation — always write in the user's language.
Number sequentially — check the directory before assigning a number.

Example Prompts that Trigger This Skill

English

"Write an ADR for using PostgreSQL as our primary database"
"Document our decision to adopt GraphQL"
"Create an ADR for moving our frontend to Next.js"
"I need to record why we chose Kafka over RabbitMQ"
"Add an architecture decision record for our authentication approach"

Portuguese

"Escreva um ADR sobre a decisão de usar PostgreSQL"
"Documente a decisão de adotar GraphQL no projeto"
"Crie um ADR explicando por que escolhemos Kafka"

Spanish

"Escribe un ADR sobre la decisión de usar PostgreSQL"
"Documenta la decisión de adoptar microservicios"
"Crea un ADR explicando por qué elegimos Next.js"

npx skills add tech-leads-club/agent-skills --skill create-adr

Documentation

SKILL.md

create-adr skill by tech-leads-club | SkillBundle

ADR Created: "ADR-{NNN}: {Title}"

Suggested file path: docs/adr/{NNN}-{kebab-case-title}.md

Would you like me to:
1. Save it to docs/adr/ (recommended convention)
2. Save it to a different location
3. Just show the content (I'll place it manually)

# ADR-{NNN}: {Title}
 
- **Date**: YYYY-MM-DD
- **Status**: Accepted | Proposed | Deprecated | Superseded by [ADR-NNN]({link})
- **Deciders**: {who was involved in the decision}
- **Tags**: {optional: architecture, security, performance, database, etc.}
 
## Context and Problem Statement
 
{Describe the context and the problem or question that led to this decision.
2–4 sentences. What situation forced this choice?}
 
## Decision Drivers
 
- {Driver 1 — e.g., "Must support 10k concurrent users"}
- {Driver 2 — e.g., "Team has no Go experience"}
- {Driver 3 — e.g., "Must be deployable on-premise"}
 
## Considered Options
 
- {Option A}
- {Option B}
- {Option C — "Do nothing / status quo" when relevant}
 
## Decision Outcome
 
Chosen option: **"{Option A}"**, because {concise rationale tied to decision drivers}.
 
### Positive Consequences
 
- {Benefit 1}
- {Benefit 2}
 
### Negative Consequences
 
- {Trade-off 1 — be honest}
- {Trade-off 2}
 
## Pros and Cons of the Options
 
### {Option A} ✅ Chosen
 
- ✅ {Pro 1}
- ✅ {Pro 2}
- ❌ {Con 1}
 
### {Option B}
 
- ✅ {Pro 1}
- ❌ {Con 1}
- ❌ {Con 2}
 
### {Option C}
 
- ✅ {Pro 1}
- ❌ {Con 1}
 
## Links
 
- {Related ADR, RFC, ticket, or documentation}
- Supersedes: [ADR-{NNN}: {Title}]({link}) (if applicable)
- Superseded by: [ADR-{NNN}: {Title}]({link}) (if applicable)

# ADR-{NNN}: {Title}
 
## Status
 
Accepted | Proposed | Deprecated | Superseded by ADR-{NNN}
 
## Context
 
{What is the situation that led to this decision?
What forces are at play — technical, business, organizational?
What constraints exist? 2–5 sentences.}
 
## Decision
 
{What did we decide to do?
State it directly, in active voice: "We will use X" or "We decided to adopt Y."
Include a brief rationale — why this option over the alternatives.}
 
## Consequences
 
{What becomes easier or better as a result?}
{What becomes harder or worse? Be honest about trade-offs.}
{What new concerns or constraints does this introduce?}

# ADR-{NNN}: {Title}
 
**Date**: YYYY-MM-DD | **Status**: Accepted
 
In the context of **{situation/use case}**,
facing **{concern or constraint}**,
we decided **{the option chosen}**,
to achieve **{quality attribute or goal}**,
accepting **{the downside or trade-off}**.
 
**Deciders**: {names or roles}
**Links**: {related ADRs, tickets}

docs/adr/
├── 001-use-postgresql-for-primary-storage.md
├── 002-adopt-event-driven-architecture.md
├── 003-replace-jenkins-with-github-actions.md   ← supersedes ADR-001 if relevant
└── README.md                                     ← optional index

We needed a database and chose PostgreSQL.

Our application requires a relational database with strong ACID guarantees.
The team has deep PostgreSQL experience. MySQL was evaluated but lacks
native support for JSONB columns, which our schema design requires.
Our cloud provider (AWS) offers managed PostgreSQL via RDS at acceptable cost.

## Consequences
PostgreSQL is fast and reliable.

## Consequences
- Enables JSONB columns and advanced indexing for our query patterns
- Team expertise means fast onboarding and fewer operational surprises
- Adds operational burden compared to a managed NoSQL service
- Schema migrations require careful planning in a relational model

## Decision
We will use Redis for session storage.

## Decision
We will use Redis for session storage. We considered storing sessions in PostgreSQL
(already in our stack) but Redis's built-in TTL support and in-memory performance
make it significantly better suited for high-frequency session reads. The operational
cost of an additional service is justified by the simplified session expiry logic.