
Architecture Decision Records
OfficialFreeDocument and evaluate architecture decisions effectively.
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 source1. Install with the skills CLI
npx skills add anthropics/knowledge-work-plugins/architecture --agent claude-code2. 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
- State constraints upfront — "We need to ship in 2 weeks" or "Must handle 10K rps" shapes the answer.
- Name your options — Even if you're leaning one way, I'll give a more balanced analysis with explicit alternatives.
- 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
Markdown to HTML Conversion
Efficiently convert Markdown documents to HTML.
Code Tour
Create structured walkthroughs for codebases.
Acquire Codebase Knowledge
Streamline onboarding with comprehensive codebase documentation.
Documentation & Modernization
Streamline codebase documentation and modernization planning.
Azure Resource Visualizer
Generate architecture diagrams for Azure resources.
CLAUDE.md Improver
Optimize your CLAUDE.md files for better project context.
