Skip to content
Skillpedia
Documentation41k · #4855

architecture-decision-records

Helps your agent write and organize architecture decision records. It's useful for documenting important technical choices and maintaining a clear history.

What it does

This tool helps record and manage important decisions about how to build software. It explains why a decision was made, what the decision was, and what happens as a result.

When to use it

  • ✓When deciding which new technology to use for a project.
  • ✓When you need to explain why a technical choice was made.
  • ✓To keep a history of how the software has evolved.

Example of what to ask your AI

“Record the decision to use PostgreSQL as the main database for project X.”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/wshobson/agents/blob/main/plugins/documentation-generation/skills/architecture-decision-records/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/wshobson/agents/blob/main/plugins/documentation-generation/skills/architecture-decision-records/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

You write a short document explaining the problem, the options considered, the final decision, and the consequences. These documents are organized in a folder and can be updated as decisions change.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add wshobson/agents --skill architecture-decision-records

Or download just the file:

curl -L https://raw.githubusercontent.com/wshobson/agents/main/plugins/documentation-generation/skills/architecture-decision-records/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

Architecture Decision Records

Comprehensive patterns for creating, maintaining, and managing Architecture Decision Records (ADRs) that capture the context and rationale behind significant technical decisions.

When to Use This Skill

  • Making significant architectural decisions
  • Documenting technology choices
  • Recording design trade-offs
  • Onboarding new team members
  • Reviewing historical decisions
  • Establishing decision-making processes

Core Concepts

1. What is an ADR?

An Architecture Decision Record captures:

  • Context: Why we needed to make a decision
  • Decision: What we decided
  • Consequences: What happens as a result

2. When to Write an ADR

Write ADR Skip ADR
New framework adoption Minor version upgrades
Database technology choice Bug fixes
API design patterns Implementation details
Security architecture Routine maintenance
Integration patterns Configuration changes

3. ADR Lifecycle

Proposed → Accepted → Deprecated → Superseded
              ↓
           Rejected

Before drafting a standard, lightweight, or Y-statement ADR, read decision templates.

Before drafting a deprecation ADR or RFC, read deprecation and RFC templates.

ADR Management

Directory Structure

docs/
├── adr/
│   ├── README.md           # Index and guidelines
│   ├── template.md         # Team's ADR template
│   ├── 0001-use-postgresql.md
│   ├── 0002-caching-strategy.md
│   ├── 0003-mongodb-user-profiles.md  # [DEPRECATED]
│   └── 0020-deprecate-mongodb.md      # Supersedes 0003

ADR Index (README.md)

# Architecture Decision Records

This directory contains Architecture Decision Records (ADRs) for [Project Name].

## Index

| ADR                                   | Title                              | Status     | Date       |
| ------------------------------------- | ---------------------------------- | ---------- | ---------- |
| [0001](0001-use-postgresql.md)        | Use PostgreSQL as Primary Database | Accepted   | 2024-01-10 |
| [0002](0002-caching-strategy.md)      | Caching Strategy with Redis        | Accepted   | 2024-01-12 |
| [0003](0003-mongodb-user-profiles.md) | MongoDB for User Profiles          | Deprecated | 2023-06-15 |
| [0020](0020-deprecate-mongodb.md)     | Deprecate MongoDB                  | Accepted   | 2024-01-15 |

## Creating a New ADR

1. Copy `template.md` to `NNNN-title-with-dashes.md`
2. Fill in the template
3. Submit PR for review
4. Update this index after approval

## ADR Status

- **Proposed**: Under discussion
- **Accepted**: Decision made, implementing
- **Deprecated**: No longer relevant
- **Superseded**: Replaced by another ADR
- **Rejected**: Considered but not adopted

Automation (adr-tools)

# Install adr-tools
brew install adr-tools

# Initialize ADR directory
adr init docs/adr

# Create new ADR
adr new "Use PostgreSQL as Primary Database"

# Supersede an ADR
adr new -s 3 "Deprecate MongoDB in Favor of PostgreSQL"

# Generate table of contents
adr generate toc > docs/adr/README.md

# Link related ADRs
adr link 2 "Complements" 1 "Is complemented by"

Review Process

## ADR Review Checklist

### Before Submission

- [ ] Context clearly explains the problem
- [ ] All viable options considered
- [ ] Pros/cons balanced and honest
- [ ] Consequences (positive and negative) documented
- [ ] Related ADRs linked

### During Review

- [ ] At least 2 senior engineers reviewed
- [ ] Affected teams consulted
- [ ] Security implications considered
- [ ] Cost implications documented
- [ ] Reversibility assessed

### After Acceptance

- [ ] ADR index updated
- [ ] Team notified
- [ ] Implementation tickets created
- [ ] Related documentation updated

Best Practices

Do's

  • Write ADRs early - Before implementation starts
  • Keep them short - 1-2 pages maximum
  • Be honest about trade-offs - Include real cons
  • Link related decisions - Build decision graph
  • Update status - Deprecate when superseded

Don'ts

  • Don't change accepted ADRs - Write new ones to supersede
  • Don't skip context - Future readers need background
  • Don't hide failures - Rejected decisions are valuable

…

FAQ

What is an ADR?

It's a document that records a significant technical decision, explaining the context, the decision, and its consequences.

When should I write an ADR?

Whenever a technical decision has a significant impact, like choosing a new technology, changing the architecture, or defining important patterns.

What does 'Deprecated' or 'Superseded' mean?

'Deprecated' means the decision is no longer recommended. 'Superseded' means a new decision has replaced it.

Details

Original description by the author

Write and maintain Architecture Decision Records (ADRs) following best practices for technical decision documentation. Use when documenting significant technical decisions, reviewing past architectural choices, or establishing decision processes.

repo: wshobson/agents

Popularity

GitHub stars
41k
Ranking position
#4855
License
MIT
Updated
10/15/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills