Creates Architecture Decision Records (ADRs) to document significant architectural choices and their rationale for future team members.

CC-BY-4.0Auto-check passedDevelopment

Install Create Adr

skills CLI
$ npx skills add tech-leads-club/agent-skills --skill create-adr -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install tech-leads-club/agent-skills create-adr --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/tech-leads-club/agent-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/'packages/skills-catalog/skills/(creation)/create-adr' .claude/skills/create-adr && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
create-adr
GitHub stars
7k
Token cost
~3.5k tokens
SKILL.md length
1,043 words
Files
2
Skills in repo
74
Repo updated
First seen
Licence
CC-BY-4.0

At a glance

Creates Architecture Decision Records (ADRs) to document significant architectural choices and their rationale for future team members.

  • Works in 5 steps: Gather Context (if not provided) → Validate Mandatory Fields → Assign ADR Number → …
  • The user says write an ADR
  • SKILL.md covers When to Use This Skill, ADR vs RFC — Critical…, Language Adaptation and ADR Format Selection, plus 7 more sections
  • Calls make

What it does

Create Adr is an agent skill from tech-leads-club/agent-skills. 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…

Its SKILL.md is about 3.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 1 other file (for example `README.md`).

It sits in Development, covering Architecture decision records. The repository describes itself as: The secure, validated skill registry for professional AI coding agents. Extend Antigravity, Claude Code, Cursor, Copilot and more with absolute confidence. The licence is CC-BY-4.0.

When your agent uses it

  • The user says write an ADR
  • Document this decision
  • Record why we chose X
  • Add an architecture decision record

Example prompts

  • “write an ADR”
  • “document this decision”
  • “record why we chose X”
  • “/create-adr”

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Gather Context (if not provided)
  2. Validate Mandatory Fields
  3. Assign ADR Number
  4. Generate the ADR
  5. Offer File Placement

What it can do on your machine

Read from SKILL.md and the folder at commit 6df68d5. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • make

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Create Adr loads about 3.5k tokens when it runs. Until then it costs about 140 tokens; SKILL.md has 1,043 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~140
When it runs · the whole SKILL.md, loaded when a task matches
~3.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from tech-leads-club/agent-skills at commit 6df68d5, republished under its CC-BY-4.0 licence (© tech-leads-club). 1,043 words, ~3,460 tokens.

Download SKILL.mdSave it as .claude/skills/create-adr/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
create-adr
description
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.
license
CC-BY-4.0
metadata.author
Tech Leads Club - github.com/tech-leads-club
metadata.version
1.0.0

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

AspectADRRFC
TimingDecision already made (or being finalized)Before the decision (seeking input)
PurposeRecord for future team membersProposal seeking approval
AudienceEngineers joining months or years laterCurrent stakeholders
LengthShort — 200–500 wordsLong — thorough comparison
MutabilityImmutable — superseded, never editedIterative — evolves during review
ToneHistorical recordDeliberative 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:

FormatBest ForLength
MADR (Markdown ADR)Teams that want structured options comparisonMedium
Nygard (original)Minimal, fast recording; obvious decisionsShort
Y-StatementInline documentation, very compact contextsOne 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:

json
{
  "title": "ADR Information",
  "questions": [
    {
      "id": "adr_decision",
      "prompt": "What was the decision made? (e.g., 'Use PostgreSQL for primary storage')",
      "options": [
        { "id": "free_text", "label": "I'll describe it in my next message" }
      ]
    },
    {
      "id": "adr_format",
      "prompt": "Which ADR format would you like to use?",
      "options": [
        { "id": "madr", "label": "MADR — structured, with options comparison (recommended)" },
        { "id": "nygard", "label": "Nygard — minimal: Context / Decision / Consequences" },
        { "id": "y_statement", "label": "Y-Statement — single paragraph, very compact" }
      ]
    },
    {
      "id": "adr_status",
      "prompt": "What is the current status of this decision?",
      "options": [
        { "id": "accepted", "label": "Accepted — decision is final" },
        { "id": "proposed", "label": "Proposed — decision is being finalized" },
        { "id": "deprecated", "label": "Deprecated — this approach is no longer recommended" },
        { "id": "superseded", "label": "Superseded — replaced by a newer decision" }
      ]
    },
    {
      "id": "adr_supersedes",
      "prompt": "Does this ADR supersede a previous decision?",
      "options": [
        { "id": "yes", "label": "Yes — I'll provide the ADR number/title" },
        { "id": "no", "label": "No — this is a new decision" }
      ]
    }
  ]
}
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:

  1. Check if an ADR directory exists (docs/adr/, docs/decisions/, .adr/, or adr/)
  2. Find the highest existing number
  3. Assign the next number (e.g., if ADR-007 exists, this becomes ADR-008)
  4. 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:

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)

Document Templates

MADR Format (Default)
markdown
# 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)

Nygard Format (Minimal)
markdown
# 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?}

Y-Statement Format (Compact)
markdown
# 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}

Show full SKILL.md (459 more words)Show less

ADR Quality Checklist

Before finalizing, verify:

  • Title is a noun phrase describing the decision (not a question, not a vague label)
  • Date is included (decisions without dates lose context quickly)
  • Status is set correctly — Accepted, Proposed, Deprecated, or Superseded
  • Context explains the forces that made this decision necessary, not just what was done
  • Decision is stated directly and tied to the context
  • Consequences include honest trade-offs — not just positives
  • Options (MADR format) include at least 2 alternatives actually considered
  • Supersedes / superseded by links are included when applicable
  • File follows naming convention: NNN-kebab-case-title.md
  • Number is sequential in the ADR directory

ADR File Naming Convention

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
  • 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:

We needed a database and chose PostgreSQL.

GOOD:

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.

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


Consequences Without Trade-offs

BAD:

## Consequences
PostgreSQL is fast and reliable.

GOOD:

## 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

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:

## Decision
We will use Redis for session storage.

GOOD:

## 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.

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"

© tech-leads-club, CC-BY-4.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file in packages/skills-catalog/skills/(creation)/create-adr of tech-leads-club/agent-skills.

  • SKILL.md
  • README.md

Open the folder on GitHubat commit 6df68d5

Compare with similar skills

Create Adr next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Create Adr compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Create Adr this skilltech-leads-club/agent-skills7k—~3.5kAutomated safety check: PassCC-BY-4.0
PR Design DocOpenHands/OpenHands90k—~2.4kAutomated safety check: PassMIT
Cto AdvisorIbrahim-3d/orchestrator-supaconductor3814 repos~2.4kAutomated safety check: PassMIT
Architecture DecisionDonchitos/Claude-Code-Game-Studios26k—~1.7kAutomated safety check: PassMIT
Improve Codebase Architectureywwynm/EverythingDone14415 repos~1.3kAutomated safety check: PassGPL-3.0
Domain Modelingbrim-borium/spotify_sdk1665 repos~806Automated safety check: PassApache-2.0

Similar skills

  • PR Design Doc

    OpenHands/OpenHands

    For a non-trivial pull request, write a self-contained HTML design doc under the temporary .pr/ directory and link a visibility-appropriate preview in the PR description, so maintainers grasp the…

    90k GitHub stars~2.4k tokensUpdated today
    DevelopmentAuto-check passed
  • Cto Advisor

    Ibrahim-3d/orchestrator-supaconductor

    Technical leadership guidance for engineering teams, architecture decisions, and technology strategy.

    381 GitHub starsUsed in 4 repos~2.4k tokens
    DevelopmentAuto-check passed
  • Architecture Decision

    Donchitos/Claude-Code-Game-Studios

    Create an ADR documenting a technical decision: context, alternatives considered, consequences.

    26k GitHub stars~1.7k tokensUpdated 2 days ago
    DevelopmentAuto-check passed
  • Improve Codebase Architecture

    ywwynm/EverythingDone

    Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/.

    144 GitHub starsUsed in 15 repos~1.3k tokens
    DevelopmentAuto-check passed
  • Domain Modeling

    brim-borium/spotify_sdk

    Build and sharpen a project's domain model. An agent skill from brim-borium/spotify_sdk.

    166 GitHub starsUsed in 5 repos~806 tokens
    DevelopmentAuto-check passed
  • Design Doc Mermaid

    SpillwaveSolutions/design-doc-mermaid

    Create Mermaid diagrams (flowchart, sequence, class, ER, state, C4, architecture) from text or source code.

    176 GitHub starsUsed in 1 repo~5.6k tokens
    DevelopmentAuto-check passed

More from tech-leads-club/agent-skills

All 74 skills in this repo
  • Evolutionary Modular Architecture

    tech-leads-club/agent-skills

    Guides design of modular-monolith platforms with DDD, flat-by-aggregate modules, anti-corruption layers, outbox events and resilience, plus an architecture document with SVG diagrams.

    7k GitHub stars~3.7k tokensUpdated yesterday
    Auto-check passed
  • Excalidraw Diagram Studio

    tech-leads-club/agent-skills

    Generates Excalidraw diagram files from plain descriptions, choosing among flowcharts, mind maps, architecture, swimlane, class, sequence and ER diagrams.

    7k GitHub stars~3.6k tokensUpdated yesterday
    Auto-check passed
  • Mermaid Studio

    tech-leads-club/agent-skills

    Creates, validates and renders Mermaid diagrams to SVG, PNG or ASCII, including C4 and AWS architecture-beta, flowcharts, sequence diagrams and ERDs.

    7k GitHub stars~4.6k tokensUpdated yesterday
    Auto-check passed
  • AWS Cloud Advisor

    tech-leads-club/agent-skills

    Answers AWS architecture, security and service-selection questions by searching AWS documentation through MCP tools first, then adapting advice to your stack and team.

    7k GitHub stars~2.1k tokensUpdated yesterday
    Auto-check passed
  • Harness Eval

    tech-leads-club/agent-skills

    Evaluates a repository's agent harness (AGENTS.md, rules, skills) for broken paths, redundant instructions and usefulness, and stops at reports.

    7k GitHub stars~3.9k tokensUpdated yesterday
    Auto-check passed
  • NestJS Modular Monolith Architect

    tech-leads-club/agent-skills

    Designs scalable NestJS modular monoliths with domain-driven design, Clean Architecture layers and optional CQRS, defining bounded contexts and strict module boundaries.

    7k GitHub stars~3.9k tokensUpdated yesterday
    Auto-check passed

Categories

Questions about Create Adr

What does Create Adr do?

Creates Architecture Decision Records (ADRs) to document significant architectural choices and their rationale for future team members. Create Adr is an agent skill from tech-leads-club/agent-skills. Creates Architecture Decision Records (ADRs) to document significant architectural choices and their rationale for future team members.

When should I use Create Adr?

Create Adr fits situations like: the user says write an ADR; document this decision; record why we chose X; add an architecture decision record.

How do I install Create Adr in Claude Code?

Run `npx skills add tech-leads-club/agent-skills --skill create-adr -a claude-code`. Or copy the skill folder (packages/skills-catalog/skills/(creation)/create-adr in tech-leads-club/agent-skills) into .claude/skills/create-adr in your project. Claude Code loads it when a task matches its description.

How do I install Create Adr in Codex?

Run `npx skills add tech-leads-club/agent-skills --skill create-adr -a codex`. Or copy the skill folder (packages/skills-catalog/skills/(creation)/create-adr in tech-leads-club/agent-skills) into .agents/skills/create-adr in your project. Codex loads it when a task matches its description.

Can I use Create Adr in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add tech-leads-club/agent-skills --skill create-adr -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/create-adr, .gemini/skills/create-adr, .github/skills/create-adr and .opencode/skills/create-adr in your project.

What does Create Adr need to run?

Going by SKILL.md and its folder, Create Adr needs the command-line tools its instructions call (make).

Does Create Adr access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Create Adr safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Create Adr use?

Create Adr is published under the CC-BY-4.0 licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Create Adr use?

About 3.5k tokens (SKILL.md is roughly 14k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Create Adr?

Skills that share tags, products or a category with Create Adr: PR Design Doc (OpenHands/OpenHands, 90k stars), Cto Advisor (Ibrahim-3d/orchestrator-supaconductor, 381 stars), Architecture Decision (Donchitos/Claude-Code-Game-Studios, 26k stars) and Improve Codebase Architecture (ywwynm/EverythingDone, 144 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Create Adr?

tech-leads-club (a GitHub organization) maintains it in tech-leads-club/agent-skills, which has 7,045 GitHub stars. The repository holds 74 skills in this directory. The repository was last updated on October 9, 2026.

Source: tech-leads-club/agent-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.