New to Claude Skills? Learn how to install them →

anthropics on GitHub

Architecture Decision Records

OfficialFree

Document and evaluate architecture decisions effectively.

Get this skill

Free · Opens the source repo

What Architecture Decision Records does

The Architecture Decision Records (ADR) skill is designed to assist developers and architects in creating and evaluating architecture decision records. An ADR is a document that captures important decisions made while designing a system, including the context, options considered, and the rationale behind the chosen option. This skill helps in making informed decisions between different technologies, such as choosing between Kafka and SQS for an event bus, and documenting the trade-offs involved in these choices.

Using the ADR skill, users can generate structured records that include essential elements such as context, decision, options considered, trade-off analysis, and consequences. The output follows a clear markdown format, making it easy to read and share with stakeholders. This structured approach not only aids in documenting decisions but also serves as a reference for future discussions and reviews, ensuring that the rationale behind architectural choices is preserved.

The skill is particularly beneficial for teams working on complex systems where multiple technologies and design options are available. It provides a framework for discussing and evaluating these options systematically, which can lead to better alignment among team members and a clearer understanding of the implications of each choice. Additionally, if connected to a knowledge base or project tracker, the skill can leverage existing documentation and link to relevant tasks, enhancing collaboration and efficiency.

In summary, the Architecture Decision Records skill is a valuable tool for any development or design team looking to formalize their decision-making process regarding system architecture. It helps ensure that all decisions are well-documented and justified, promoting transparency and accountability within the team.

When to use it

Use this skill when you need to document architectural decisions or evaluate design proposals, particularly in collaborative environments.

When not to use it

This skill may not be suitable for simple projects where architectural decisions are minimal or do not require formal documentation.

What you can build with it

Choosing Between Technologies

When faced with a decision to choose between technologies like Kafka and SQS, use this skill to document the pros and cons of each option.

Reviewing System Designs

Utilize this skill to evaluate and provide feedback on a microservices proposal, ensuring all aspects are considered.

Documenting Architectural Changes

When making significant changes to a system's architecture, create an ADR to capture the decision-making process and its implications.

How to install Architecture Decision Records

View source

1. Install with the skills CLI

npx skills add anthropics/knowledge-work-plugins/architecture --agent claude-code

2. Or install it manually

Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.

Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs

Inside SKILL.md

Written by anthropics

/architecture

If you see unfamiliar placeholders or need to check which tools are connected, see CONNECTORS.md.

Create an Architecture Decision Record (ADR) or evaluate a system design.

Usage

/architecture $ARGUMENTS

Modes

Create an ADR: "Should we use Kafka or SQS for our event bus?" Evaluate a design: "Review this microservices proposal" System design: "Design the notification system for our app"

See the system-design skill for detailed frameworks on requirements gathering, scalability analysis, and trade-off evaluation.

Output — ADR Format

# ADR-[number]: [Title]

**Status:** Proposed | Accepted | Deprecated | Superseded
**Date:** [Date]
**Deciders:** [Who needs to sign off]

## Context
[What is the situation? What forces are at play?]

## Decision
[What is the change we're proposing?]

## Options Considered

### Option A: [Name]
| Dimension | Assessment |
|-----------|------------|
| Complexity | [Low/Med/High] |
| Cost | [Assessment] |
| Scalability | [Assessment] |
| Team familiarity | [Assessment] |

**Pros:** [List]
**Cons:** [List]

### Option B: [Name]
[Same format]

## Trade-off Analysis
[Key trade-offs between options with clear reasoning]

## Consequences
- [What becomes easier]
- [What becomes harder]
- [What we'll need to revisit]

## Action Items
1. [ ] [Implementation step]
2. [ ] [Follow-up]

If Connectors Available

If ~~knowledge base is connected:

  • Search for prior ADRs and design docs
  • Find relevant technical context

If ~~project tracker is connected:

  • Link to related epics and tickets
  • Create implementation tasks

Tips

  1. State constraints upfront — "We need to ship in 2 weeks" or "Must handle 10K rps" shapes the answer.
  2. Name your options — Even if you're leaning one way, I'll give a more balanced analysis with explicit alternatives.
  3. Include non-functional requirements — Latency, cost, team expertise, and maintenance burden matter as much as features.

Frequently asked questions about Architecture Decision Records

Similar skills