skills/chaiwithjai/technical-decision-record/SKILL.md
Use when making technical decisions, choosing technologies, or documenting architectural choices. Creates ADRs (Architecture Decision Records).
npx skillsauth add aiskillstore/marketplace technical-decision-recordInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
<framework_overview>
A structured approach to documenting technical decisions using ADRs (Architecture Decision Records). Ensures decisions are traceable, well-reasoned, and understood by the team.
Once made, an ADR is never modified—only superseded. This preserves the reasoning at the time, even if context changes later.
The "why" is more valuable than the "what." Future readers need to understand the constraints, options, and trade-offs that led to the decision.
Prefer decisions that can be changed later. Document the reversal cost for irreversible choices.
If it wasn't written down, it wasn't decided. Verbal agreements don't count as architectural decisions.
Decisions should be reviewed by affected parties. Surprise decisions create resistance. </principles>
<process> ## The ProcessWhat are we deciding? Be specific.
What limits our options?
List 2-4 real options. For each:
Choose one option. State it clearly.
What follows from this decision?
# 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
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."
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.
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.
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?What's being decided?
What triggered this decision?
How reversible should this be?
I'll help you structure the ADR based on your answers. </intake>
development
Apple Human Interface Guidelines for content display components. Use this skill when the user asks about charts component, collection view, image view, web view, color well, image well, activity view, lockup, data visualization, content display, displaying images, rendering web content, color pickers, or presenting collections of items in Apple apps. Also use when the user says how should I display charts, what's the best way to show images, should I use a web view, how do I build a grid of items, what component shows media, or how do I present a share sheet. Cross-references: hig-foundations for color/typography/accessibility, hig-patterns for data visualization patterns, hig-components-layout for structural containers, hig-platforms for platform-specific component behavior.
tools
Automate HelpDesk tasks via Rube MCP (Composio): list tickets, manage views, use canned responses, and configure custom fields. Always search tools first for current schemas.
testing
Expert Haskell engineer specializing in advanced type systems, pure functional design, and high-reliability software. Use PROACTIVELY for type-level programming, concurrency, and architecture guidance.
tools
GraphQL gives clients exactly the data they need - no more, no less. One endpoint, typed schema, introspection. But the flexibility that makes it powerful also makes it dangerous. Without proper controls, clients can craft queries that bring down your server. This skill covers schema design, resolvers, DataLoader for N+1 prevention, federation for microservices, and client integration with Apollo/urql. Key insight: GraphQL is a contract. The schema is the API documentation. Design it carefully.