architecture-decision-records

Capture architectural decisions as structured ADR documents with alternatives and consequences.

1|Updated Mar 3, 2026
One-click install
npx skills add https://github.com/samymity/bridge-ventures-backend --skill architecture-decision-records-samymity
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: architecture-decision-records
Source: https://github.com/samymity/bridge-ventures-backend/tree/main/.claude/skills/architecture-decision-records
Command: npx skills add https://github.com/samymity/bridge-ventures-backend --skill architecture-decision-records-samymity

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It prevents important architectural decisions from being lost in chat, PR comments, or memory by capturing them as structured, versioned Architecture Decision Records (ADRs) that future developers can read and trust.

Core Features & Use Cases

  • Capture decision context: Records the problem, constraints, and forces that led to an architectural choice during AI-assisted coding sessions.
  • Preserve alternatives and rationale: Documents competing options and why they were rejected so trade-offs remain transparent.
  • Track consequences over time: Lists expected positive/negative outcomes, risks, and mitigations, maintaining decision continuity as the codebase evolves.
  • Index for discovery: Maintains an ADR index so users can quickly answer “why did we choose X?” by locating relevant decisions.

Quick Start

Ask the skill to record a decision by saying: “let’s record this decision: we chose X instead of Y.”

Frequently Asked Questions about architecture-decision-records

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I document architectural decisions so the rationale isn't lost in chat logs?

Documenting architectural decisions as structured Architecture Decision Records captures the problem context, rejected alternatives, and expected consequences in versioned files. This approach preserves trade-off transparency so future developers understand why specific system choices were made.

What is the best way to track trade-offs when choosing between software frameworks or databases?

Tracking trade-offs when choosing software frameworks or databases requires recording the competing options and rejection rationale. Structured ADR documents list these alternatives alongside expected positive and negative outcomes, maintaining decision continuity as the codebase evolves.

How do I create an ADR during an AI-assisted coding session?

Creating an ADR during an AI-assisted coding session involves interactive detection of decision moments. The system requires explicit user approval before guarded file creation, ensuring architectural choices regarding patterns or APIs are captured accurately with full context.

Can I search existing architecture decision records to find why a specific pattern was chosen?

Searching existing architecture decision records is supported through a maintained ADR index. This index enables quick discovery of past decisions, allowing developers to locate relevant records and answer why specific infrastructure or security choices were adopted.

Does this approach require any specific dependencies to manage software documentation?

Managing software documentation with this approach requires no external dependencies. The system operates independently to capture architectural choices, relying solely on interactive user approval and an index file for record discovery.

When should I not use architecture decision records for software planning?

Architecture decision records should not be used for minor implementation details that lack significant trade-offs. They are designed for major framework, database, or infrastructure choices where documenting rationale and consequences provides ongoing value to future developers.