Agent skill

Decision Record

by murphytrueman in murphytrueman/design-system-ops

Write a narrative decision record (ADR) for a design system choice: context, options, trade-offs, consequences, including declined proposals.

MITAuto-check passedFrontend & Design

Install Decision Record

skills CLI
$ npx skills add murphytrueman/design-system-ops --skill decision-record -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install murphytrueman/design-system-ops decision-record --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/murphytrueman/design-system-ops.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/decision-record .claude/skills/decision-record && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
decision-record
GitHub stars
201
Token cost
~2.8k tokens
SKILL.md length
1,629 words
Files
1
Skills in repo
36
Repo updated
First seen
Licence
MIT

At a glance

Write a narrative decision record (ADR) for a design system choice: context, options, trade-offs, consequences, including declined proposals.

  • Works in 6 steps: Decision trigger checklist → Clarify the decision → Write the record → …
  • Tasks that involve Design systems
  • SKILL.md covers Before you begin: verify…, Context, Step 0: Decision trigger… and Step 0b: Find the team's…, plus 6 more sections
  • Calls npx

What it does

Decision Record is an agent skill from murphytrueman/design-system-ops. Write a narrative decision record (ADR) for a design system choice: context, options, trade-offs, consequences, including declined proposals. Triggers: document this decision, ADR, why did we choose, capture the reasoning. Machine-checkable rules: governance-encoder.

Its SKILL.md is about 2.8k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Frontend & Design, covering Design systems, Architecture decision records and Proposals and quotes. The repository describes itself as: Claude Code skills for the work that keeps a design system alive. The licence is MIT.

When your agent uses it

  • Tasks that involve Design systems
  • Tasks that involve Architecture decision records
  • Tasks that involve Proposals and quotes

Example prompts

  • “/decision-record”

Requirements

  • Node.js
  • Pre-approved tools (allowed-tools): Read, Write, Grep, Glob, Bash(cat:*), Bash(find:*), Bash(head:*), Bash(ls:*), Bash(grep:*), Bash(rg:*)

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Decision trigger checklist
  2. Clarify the decision
  3. Write the record
  4. Write the file
  5. Suggest a review trigger
  6. Summarise in chat

What it can do on your machine

Read from SKILL.md and the folder at commit f167898. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Write
    • Grep
    • Glob
    • Bash(cat:*)
    • Bash(find:*)
    • Bash(head:*)
    • Bash(ls:*)
    • Bash(grep:*)
    • Bash(rg:*)

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • npx

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use npx, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Decision Record loads about 2.8k tokens when it runs. Until then it costs about 71 tokens; SKILL.md has 1,629 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~71
When it runs · the whole SKILL.md, loaded when a task matches
~2.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from murphytrueman/design-system-ops at commit f167898, republished under its MIT licence (© murphytrueman). 1,629 words, ~2,845 tokens.

Download SKILL.mdSave it as .claude/skills/decision-record/SKILL.md (or your agent's skills folder).
name
decision-record
description
Write a narrative decision record (ADR) for a design system choice: context, options, trade-offs, consequences, including declined proposals. Triggers: document this decision, ADR, why did we choose, capture the reasoning. Machine-checkable rules: governance-encoder.
allowed-tools
Read, Write, Grep, Glob, Bash(cat:*), Bash(find:*), Bash(head:*), Bash(ls:*), Bash(grep:*), Bash(rg:*)
references
../../knowledge-notes/component-governance.md, ../../knowledge-notes/output-discipline.md

Decision record

A skill for creating structured decision records for design system choices. Covers component decisions, token architecture choices, tooling selections, governance policies, and any other decision worth recording so future contributors do not have to reverse-engineer the reasoning.

Before you begin: verify references

Confirm that every path in this skill's frontmatter references: exists relative to this SKILL.md. If any is missing, stop: the install is incomplete, usually because a flattening installer (for example npx skills install) dropped the repo-root knowledge-notes/ directory. Tell the user to reinstall by a method in 1-INSTALL.md and run verify-install.sh from the install root. Proceed without the references only if the user explicitly says to, and then say in the output that it was produced without the pack's reference material.

Context

Design systems accumulate decisions faster than they accumulate documentation. The result is a system where the current state is known but the reasoning is not — which means the same debates recur, constraints get ignored because their origin is forgotten, and new team members spend weeks learning by collision what a thirty-minute conversation would have covered.

A decision record does not need to be formal. It needs to be findable and honest. The format below is lightweight enough to write in under twenty minutes and structured enough to be useful when someone reads it twelve months later.


Step 0: Decision trigger checklist

Before writing a record, confirm this decision warrants one. Not every choice needs a formal record — but more decisions warrant records than teams typically capture. Use this checklist:

Create a decision record if any of these are true:

  • The decision affects more than one consuming team
  • The decision involves a trade-off where reasonable people could disagree
  • The decision will be referenced during future contribution reviews
  • The decision changes a naming convention, token architecture, or API contract
  • The decision deprecates or removes something from the system
  • Someone asked "why do we do it this way?" and the answer was not documented
  • The same question has come up more than once

Skip the decision record if all of these are true:

  • The decision affects only one component's internal implementation
  • The decision is easily reversible with no consumer impact
  • The decision follows an existing, documented convention without exception

When in doubt, write the record. A twenty-minute investment in documentation saves hours of re-discovery and re-debate.

Step 0b: Find the team's existing records

Before writing, look for where decisions already live and match it: docs/adr/, docs/decisions/, adr/, decisions/, an .adr-dir file (adr-tools), a MADR template (template.md with "Decision Drivers" and "Considered Options"), a log4brains config, or a docs-platform section the user names. If records exist, use their template's section names and their numbering (sequential NNNN- prefixes are the norm; take the next number). If none exist, use docs/decisions/NNNN-<kebab-title>.md starting at 0001, and say so. Don't invent a date-based id scheme: two decisions in one month would collide.

Step 1: Clarify the decision

Ask for or confirm:

  • What was decided? (One clear sentence)
  • When was this decided?
  • Who was involved in making the decision?
  • Is this decision already made, or is it still in progress?
  • What options were considered, and why was each rejected? Get these from the user or from linked sources (meeting notes, PR threads, RFCs)

If the decision is in progress, the record still gets written — just with an open status. Decision records for in-progress decisions are often the most valuable, because they capture the thinking before it is lost in the gap between discussion and resolution.

Step 2: Write the record

Use the following structure. Impact assessment is conditional; every other section appears in every record.

Record only options, reasons and trade-offs the user supplied or that appear in the sources you were given. Where something is missing, write [unknown — ask X] naming who would know. Never infer rationale: a plausible reason that nobody actually gave is worse than a visible gap, because future readers will treat it as fact.


Decision record: [title]

ID: [sequential, matching the team's existing records, e.g. 0007] Date: [when the decision was made or this record was created] Status: Proposed / Accepted / Declined / Superseded / Deprecated Deciders: [who made the decision] Author: [who wrote this record, if different]

Use Declined for proposals that were turned down (for example, rejection records from contribution-workflow); the record then explains which criteria weren't met and under what conditions it could be revisited.


Context

What was the situation that made this decision necessary? What problem was being solved, or what question needed an answer?

Write this as a factual description of the state of the world at the time of the decision. Include any constraints that shaped the decision space — technical, organisational, time-based, or otherwise. Do not frame the context to make the eventual decision look inevitable. Future readers need to understand the real landscape, including the pressures that influenced the outcome.

Two to four sentences is usually enough.

Decision drivers

The three to five forces that decided it: a constraint, a requirement, a cost, a deadline, a team preference. Each from the user or a source; none inferred. This is the section future readers use to tell whether the decision still holds when the forces change.

Options considered

List each option that was genuinely evaluated. For each option:

  • Name or brief description
  • Why it was a viable candidate
  • Why it was not chosen (if it was not)

Do not list options that were not seriously considered — this section should reflect the actual decision space, not a post-hoc justification exercise. If only one option was considered, say so and explain why.

The option that was eventually chosen should also appear here, with a note that it was selected and a forward reference to the decision section.

Show full SKILL.md (679 more words)Show less
Decision

State the decision in one sentence. Then explain the primary reasoning in two to four sentences.

Be honest about trade-offs. If the chosen option had weaknesses that were accepted, name them. If the decision was influenced by non-technical factors — timelines, team preferences, tooling constraints — include that. Decision records that paper over trade-offs are records of what was decided, not why, which makes them significantly less useful.

Impact assessment (API, token or breaking changes only)

Include this section when the decision changes a component API, token names or values, or anything consumers must migrate. Skip it for conventions, tooling and process decisions with no migration cost.

Impact dimensionMeasurement
Files affected[count — from grep/search if available]
Components affected[count and names]
Consuming teams affected[count and names]
Migration effort[user-supplied estimate, or "not measured"]
Token/API changes required[count]
Breaking changes[yes/no — if yes, list them]
Timeline to full adoption[user-supplied, or "not measured"]

If codebase access is available, run searches to populate the counts. For example, if the decision is to adopt DTCG token format, count how many token files need restructuring, how many consuming files reference tokens, and how many teams own those files.

Where a row wasn't measured, write "not measured" and name the audit skill that would measure it. Don't fill rows with estimates; effort and timeline only go in if the user supplied them, labelled as theirs.

Consequences

What changes as a result of this decision? What becomes easier, and what becomes harder?

This section should cover both intended outcomes and known risks. If the decision introduces a dependency, a constraint, or a new obligation for contributors, document it here. If it closes off a future option, name that too.

Supersedes / superseded by

If this decision replaces a previous decision, reference it here. If this decision is later superseded, this field gets updated with the reference to the new record.

Any other decision records relevant to understanding this one. Links or IDs are sufficient.

Step 3: Write the file

Write the record to the location and with the numbering found in Step 0b, and say the path. If the team keeps decisions on a documentation platform rather than in the repo, produce the record in chat for pasting and say where it belongs. If the location is unknown and the user hasn't said, ask once; don't leave the record only in chat by default.

Step 4: Suggest a review trigger

Decision records go stale. Suggest a condition that should prompt this record to be revisited — for example, a tooling change, a team size threshold, a specific dependency version, or a timeline milestone.

This does not need to be elaborate. One sentence is enough: "Revisit this decision if the team grows beyond ten active contributors or if the token tooling changes."

Step 5: Summarise in chat

  • Headline: the decision, its status and the file written
  • Open: every [unknown — ask X] left in the record
  • Next: the skills that follow from the decision's consequences, in chat rather than in the permanent record: deprecation-process for a removal, token-audit for a token architecture change, version-bump-advisor then change-communication for an API change, governance-encoder for a new convention, codemod-generator when many consumers must change, stakeholder-brief for a large investment
  • Scope: what sources were read (meeting notes, PRs, RFCs) and what the impact counts came from

Quality checks

  • The record matches the team's existing ADR format and numbering, and was written to the repository or produced for the platform the team uses
  • Decision drivers are present and each traces to the user or a source
  • Context describes the actual situation, not a setup for the conclusion
  • Options considered reflects the real decision space, not a post-hoc list
  • Every option, reason and trade-off traces to the user or a named source; gaps are marked [unknown — ask X]
  • Decision section names the trade-offs that were accepted, not just the benefits
  • Consequences covers both intended outcomes and known risks
  • Record is written for someone who was not in the room — no assumed context
  • Status field is set correctly
  • A review trigger is included

© murphytrueman, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/decision-record of murphytrueman/design-system-ops.

Open the folder on GitHubat commit f167898

Compare with similar skills

Decision Record next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Decision Record compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Decision Record this skillmurphytrueman/design-system-ops201—~2.8kAutomated safety check: PassMIT
Typeui Fundamentalsbergside/typeui2k—~861Automated safety check: PassMIT
Ds Planbaloise/design-system114—~1.6kAutomated safety check: PassApache-2.0
Design Standardsrampstackco/claude-skills935—~2.4kAutomated safety check: PassMIT
Design System ContextHermeticOrmus/LibreUIUX-Claude-Code111—~5kAutomated safety check: PassMIT
Architectdralgorhythm/claude-agentic-framework124—~475Automated safety check: PassNone

Similar skills

  • Typeui Fundamentals

    bergside/typeui

    Universal UI/UX design principles covering visual hierarchy, interaction laws, typography foundations, and WCAG accessibility requirements.

    2k GitHub stars~861 tokensUpdated 3 mo ago
    Frontend & DesignAuto-check passed
  • Ds Plan

    baloise/design-system

    Generate phased implementation plans for design system components with adaptive scope, design decisions, and risk assessment

    114 GitHub stars~1.6k tokensUpdated today
    Frontend & DesignAuto-check passed
  • Design Standards

    rampstackco/claude-skills

    Apply production-grade design standards when building or reviewing pages, components, or UI.

    935 GitHub stars~2.4k tokensUpdated today
    Frontend & DesignAuto-check passed
  • Design System Context

    HermeticOrmus/LibreUIUX-Claude-Code

    Keeping a design system in an LLM's context: loading tokens compactly, persisting design decisions across sessions, handling multiple variants, and budgeting the context window.

    111 GitHub stars~5k tokensUpdated 2 days ago
    Frontend & DesignAuto-check passed
  • Architect

    dralgorhythm/claude-agentic-framework

    Design systems and record architecture decisions as ADRs — a user-invoked Principal Architect workflow.

    124 GitHub stars~475 tokensUpdated 2 mo ago
    Frontend & DesignAuto-check passed
  • Impeccable

    bestofjs/bestofjs

    A skill your agent uses when the user wants to design, redesign, shape, critique, audit, polish, clarify, distill, harden, optimize, adapt, animate, colorize, extract, or otherwise improve a…

    3.1k GitHub starsUsed in 27 repos~2.6k tokens
    Frontend & DesignAuto-check passed

More from murphytrueman/design-system-ops

All 36 skills in this repo
  • Agent Instructions

    murphytrueman/design-system-ops

    Write the AGENTS.md that tells coding agents how to use this design system: where things live, sourced rules, how to check work, what not to do; Claude, Cursor or Copilot pointers on request.

    201 GitHub stars~2.3k tokensUpdated 13 days ago
    Auto-check passed
  • AI Component Description

    murphytrueman/design-system-ops

    Write a six-section prose description (purpose, props, anti-patterns, composition, accessibility, examples) for a Figma component's description field so LLMs read it via MCP.

    201 GitHub stars~4.7k tokensUpdated 13 days ago
    Auto-check passed
  • Change Communication

    murphytrueman/design-system-ops

    Write release notes, a migration guide and a team announcement for a design system change that is already decided, scaled to its impact.

    201 GitHub stars~3.4k tokensUpdated 13 days ago
    Auto-check passed
  • Codebase Index

    murphytrueman/design-system-ops

    Generate machine-readable index files in .ai/index/ (component inventory, uses/usedBy graph, stats) for AI agents.

    201 GitHub stars~4.7k tokensUpdated 13 days ago
    Auto-check passed
  • Codemod Generator

    murphytrueman/design-system-ops

    Generate tested jscodeshift/postcss codemods for design system migrations: token renames, prop renames or removals, import paths, component swaps.

    201 GitHub stars~4.9k tokensUpdated 13 days ago
    Auto-check passed
  • Component API Validator

    murphytrueman/design-system-ops

    Audit prop APIs across a component library: naming consistency, boolean/default patterns, type coverage, exported types, breaking changes between versions.

    201 GitHub stars~4.3k tokensUpdated 13 days ago
    Auto-check passed

Questions about Decision Record

What does Decision Record do?

Write a narrative decision record (ADR) for a design system choice: context, options, trade-offs, consequences, including declined proposals. Decision Record is an agent skill from murphytrueman/design-system-ops. Write a narrative decision record (ADR) for a design system choice: context, options, trade-offs, consequences, including declined proposals.

When should I use Decision Record?

Decision Record fits situations like: tasks that involve Design systems; tasks that involve Architecture decision records; tasks that involve Proposals and quotes.

How do I install Decision Record in Claude Code?

Run `npx skills add murphytrueman/design-system-ops --skill decision-record -a claude-code`. Or copy the skill folder (skills/decision-record in murphytrueman/design-system-ops) into .claude/skills/decision-record in your project. Claude Code loads it when a task matches its description.

How do I install Decision Record in Codex?

Run `npx skills add murphytrueman/design-system-ops --skill decision-record -a codex`. Or copy the skill folder (skills/decision-record in murphytrueman/design-system-ops) into .agents/skills/decision-record in your project. Codex loads it when a task matches its description.

Can I use Decision Record in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add murphytrueman/design-system-ops --skill decision-record -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/decision-record, .gemini/skills/decision-record, .github/skills/decision-record and .opencode/skills/decision-record in your project.

What does Decision Record need to run?

Going by SKILL.md and its folder, Decision Record needs the command-line tools its instructions call (npx). Our summary lists: Node.js. Its frontmatter pre-approves these tools: Read, Write, Grep, Glob, Bash(cat:*), Bash(find:*), Bash(head:*), Bash(ls:*), Bash(grep:*), Bash(rg:*).

Does Decision Record access the network?

SKILL.md contains no URLs. Its commands use npx, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Decision Record safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Decision Record use?

Decision Record is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Decision Record use?

About 2.8k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Decision Record?

Skills that share tags, products or a category with Decision Record: Typeui Fundamentals (bergside/typeui, 2k stars), Ds Plan (baloise/design-system, 114 stars), Design Standards (rampstackco/claude-skills, 935 stars) and Design System Context (HermeticOrmus/LibreUIUX-Claude-Code, 111 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Decision Record?

murphytrueman (a GitHub user) maintains it in murphytrueman/design-system-ops, which has 201 GitHub stars. The repository holds 36 skills in this directory. The repository was last updated on September 24, 2026.

Source: murphytrueman/design-system-ops on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.