Agent skill

Rigor Adr Author

by rigortype in rigortype/rigor

Author and wire a new Architecture Decision Record under docs/adr/.

MPL-2.0Auto-check passedDevelopment

Install Rigor Adr Author

skills CLI
$ npx skills add rigortype/rigor --skill rigor-adr-author -a claude-code

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

GitHub CLI
$ gh skill install rigortype/rigor rigor-adr-author --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/rigortype/rigor.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/rigor-adr-author .claude/skills/rigor-adr-author && 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
rigor-adr-author
GitHub stars
106
Token cost
~2.7k tokens
SKILL.md length
1,364 words
Files
1
Skills in repo
36
Repo updated
First seen
Licence
MPL-2.0

At a glance

Author and wire a new Architecture Decision Record under docs/adr/.

  • Works in 6 steps: Does this even need an ADR? → Tag archetype + stakes (per ADR-49) → Pick the skeleton for the archetype → …
  • A decision needs an ADR
  • SKILL.md covers Step 0 — Does this even need…, Step 1 — Tag archetype +…, Step 2 — Pick the skeleton for… and Step 3 — Write the body, sized…, plus 3 more sections
  • Calls git, make and nix

What it does

Rigor Adr Author is an agent skill from rigortype/rigor. Author and wire a new Architecture Decision Record under docs/adr/. Use when a decision needs an ADR, including numbering, index wiring, and verification; not for type/internal-spec edits, and not instead of the ADR-49 quality rubric.

Its SKILL.md is about 2.7k 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 Development, covering Architecture decision records. The repository describes itself as: Inference-first static analysis for Ruby. The licence is MPL-2.0.

When your agent uses it

  • A decision needs an ADR
  • Including numbering
  • Not for type/internal-spec edits
  • Not instead of the ADR-49 quality rubric

Example prompts

  • “/rigor-adr-author”

Workflow steps

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

  1. Does this even need an ADR?
  2. Tag archetype + stakes (per ADR-49)
  3. Pick the skeleton for the archetype
  4. Write the body, sized to the stakes
  5. Mechanical wiring (where authoring slips)
  6. Verify

What it can do on your machine

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

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git
    • make
    • nix
    • bundle

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

  • Network

    No URLs in SKILL.md. Its commands use git, 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

Rigor Adr Author loads about 2.7k tokens when it runs. Until then it costs about 63 tokens; SKILL.md has 1,364 words of instructions outside code blocks.

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

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 rigortype/rigor at commit 57a67cf, republished under its MPL-2.0 licence (© rigortype). 1,364 words, ~2,699 tokens.

Download SKILL.mdSave it as .claude/skills/rigor-adr-author/SKILL.md (or your agent's skills folder).
name
rigor-adr-author
description
Author and wire a new Architecture Decision Record under `docs/adr/`. Use when a decision needs an ADR, including numbering, index wiring, and verification; not for type/internal-spec edits, and not instead of the ADR-49 quality rubric.
metadata.internal
true

Author an ADR

This skill is the procedure for adding an ADR. The quality bar is docs/adr/49-adr-authoring-guidelines.md — read it; do not re-derive or restate its rubric here. The skill's job is to route the decision to the right shape, then get the mechanical wiring (numbering + two index updates + verification) right, which is where ADR authoring actually slips.

The one empirical lever from the corpus audit (docs/notes/20260605-adr-corpus-rubric-audit.md): the corpus's only systematic drift is over-information, never thin. So the recurring authoring mistake is writing too much for the stakes, not too little. Bias toward brevity; let stakes earn length.

Step 0 — Does this even need an ADR?

An ADR records a decision with rationale and rejected alternatives, or a standing policy. It is not the home for:

  • A mechanical change with no live alternatives (just do it; note in CHANGELOG.md).
  • Behaviour the spec corpus (docs/type-specification/, docs/internal-spec/) should own — when a change touches type-language behaviour or an analyzer contract, the spec binds; the ADR records why, not what. Put the normative rule in the spec, the rationale in the ADR.
  • A point-in-time measurement or survey — that is a docs/notes/ note (which an ADR may then cite as grounding).

If the decision is real but small and forced, it can still be an ADR — see the Mechanical archetype below. If there is no decision (no alternatives were weighed), it is probably a note or a CHANGELOG line, not an ADR.

Step 1 — Tag archetype + stakes (per ADR-49)

Before writing, fix the two tags ADR-49 defines. They decide which axes you must satisfy and how long the ADR may be.

  • Archetype — Deliberative / Mechanical-policy / Evaluation-proposal. This sets which axes are core vs exempt.
  • Stakes — low / mid / high, by reversibility × blast-radius × whether it touches the false-positive / soundness envelope. This sets the length budget (Step 3) and how hard the intent/criterion axes are read.

Do not skip this. A mis-tag is the usual cause of a bloated mechanical ADR or a thin high-stakes one.

Step 2 — Pick the skeleton for the archetype

The repo's structural contract (from docs/adr/README.md § "Adding a New ADR") is Status / Context / Decision / Consequences. Layer the archetype shape on top:

Deliberative (e.g. ADR-43, 45, 46, 26, 35)
markdown
# ADR-N — <title>

Status: **<state>, <date>.** <one-paragraph what-landed / what-remains.>

Grounding: <links to the note(s) / spike(s) this rests on, if any>

## Context        — the problem, the gap, why now (intent lives here)
## Decision       — the decision + the discriminating CRITERION (the reusable rule)
## Working decisions (WD1…) — the load-bearing sub-choices, each with its reason
## Rejected / deferred alternatives — table or list, each with a reason
## Consequences   — positive / negative / carry-over
## Relationship to other ADRs — cross-refs

The two axes that make a deliberative ADR earn its keep (ADR-49 axes 1–2): a crisp intent in Context, and a decision criterion in Decision that is a reusable rule ("this class's RBS is authoritative and complete → a call it omits is a mistake"), not merely "we picked B."

Mechanical / policy (e.g. ADR-40, 38, 33)

Same skeleton, shorter. Intent may be one line (ADR-49 scores it generously or N/A here — do not pad it). The rejected-alternatives table still earns Criterion; keep it. Economy is weighted up — a small change must read small. ADR-40 / ADR-33 are the length targets.

Evaluation / proposal (e.g. ADR-21, 41, 30, 42)

Same skeleton, but the Status is "Proposed" and there is no shipped measurement yet (ADR-49 exempts the evidence sub-part of axis 5 — survey grounding still counts; a shipped benchmark does not exist yet). State the re-evaluation triggers explicitly (these are the guardrails). Watch economy hardest here: a "defer / demand-gate this" decision paying full-deliberation length is the corpus's commonest over-write (audit finding 2).

Step 3 — Write the body, sized to the stakes

Defer to ADR-49 for what good looks like on each axis. The economy discipline, concretely:

  • Length tracks stakes. A high-stakes engine/FP decision earns ADR-46's length; a low/mid mechanical or evaluation ADR should read like ADR-33 / ADR-40. If a low-stakes or evaluation ADR is growing past ~ADR-33 length, that is the smell — trim or move material out.
  • Move reference tables to a linked note. Large PHPStan/TS comparison tables or survey dumps belong in docs/notes/, cited as grounding (the ADR-1 / ADR-16 over-length pattern the audit flagged). Keep the ADR the decision, not the research.
  • The dense landed-status opening paragraph is a sanctioned trade. A one-paragraph "what landed / what remains" status block (ADR-46, ADR-24) doubles as a resume bookmark — keep it even though it costs a little economy; do not trim a load-bearing status block to chase brevity.
  • Anchor to real code where you can (file + approx. line + the surrounding real symbols) — this is ADR-43 WD2's rbs_dispatch.rb ~L270 shape, and it is what makes an ADR implementable rather than aspirational.

Step 4 — Mechanical wiring (where authoring slips)

Three files change together. Get the ordering right.

4a. The ADR file

Find the next number:

sh
ls docs/adr/ | grep -E '^[0-9]+-' | sort -n -t- -k1 | tail -3

Write docs/adr/<N>-<kebab-title>.md.

4b. docs/adr/README.md index row — ascending order

The index table is ordered ADR-0, 1, 2, …. Insert the new row after the current-highest row, before the ## Adding a New ADR heading — not before the previous row. (This ordering is the easy slip: anchor the edit on the last table row + the heading, not on the previous-number row.) Row shape: | ADR-N | [Title](N-slug.md) | <status> |.

The third column is headed Status and carries exactly that — the README's own "How to Read" is the contract: Accepted / Proposed / Superseded, plus one parenthetical for an in-flight implementation (which WD/slice landed, what remains, a version or PR). Cap: 200 characters, one line, no |. Derive it from your ADR's own Status: block so the two cannot disagree — that block is canonical (ADR-92).

Not a summary: no criteria, no rationale, no rejected alternatives, no measurements. They are in the ADR body, and duplicating them here is what grew this column to 5,195 characters a cell before ADR-97 capped it.

| ADR-40 | [`config_schema` declared defaults](40-config-schema-defaults.md) | Accepted (mechanism + 13 plugins migrated off the `DEFAULT_*` idiom) |
Show full SKILL.md (476 more words)Show less
4c. AGENTS.md — usually nothing to do

AGENTS.md is loaded into context at the start of every session, so its ADR list is a premise set, not an index (ADR-97 WD1): only the ADRs an agent would get wrong without knowing to look them up — the foundation / conceptual core (ADR-0–5) and the standing policies in force. The gate caps it at 12 entries.

Your ADR almost certainly does not belong there. It earns a line only if it is a new standing policy — a rule that binds a contribution whatever it touches, not merely an important decision in its own area. "This is significant" is not the test; "a session that never thought to look this up will do the wrong thing" is. When in doubt, leave it out: docs/adr/README.md is one hop away, and the gate will not let you quietly spend the session budget.

If it genuinely qualifies, add - [ADR-N](docs/adr/N-slug.md) — <topic> to the matching sub-list: topic only, ≤ 100 characters, no status, no dates, no measurements, no WD references.

The gate is spec/docs/agent_index_spec.rb under make docs-check.

(If the ADR establishes a SKILL, a release process, or anything an agent should discover, also add/adjust the relevant CLAUDE.md / AGENTS.md pointer — most ADRs do not need this.)

Step 5 — Verify

sh
git diff --check                                # whitespace
git status --short                              # expect: new ADR file + modified docs/adr/README.md
                                                # (+ AGENTS.md only in the rare 4c case)
nix develop --command make docs-check         # gates the index rules (ADR-97)

ADR authoring is docs-only, so the code gates are not required for the ADR itself. If the ADR lands alongside an implementation slice, that slice follows the normal protocol (AGENTS.md § "Validation": make verify-changed locally, CI on the Draft PR) — but the ADR text does not gate on it. An ADR records a decision, so its PR stays Draft for the user (docs/agents/contribution-flow.md § "Landing a pull request").

Commit and release rules are in docs/agents/contribution-flow.md; bundle exec rake release needs explicit authorization. A new ADR is a reasonable single commit (Add ADR-N — <title> or, if it lands with code, fold it into that slice's commit).

Quick checklist

  • Step 0 cleared: this is a decision/policy, not a CHANGELOG line, a spec rule, or a note.
  • Archetype + stakes tagged; skeleton chosen to match.
  • Intent (Context) and decision criterion (Decision) are present and crisp for a deliberative ADR; not padded for a mechanical one.
  • Rejected/deferred alternatives recorded with reasons.
  • Length is proportional to stakes — reference dumps moved to a note; not over-written for a low-stakes / evaluation decision.
  • docs/adr/README.md row inserted in ascending position (after the last row, before ## Adding a New ADR) — status only, ≤ 200 chars, derived from your ADR's own Status: block (ADR-97).
  • AGENTS.md — confirmed the ADR is a lookup, so no line added (the normal case); or it is a new standing policy and earns one (ADR-97).
  • make docs-check green — it gates both lists.
  • git diff --check clean; git status shows exactly the expected entries (normally two: the ADR file + docs/adr/README.md).
  • Quality re-read against ADR-49: which one or two axes drag, and is that drag archetype-correct (fine) or a real gap (fix)?

© rigortype, MPL-2.0. 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 .claude/skills/rigor-adr-author of rigortype/rigor.

Open the folder on GitHubat commit 57a67cf

Compare with similar skills

Rigor Adr Author 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.

Rigor Adr Author compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Rigor Adr Author this skillrigortype/rigor106—~2.7kAutomated safety check: PassMPL-2.0
PR Design DocOpenHands/OpenHands90k—~2.4kAutomated safety check: PassMIT
Cto AdvisorIbrahim-3d/orchestrator-supaconductor3814 repos~2.4kAutomated safety check: PassMIT
Architecture DecisionDonchitos/Claude-Code-Game-Studios26k—~1.7kAutomated safety check: PassMIT
Improve Codebase Architectureywwynm/EverythingDone14415 repos~1.3kAutomated safety check: PassGPL-3.0
Domain Modelingbrim-borium/spotify_sdk1665 repos~806Automated safety check: PassApache-2.0

Similar skills

  • PR Design Doc

    OpenHands/OpenHands

    For a non-trivial pull request, write a self-contained HTML design doc under the temporary .pr/ directory and link a visibility-appropriate preview in the PR description, so maintainers grasp the…

    90k GitHub stars~2.4k tokensUpdated today
    DevelopmentAuto-check passed
  • Cto Advisor

    Ibrahim-3d/orchestrator-supaconductor

    Technical leadership guidance for engineering teams, architecture decisions, and technology strategy.

    381 GitHub starsUsed in 4 repos~2.4k tokens
    DevelopmentAuto-check passed
  • Architecture Decision

    Donchitos/Claude-Code-Game-Studios

    Create an ADR documenting a technical decision: context, alternatives considered, consequences.

    26k GitHub stars~1.7k tokensUpdated yesterday
    DevelopmentAuto-check passed
  • Improve Codebase Architecture

    ywwynm/EverythingDone

    Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/.

    144 GitHub starsUsed in 15 repos~1.3k tokens
    DevelopmentAuto-check passed
  • Domain Modeling

    brim-borium/spotify_sdk

    Build and sharpen a project's domain model. An agent skill from brim-borium/spotify_sdk.

    166 GitHub starsUsed in 5 repos~806 tokens
    DevelopmentAuto-check passed
  • Design Doc Mermaid

    SpillwaveSolutions/design-doc-mermaid

    Create Mermaid diagrams (flowchart, sequence, class, ER, state, C4, architecture) from text or source code.

    176 GitHub starsUsed in 1 repo~5.6k tokens
    DevelopmentAuto-check passed

More from rigortype/rigor

All 36 skills in this repo
  • Rigor Regression Sweep

    rigortype/rigor

    Measure Rigor's baseline drift across the tagged history of a real OSS Ruby project.

    106 GitHub stars~2.9k tokensUpdated yesterday
    Auto-check passed
  • Adjudicate a rigor unused report safely before proposing dead-code removal.

    106 GitHub stars~1.1k tokensUpdated yesterday
    Auto-check passed
  • Rigor Baseline Reduce

    rigortype/rigor

    Reduce an existing .rigor-baseline.yml rule by rule by triaging sites, fixing or intentionally suppressing them, and regenerating the baseline.

    106 GitHub stars~1.3k tokensUpdated yesterday
    Auto-check passed
  • Rigor Doctor

    rigortype/rigor

    Validate that a project's Rigor configuration, plugins, paths, and baseline are actually healthy.

    106 GitHub stars~767 tokensUpdated yesterday
    Auto-check passed
  • Rigor Plugin Author

    rigortype/rigor

    Author a new Rigor plugin, choosing plugins/ for production support or examples/ for a contract walkthrough.

    106 GitHub stars~3.3k tokensUpdated yesterday
    Auto-check: notes
  • Rigor Plugin Author

    rigortype/rigor

    Author a Rigor plugin in an adopting project or standalone rigor- gem for a DSL, framework, or metaprogramming pattern.

    106 GitHub stars~1.9k tokensUpdated yesterday
    Auto-check passed

Categories

Questions about Rigor Adr Author

What does Rigor Adr Author do?

Author and wire a new Architecture Decision Record under docs/adr/. Rigor Adr Author is an agent skill from rigortype/rigor. Author and wire a new Architecture Decision Record under docs/adr/.

When should I use Rigor Adr Author?

Rigor Adr Author fits situations like: A decision needs an ADR; including numbering; not for type/internal-spec edits; not instead of the ADR-49 quality rubric.

How do I install Rigor Adr Author in Claude Code?

Run `npx skills add rigortype/rigor --skill rigor-adr-author -a claude-code`. Or copy the skill folder (.claude/skills/rigor-adr-author in rigortype/rigor) into .claude/skills/rigor-adr-author in your project. Claude Code loads it when a task matches its description.

How do I install Rigor Adr Author in Codex?

Run `npx skills add rigortype/rigor --skill rigor-adr-author -a codex`. Or copy the skill folder (.claude/skills/rigor-adr-author in rigortype/rigor) into .agents/skills/rigor-adr-author in your project. Codex loads it when a task matches its description.

Can I use Rigor Adr Author 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 rigortype/rigor --skill rigor-adr-author -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/rigor-adr-author, .gemini/skills/rigor-adr-author, .github/skills/rigor-adr-author and .opencode/skills/rigor-adr-author in your project.

What does Rigor Adr Author need to run?

Going by SKILL.md and its folder, Rigor Adr Author needs the command-line tools its instructions call (git, make, nix and bundle).

Does Rigor Adr Author access the network?

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

Is Rigor Adr Author 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 Rigor Adr Author use?

Rigor Adr Author is published under the MPL-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Rigor Adr Author use?

About 2.7k 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 Rigor Adr Author?

Skills that share tags, products or a category with Rigor Adr Author: PR Design Doc (OpenHands/OpenHands, 90k stars), Cto Advisor (Ibrahim-3d/orchestrator-supaconductor, 381 stars), Architecture Decision (Donchitos/Claude-Code-Game-Studios, 26k stars) and Improve Codebase Architecture (ywwynm/EverythingDone, 144 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Rigor Adr Author?

rigortype (a GitHub organization) maintains it in rigortype/rigor, which has 106 GitHub stars. The repository holds 36 skills in this directory. The repository was last updated on October 8, 2026.

Source: rigortype/rigor on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.