Skip to main content
skill CX Codex

writing-adrs — Claude Code skill: ADRs in docs/adr/

Sets the format, numbering and when-to-write rules for Architecture Decision Records. Useful when architectural choices keep getting lost in chat threads.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add pandoscope/skills --skill writing-adrs -a claude-code
Open on GitHub

What writing-adrs does

The skill covers how ADRs live in docs/adr/ with sequential numbering: 0001-slug.md, 0002-slug.md and onward. The directory gets created lazily, only once the first decision needs recording.

The template is short — a title plus one to three sentences on the context, the decision and the reason behind it. Status, Considered Options and Consequences are optional and only earn their place when they add something real. For numbering, the skill scans docs/adr/ for the highest existing number and increments it.

There is a grilling gate. If a decision was made in conversation and never went through a grilling session, the skill asks whether to record it as-is and waits for explicit confirmation. When you dictated the decision yourself, the gate does not apply. Writing an ADR makes sense only when all three conditions hold: the decision is hard to reverse, it looks surprising without context, and it came out of a genuine trade-off. An easy-to-reverse decision is not worth a file — you will just reverse it.

What it helps with

  • record why the write model is event-sourced and the read model lands in Postgres
  • capture a deliberate move to hand-written SQL over an ORM
  • keep a rejected alternative on file so nobody proposes it again
  • document constraints invisible in code, like a partner API response-time contract
  • number a new ADR without clashing with existing files

Example prompts for the agent

  • Write an ADR: ordering and billing talk over domain events, not synchronous HTTP.
  • Check whether this decision is ADR-worthy and create the file in docs/adr/ if it is.
  • Record the decision to drop GraphQL for REST and explain the reasoning.

How to install writing-adrs

1Skills CLI (Vercel)

npx skills add pandoscope/skills --skill writing-adrs -a claude-code

2Manually: put the files in place

~/.claude/skills/writing-adrs/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/writing-adrs/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about writing-adrs

How do I install writing-adrs in Claude?

Run npx skills add pandoscope/skills --skill writing-adrs -a claude-code. The skill lands in ~/.claude/skills/writing-adrs/SKILL.md.

What does writing-adrs do?

It defines the format and numbering for Architecture Decision Records in docs/adr/ and tells you when a decision deserves one.

How is it different from a plain ADR template?

It does not demand every section. The template is a title and a short paragraph, with Status, Considered Options and Consequences added only when they matter. It also applies a three-condition test and asks about decisions that were never grilled.

Source text

SKILL.md · MIT
---
name: writing-adrs
description: >
  Format, numbering, and when-to-write criteria for Architecture Decision
  Records in docs/adr/. Use when recording an architectural decision, when
  another skill flags a decision as ADR-worthy, or when the user asks to
  write or review an ADR.
metadata.derived-from: lifted from mattpocock/skills' `domain-modeling` reference file ADR-FORMAT.md (https://github.com/mattpocock/skills/blob/391a2701dd948f94f56a39f7533f8eea9a859c87/skills/engineering/domain-modeling/ADR-FORMAT.md)
---

# Writing ADRs

ADRs live in `docs/adr/` and use sequential numbering: `0001-slug.md`, `0002-slug.md`, etc.

Create the `docs/adr/` directory lazily — only when the first ADR is needed.

## Template

```md
# {Short title of the decision}

{1-3 sentences: what's the context, what did we decide, and why.}
```

That's it. An ADR can be a single paragraph. The value is in recording *that* a decision was made and *why* — not in filling out sections.

Written and checked with the `writing-prose` skill if available, surface `markdown`. Hard limit: precision and understandability must not suffer.

## Optional sections

Only include these when they add genuine value. Most ADRs won't need them.

- **Status** frontmatter (`proposed | accepted | deprecated | superseded by ADR-NNNN`) — useful when decisions are revisited
- **Considered Options** — only when the rejected alternatives are worth remembering
- **Consequences** — only when non-obvious downstream effects need to be called out

## Numbering

Scan `docs/adr/` for the highest existing number and increment by one.

## Grilling gate

ADRs record load-bearing decisions. Decision made in-conversation, never grilled (`docs/glossary/grilling-session.md`) → ask user: "Decision wasn't grilled — record as-is?" Proceed only on explicit confirmation. Transcribing decision user already stated explicitly → gate doesn't apply.

## When to write an ADR

All three of these must be true:

1. **Hard to reverse** — the cost of changing your mind later is meaningful
2. **Surprising without context** — a future reader will look at the code and wonder "why on earth did they do it this way?"
3. **The result of a real trade-off** — there were genuine alternatives and you picked one for specific reasons

If a decision is easy to reverse, skip it — you'll just reverse it. If it's not surprising, nobody will wonder why. If there was no real alternative, there's nothing to record beyond "we did the obvious thing."

### What qualifies

- **Architectural shape.** "We're using a monorepo." "The write model is event-sourced, the read model is projected into Postgres."
- **Integration patterns between contexts.** "Ordering and Billing communicate via domain events, not synchronous HTTP."
- **Technology choices that carry lock-in.** Database, message bus, auth provider, deployment target. Not every library — just the ones that would take a quarter to swap out.
- **Boundary and scope decisions.** "Customer data is owned by the Customer context; other contexts reference it by ID only." The explicit no-s are as valuable as the yes-s.
- **Deliberate deviations from the obvious path.** "We're using manual SQL instead of an ORM because X." Anything where a reasonable reader would assume the opposite. These stop the next engineer from "fixing" something that was deliberate.
- **Constraints not visible in the code.** "We can't use AWS because of compliance requirements." "Response times must be under 200ms because of the partner API contract."
- **Rejected alternatives when the rejection is non-obvious.** If you considered GraphQL and picked REST for subtle reasons, record it — otherwise someone will suggest GraphQL again in six months.

© pandoscope · MIT · pandoscope/skills

Similar skills

Everything for Writing and docs →

From the same set3

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor