Lead engineers do not lose time because teams move slowly. They lose time because teams revisit the same decision three times across six months, with no shared memory of why the previous choice was made.

This article shows:

• why ADRs are a leverage point for engineering leaders,
• how to remove the friction that kills adoption,
• and how to bootstrap the practice with create-adr in minutes.

If your goal is better decisions, faster onboarding, and fewer "why are we doing this?" loops, this is for you.

The Real Cost of Missing Decision History

When important technical decisions are undocumented, teams pay hidden tax:

• repeated debates in refinement and PR reviews,
• inconsistent implementations across squads,
• slower onboarding for new engineers,
• fear of change because intent is unclear.

ADRs create a compact, searchable system of record for architecture and product-technical trade-offs.

What an ADR Is (and Is Not)

An ADR is a short markdown document that captures one meaningful decision:

• Context: what problem and constraints exist,
• Decision: what you choose now,
• Consequences: expected benefits and known downsides,
• Alternatives: what you considered and why it was rejected.

Why ADR Adoption Usually Fails

Most teams fail ADR rollout for one of three reasons:

1. Too much ceremony: heavyweight templates and long approval chains.
2. No trigger points: nobody knows when to write one.
3. Tooling friction: people must create folder/file/number/template manually.

You do not need a bigger process. You need a lower-friction default.

create-adr: Remove Friction, Keep Discipline

create-adr is a small CLI that generates ADR files under docs/adr/ at your repository root.

From any repository root:

npx create-adr "Use URI path versioning for public APIs"

You can also pass explicit flags:

npx create-adr --title "Use URI path versioning for public APIs" --path /path/to/repository

What the CLI does for you

It automatically:

• creates docs/adr/ if it does not exist,
• picks the next ADR number (0001, 0002, ...),
• creates a kebab-case filename from the title,
• writes a markdown template with status/date/sections.

Example generated file:

docs/adr/0001-use-uri-path-versioning-for-public-apis.md

Template sections include:

• Status: proposed
• Date: YYYY-MM-DD
• Context
• Decision
• Consequences (expected improvements + identified downsides)
• Alternatives considered
• Links

This is exactly the kind of structured speed that drives adoption.

End-to-End Example: A Lead-Engineer Workflow

Let’s say your team needs to decide whether to version APIs in the URL path.

Step 1: Create the ADR shell

npx create-adr "Use URI path versioning for public APIs"

Step 2: Fill only what matters

Focus on the decision quality, not document size:

• context: client compatibility constraints, timeline, migration risk,
• decision: adopt /v1/... route strategy for public APIs,
• consequences: easier backward compatibility, but possible route sprawl,
• alternatives: header-based versioning rejected for operational complexity.

Step 3: Attach ADR in your PR

In PR description:

• add a link to the ADR file,
• require one reviewer to challenge consequences and alternatives,
• merge decision + implementation together when possible.

Step 4: Use ADR in onboarding

When a new engineer asks "why this pattern?", send the ADR link before scheduling another alignment call.

Anti-Patterns to Avoid

• Writing ADRs for trivial choices ("rename variable")
• Treating status as permanently proposed (update as decisions mature)
• Copy-pasting alternatives without real rejection rationale
• Creating ADRs without connecting them to implementation PRs

The point is not producing more markdown. The point is producing fewer bad or repeated decisions.

Start Today (Copy/Paste)

Run this in your repository root:

npx create-adr "Choose one high-impact architecture decision title"

Then set a simple team rule: no major technical decision merges without an ADR link.

You will quickly notice:

• faster alignment in reviews,
• better context transfer across teams,
• and stronger engineering leadership through transparent decision-making.

https://npmjs.com/package/create-adr

Looking for a .skill?

If you want to share this approach across teams, share that skill file in your repo so everyone can use the same ADR workflow with a single, consistent prompt.

---
name: create-adr
description: Generates an ADR markdown file and guides stronger Context, Decision, and Consequences writing. Use when the user asks to create an ADR, document a technical decision, or standardize architecture decision workflow.
version: 1.0.0
---

# create-adr Skill

## Purpose

Create a high-quality ADR quickly, with minimal ceremony and strong decision clarity.

## Trigger

Use this skill when the user asks to:
- create an ADR,
- document an architecture/technical decision,
- add decision rationale to a repo,
- standardize decision records across a team.

## Inputs

Collect these inputs before generating:
1. Decision title (required)
2. Repository root path (optional, default: current directory)
3. Key constraints (optional but recommended)
4. At least one rejected alternative (recommended)

## Execution Workflow

### Step 1: Generate ADR shell via CLI

Use `npx` for examples.  
The command is compatible with Node (`npx`) and Bun (`bunx`).

```
{% endraw %}
sh
npx create-adr "Short decision title"
{% raw %}

```

Optional explicit path:

```
{% endraw %}
sh
npx create-adr --title "Short decision title" --path /path/to/repository
{% raw %}

```

The file is generated in:
- `docs/adr/`
- with incremented numbering (`0001`, `0002`, ...)
- and kebab-case naming.

### Step 2: Coach for strong content quality

Guide the user to complete the template with concise, concrete content:

- **Context**: What problem, constraints, and timeline pressure exist?
- **Decision**: What exactly is chosen now?
- **Consequences**:
  - Expected improvements (2+ practical benefits)
  - Identified downsides (at least 1 real trade-off)
- **Alternatives considered**: What was rejected and why?

### Step 3: Enforce practical quality gates

Before marking done, verify:
- Decision is specific and testable in implementation.
- At least one downside is explicit.
- At least one alternative is documented with rejection rationale.
- Links section references issue/PR when available.

## Output Format

Respond with:
1. Generated ADR path
2. A short "quality check" list
3. Optional suggested improvements for missing sections

Use this response template:

```
{% endraw %}
markdown
ADR created: {% raw %}`docs/adr/XXXX-your-title.md`

Quality check:
- Context is clear: [yes/no]
- Decision is explicit: [yes/no]
- Consequences include downsides: [yes/no]
- Alternatives include rejection rationale: [yes/no]

Suggested improvements:
- ...
{% raw %}

```

## Example Usage

User:
"Create an ADR for adopting URI path versioning for public APIs."

Assistant behavior:
1. Run:
```
{% endraw %}
sh
npx create-adr "Use URI path versioning for public APIs"
{% raw %}

```
2. Provide writing guidance for Context/Decision/Consequences.
3. Return ADR path and quality checklist.

## Notes

- Keep ADRs short; optimize for future readability.
- Prefer decision quality over document length.
- This skill complements team review habits; it does not replace architectural discussion.
```
{% endraw %}
`