adr-writer

Category: Daily Life | Uploader: Mathews-Tom | Downloads: 0 | Version: v1.0（Latest）
Generates Architecture Decision Records (ADRs) capturing context, decision rationale, alternatives considered, and projected consequences. Produces numbered, status-tracked documents following the standard ADR format with proper metadata lifecycle.
Changelog: Source: GitHub https://github.com/Mathews-Tom/praxis-skills
Directory Structure

Current level: skills/adr-writer/
📁 evals/
- 📄 cases.yaml 1.2 KB
📁 references/
- 📄 adr-template.md 4.5 KB
- 📄 alternatives-analysis.md 4.8 KB
- 📄 context-capture.md 5.5 KB
- 📄 status-lifecycle.md 3.9 KB
📄 SKILL.md 8.2 KB
SKILL.md

---
name: adr-writer
description: >
  Generates Architecture Decision Records (ADRs) capturing context, decision rationale,
  alternatives considered, and projected consequences. Produces numbered, status-tracked
  documents following the standard ADR format with proper metadata lifecycle.
  Triggers on: "write an ADR", "document this decision", "architecture decision record",
  "why did we choose", "capture this decision", "record the decision", "ADR for",
  "document the architecture", "decision record", "design decision", "technical decision".
  Use this skill when an architectural or technical decision needs to be documented.
metadata:
  version: 1.1.0
---

# ADR Writer

Captures architecture decisions in a lightweight, structured format that preserves
context, rationale, alternatives, and consequences. Produces numbered ADR documents with
proper status lifecycle — preventing the "why did we do it this way?" problem when
revisiting decisions months later.

## Reference Files

| File                                  | Contents                                                       | Load When                             |
| ------------------------------------- | -------------------------------------------------------------- | ------------------------------------- |
| `references/adr-template.md`          | Standard ADR template with field explanations and examples     | Always                                |
| `references/status-lifecycle.md`      | Status transitions, supersession rules, deprecation process    | ADR references existing decisions     |
| `references/context-capture.md`       | Techniques for eliciting and documenting decision context      | Complex or multi-stakeholder decision |
| `references/alternatives-analysis.md` | Framework for evaluating and documenting rejected alternatives | Multiple options being considered     |

## Prerequisites

- A decisions directory (typically `docs/adr/` or `docs/decisions/`)
- Understanding of the decision being made (may require clarifying questions)

## Workflow

### Phase 1: Identify the Decision

1. **What choice was made?** — Extract the core architectural decision. If the user
   describes a problem, help them articulate the decision that resolves it.
2. **Is this decision-worthy?** — ADRs are for decisions that:
   - Affect system structure (component boundaries, data flow, API design)
   - Are hard to reverse (technology choice, database schema, protocol)
   - Have non-obvious tradeoffs (multiple viable alternatives)
   - Will be questioned later (the "why" will be forgotten)
3. **What triggered this decision?** — New requirement, performance issue, scaling
   concern, security audit finding, tech debt, team growth.

### Phase 2: Capture Context

Document the forces that shaped this decision:

1. **Requirements** — What functional or non-functional requirements drive this?
2. **Constraints** — What limits the solution space? (budget, timeline, team expertise,
   existing infrastructure, regulatory requirements)
3. **Current state** — What exists today? What is the pain point?
4. **Stakeholders** — Who is affected by this decision? Who needs to agree?

### Phase 3: Enumerate Alternatives

For each alternative considered:

1. **Name it clearly** — "PostgreSQL" not "Option A"
2. **List concrete pros** — Specific, measurable benefits
3. **List concrete cons** — Specific, measurable drawbacks
4. **State the rejection reason** — Why this alternative was not chosen. Be specific:
   "Does not support our required throughput of 10K ops/sec" not "Too slow."

### Phase 4: Document the Decision

State the chosen option and why it was selected given the context and constraints.
The decision should follow logically from the context + alternatives analysis.

### Phase 5: Project Consequences

Document what this decision makes easier and harder:

1. **Positive consequences** — What improves?
2. **Negative consequences** — What tradeoffs are accepted? What tech debt is incurred?
3. **Neutral consequences** — Side effects that are neither good nor bad.

### Phase 6: Assign Metadata

1. **Number** — Sequential: ADR-001, ADR-002, etc. Check existing ADRs for the next number.
2. **Status** — Initial status is usually "Proposed" or "Accepted"
3. **Date** — Date the ADR was written
4. **Author** — Who authored this ADR
5. **Supersedes/Superseded-by** — Link to related ADRs if this replaces an earlier decision

## Output Format

```text
# ADR-{NNN}: {Descriptive Title}

**Status:** {Proposed | Accepted | Deprecated | Superseded by ADR-XXX}
**Date:** {YYYY-MM-DD}
**Author:** {name}
**Supersedes:** {ADR-XXX (if applicable)}

## Context

{What situation requires a decision? What constraints exist? What forces are at play?
Write in present tense — describe the situation as it exists at decision time.}

## Decision

{State the decision clearly and concisely. "We will use X for Y because Z."
One to three sentences. The reader should understand the decision without reading
the rest of the document.}

## Alternatives Considered

### {Alternative 1 Name}
- **Pros:** {specific benefits}
- **Cons:** {specific drawbacks}
- **Rejected because:** {concrete, specific reason tied to context}

### {Alternative 2 Name}
- **Pros:** {specific benefits}
- **Cons:** {specific drawbacks}
- **Rejected because:** {concrete, specific reason tied to context}

## Consequences

### Positive
- {Concrete benefit 1}
- {Concrete benefit 2}

### Negative
- {Concrete tradeoff 1 — acknowledged and accepted}
- {Technical debt incurred — with plan to address if applicable}

### Neutral
- {Side effect that is neither positive nor negative}

## References

- {Link to related issue, discussion, document, or prior ADR}
```

## Calibration Rules

1. **Context is king.** The Context section is the most important part. A decision
   without context is just an assertion. Future readers need to understand WHY, not
   just WHAT.
2. **Specific rejection reasons.** "Not suitable" is not a rejection reason. "Does not
   support transactions across partitions, which we need for order processing" is.
3. **Honest consequences.** Every decision has downsides. If the Negative section is
   empty, the analysis is incomplete. Push the user to articulate tradeoffs.
4. **Present tense for context.** Write the Context section in present tense — it
   captures the world as it was when the decision was made.
5. **One decision per ADR.** If multiple decisions are interrelated, write separate ADRs
   and cross-reference them. Do not bundle unrelated decisions.
6. **Immutable after acceptance.** Accepted ADRs are not edited. If a decision changes,
   write a new ADR that supersedes the old one. This preserves the historical record.

## Error Handling

| Problem                                      | Resolution                                                                                                |
| -------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
| User cannot articulate alternatives          | Help them brainstorm by asking: "What else could you have done? What did you consider and reject?"        |
| Decision is trivial (no real alternatives)   | Suggest it doesn't need an ADR. ADRs are for non-obvious decisions with tradeoffs.                        |
| Decision already made, no context remembered | Reconstruct context from code, PRs, commit history. Note reconstructed context as "best available."       |
| Existing ADR numbering scheme unknown        | Check `docs/adr/` or `docs/decisions/`. If no directory exists, suggest creating one and starting at 001. |
| Decision scope is too broad                  | Split into multiple focused ADRs. One for the database choice, one for the caching strategy, etc.         |

## When NOT to Write an ADR

Push back if:

- The decision is easily reversible (library version, code formatting rules) — use a comment or config instead
- The decision is a standard practice with no alternatives (use HTTPS, validate input) — not decision-worthy
- The user wants to document implementation details — ADRs are for WHY decisions, not HOW implementations
- The decision has already been superseded — write the new ADR, not the old one
Comments 0
Latest | Hot
Please login before commenting.
No comments yet. Be the first one!
adr-writer

Directory Structure

SKILL.md

Report

Notice
