technical-decision-record

Use when making technical decisions, choosing technologies, or documenting architectural choices. Creates ADRs (Architecture Decision Records).

242 stars

Best use case

technical-decision-record is best used when you need a repeatable AI agent workflow instead of a one-off prompt. It is especially useful for teams working in multi. Use when making technical decisions, choosing technologies, or documenting architectural choices. Creates ADRs (Architecture Decision Records).

Use when making technical decisions, choosing technologies, or documenting architectural choices. Creates ADRs (Architecture Decision Records).

Users should expect a more consistent workflow output, faster repeated execution, and less time spent rewriting prompts from scratch.

Practical example

Example input

Use the "technical-decision-record" skill to help with this workflow task. Context: Use when making technical decisions, choosing technologies, or documenting architectural choices. Creates ADRs (Architecture Decision Records).

Example output

A structured workflow result with clearer steps, more consistent formatting, and an output that is easier to reuse in the next run.

When to use this skill

  • Use this skill when you want a reusable workflow rather than writing the same prompt again and again.

When not to use this skill

  • Do not use this when you only need a one-off answer and do not need a reusable workflow.
  • Do not use it if you cannot install or maintain the related files, repository context, or supporting tools.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/technical-decision-record/SKILL.md --create-dirs "https://raw.githubusercontent.com/aiskillstore/marketplace/main/skills/chaiwithjai/technical-decision-record/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/technical-decision-record/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How technical-decision-record Compares

Feature / Agenttechnical-decision-recordStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/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-writing

242
from aiskillstore/marketplace

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.

architecture-decision-records

242
from aiskillstore/marketplace

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.

technical-blog-writing

242
from aiskillstore/marketplace

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

242
from aiskillstore/marketplace

Technical analysis capabilities for APIs, data models, integrations, and security requirements. Use when analyzing technical aspects of systems or documenting technical requirements.

clinical-decision-support

242
from aiskillstore/marketplace

Generate professional clinical decision support (CDS) documents for pharmaceutical and clinical research settings, including patient cohort analyses (biomarker-stratified with outcomes) and treatment recommendation reports (evidence-based guidelines with decision algorithms). Supports GRADE evidence grading, statistical analysis (hazard ratios, survival curves, waterfall plots), biomarker integration, and regulatory compliance. Outputs publication-ready LaTeX/PDF format optimized for drug development, clinical research, and evidence synthesis.

decisions

242
from aiskillstore/marketplace

Load past architectural decisions. Use when making new decisions to ensure consistency.

decision-moment-skill

242
from aiskillstore/marketplace

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.

pytest-recording

242
from aiskillstore/marketplace

Work with pytest-recording (VCR.py) for recording and replaying HTTP interactions in tests. Use when writing VCR tests, managing cassettes, configuring VCR options, filtering sensitive data, or debugging recorded HTTP responses.

decision-action

242
from aiskillstore/marketplace

Use when the user needs to choose, prioritize, or make a go/no-go decision among options.

architecture-decision-record

242
from aiskillstore/marketplace

Use this skill when documenting significant architectural decisions. Provides ADR templates following the Nygard format with sections for context, decision, consequences, and alternatives. Helps teams maintain architectural memory and rationale for backend systems, API designs, database choices, and infrastructure decisions.

technical-clarity

242
from aiskillstore/marketplace

Audit technical writing for learner comprehension and accessibility. Use when reviewing documentation, tutorials, or educational content for clarity.

technical-research

242
from aiskillstore/marketplace

Technical spike and research investigation specialist. Use when exploring options for a technical decision, conducting timeboxed investigations, or evaluating technology choices.