technical-decision-record
Use when making technical decisions, choosing technologies, or documenting architectural choices. Creates ADRs (Architecture Decision Records).
Best use case
technical-decision-record is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Use when making technical decisions, choosing technologies, or documenting architectural choices. Creates ADRs (Architecture Decision Records).
Teams using technical-decision-record should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/technical-decision-record/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How technical-decision-record Compares
| Feature / Agent | technical-decision-record | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Use when making technical decisions, choosing technologies, or documenting architectural choices. Creates ADRs (Architecture Decision Records).
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
<framework_overview> ## What This Is A structured approach to documenting technical decisions using ADRs (Architecture Decision Records). Ensures decisions are traceable, well-reasoned, and understood by the team. ## When to Use - Choosing between technologies or frameworks - Making architectural changes - Selecting third-party services - Changing established patterns - Any decision you'd want to reference later </framework_overview> <principles> ## Core Philosophy ### 1. DECISIONS ARE IMMUTABLE HISTORY Once made, an ADR is never modified—only superseded. This preserves the reasoning at the time, even if context changes later. ### 2. CONTEXT OVER CONCLUSION The "why" is more valuable than the "what." Future readers need to understand the constraints, options, and trade-offs that led to the decision. ### 3. BIAS TOWARD REVERSIBILITY Prefer decisions that can be changed later. Document the reversal cost for irreversible choices. ### 4. EXPLICIT OVER IMPLICIT If it wasn't written down, it wasn't decided. Verbal agreements don't count as architectural decisions. ### 5. TEAM OVER INDIVIDUAL Decisions should be reviewed by affected parties. Surprise decisions create resistance. </principles> <process> ## The Process ### Step 1: Define the Problem What are we deciding? Be specific. - "Which database for user data" not "database stuff" - Include the trigger: what prompted this decision? ### Step 2: List Constraints What limits our options? - Technical: performance, scalability, existing stack - Business: budget, timeline, team skills - Compliance: security, regulatory, data residency ### Step 3: Enumerate Options List 2-4 real options. For each: - Brief description - Pros (what it does well) - Cons (what it does poorly) - Estimated cost/effort ### Step 4: Make the Decision Choose one option. State it clearly. - "We will use [X]" - Include who made the decision and when ### Step 5: Document Consequences What follows from this decision? - Positive: benefits we expect - Negative: costs we accept - Risks: what could go wrong - Reversibility: how hard to change later </process> <templates> ## ADR Template ```markdown # ADR-[NUMBER]: [TITLE] **Status**: [Proposed | Accepted | Superseded by ADR-X] **Date**: [YYYY-MM-DD] **Deciders**: [Names] ## Context [What is the issue? What prompted this decision?] ## Constraints - [Constraint 1] - [Constraint 2] - [Constraint 3] ## Options Considered ### Option 1: [Name] [Description] - Pros: [...] - Cons: [...] ### Option 2: [Name] [Description] - Pros: [...] - Cons: [...] ### Option 3: [Name] [Description] - Pros: [...] - Cons: [...] ## Decision We will use **[Option X]**. [Reasoning: Why this option over others?] ## Consequences ### Positive - [Benefit 1] - [Benefit 2] ### Negative - [Cost 1] - [Cost 2] ### Risks - [Risk 1]: [Mitigation] - [Risk 2]: [Mitigation] ### Reversibility [Easy | Moderate | Difficult | Irreversible] [Explanation of what reversal would require] ``` </templates> <anti-patterns> ## Common Mistakes ### 1. DECIDING WITHOUT OPTIONS Making a decision without exploring alternatives is not a decision—it's a default. Why it's wrong: You can't justify a choice without knowing what you chose against. Instead: Always list at least 2 options, even if one is "do nothing." ### 2. BIKESHEDDING Spending more time on reversible decisions than irreversible ones. Why it's wrong: Time spent on low-stakes decisions is time not spent on high-stakes ones. Instead: Match deliberation time to reversibility. Irreversible = more process. ### 3. HIDDEN STAKEHOLDERS Making decisions that affect teams without involving them. Why it's wrong: Creates surprise, resistance, and rework. Instead: List affected parties in "Deciders" and get explicit sign-off. ### 4. REVISION INSTEAD OF SUPERSESSION Editing old ADRs when context changes. Why it's wrong: Loses the historical record of why decisions were made. Instead: Create a new ADR that supersedes the old one, referencing the original. </anti-patterns> <intake> What technical decision are you working on? 1. **What's being decided?** - Technology choice - Architectural pattern - Third-party service - Process change - Other: ___ 2. **What triggered this decision?** - New requirement - Performance issue - Technical debt - Team change - Other: ___ 3. **How reversible should this be?** - Easy to change (experiment) - Moderate effort to change - Significant investment - Hard to reverse (commit carefully) I'll help you structure the ADR based on your answers. </intake>
Related Skills
technical-diagram-analyzer
Technical Diagram Analyzer - Auto-activating skill for Visual Content. Triggers on: technical diagram analyzer, technical diagram analyzer Part of the Visual Content skill category.
technical-analyst
Technical analysis translator for Product Managers. Use when the user needs to understand a system, codebase, API, or technical concept in PM-friendly terms. Triggers include "understand system", "explain code", "technical analysis", "how does X work", "what does this service do", or when exploring unfamiliar technical territory.
route53-record-manager
Route53 Record Manager - Auto-activating skill for AWS Skills. Triggers on: route53 record manager, route53 record manager Part of the AWS Skills skill category.
gtm-technical-product-pricing
Pricing strategy for technical products. Use when choosing usage-based vs seat-based, designing freemium thresholds, structuring enterprise pricing conversations, deciding when to raise prices, or using price as a positioning signal.
create-technical-spike
Create time-boxed technical spike documents for researching and resolving critical development decisions before implementation.
create-architectural-decision-record
Create an Architectural Decision Record (ADR) document for AI-optimized decision documentation.
decision-logger
Two-layer memory architecture for board meeting decisions. Manages raw transcripts (Layer 1) and approved decisions (Layer 2). Use when logging decisions after a board meeting, reviewing past decisions with /cs:decisions, or checking overdue action items with /cs:review. Invoked automatically by the board-meeting skill after Phase 5 founder approval.
technical-writing
Write clear, comprehensive technical documentation. Use when creating specs, architecture docs, runbooks, or API documentation. Handles technical specifications, system design docs, operational guides, and developer documentation with industry best practices.
technical-blog-writing
Technical blog post writing with structure, code examples, and developer audience conventions. Covers post types, code formatting, explanation depth, and developer-specific engagement patterns. Use for: engineering blogs, dev tutorials, technical writing, developer content, documentation posts. Triggers: technical blog, dev blog, engineering blog, technical writing, developer tutorial, tech post, code tutorial, programming blog, developer content, technical article, engineering post, coding tutorial, technical content
technical-analysis
Technical analysis capabilities for APIs, data models, integrations, and security requirements. Use when analyzing technical aspects of systems or documenting technical requirements.
decisions
Load past architectural decisions. Use when making new decisions to ensure consistency.
decision-moment-skill
Map and optimize decision moments across Awareness, Consideration, Conversion, and Retention, then attach specific assets, visuals, and automations to each stage. Use when designing funnels, campaigns, or retention systems.