A collection of prompt-based skills for Claude Code that add structured workflows for software engineering and research.
Skills are markdown files with YAML frontmatter that Claude loads as playbooks. Each skill provides a /slash-command — you invoke it, and Claude follows the skill's instructions to guide you through a specific workflow phase.
This repo can be installed two ways: as a Claude Code plugin marketplace (recommended for end users) or via the legacy symlink installer (recommended for developing/iterating on the skills themselves).
The repo root carries a .claude-plugin/marketplace.json catalog (mtrense-skills). Each workflow family is exposed as a separately-installable plugin with its own <workflow>/.claude-plugin/plugin.json manifest.
/plugin marketplace add mtrense/skills
/plugin install milestone-driven@mtrense-skills
/plugin install research@mtrense-skills
/plugin install codebase-survey@mtrense-skills
/plugin install synaptic-authoring@mtrense-skills
/plugin install common@mtrense-skillsUpdates: /plugin marketplace update. No version field is pinned, so each commit on main is treated as a new version.
# Install every workflow globally (~/.claude/skills/ + ~/.claude/agents/)
./install.sh all
# Install just one workflow globally
./install.sh milestone-driven
# Install one workflow into a specific project
./install.sh research /path/to/projectThe first argument is the workflow name (codebase-survey, common, domain-driven, milestone-driven, research, synaptic-authoring) or all. The optional second argument is the install target (defaults to $HOME). The installer creates symlinks, so skills stay up to date as you pull changes.
A phased cycle for building software, from idea through implementation to closeout. Each phase produces a specific artifact that feeds into the next. See milestone-driven/README.md for the roadmap file layout and migration instructions for existing projects.
| Phase | Command | What it does | Produces |
|---|---|---|---|
| 0 | /project-inception |
Socratic dialogue to discover project vision and goals | README.md |
| 1 | /strategic-planning |
Sharpen ideas into well-defined, testable milestones | roadmap/NNNN-slug.md + ROADMAP.md index entry |
| 2 | /milestone-breakdown |
Decompose a milestone into ordered, independently testable tasks | PLAN.md |
| 3 | /task-implementation |
Implement one task using strict TDD (tests first, then code) | Passing code + tests |
| 3 | /implementation-cycle |
Run task-implementation + commit in fresh subagents per task, then sync docs/examples to each commit, to keep the main session clean | Passing code + commits + doc commits |
| 3 | /implementation-cycle-run |
Experimental workflow-backed twin of /implementation-cycle — a standalone Workflow script that drives the per-task loop as a scripted agent() fan-out, so the two orchestration styles can be tested side by side |
Passing code + commits + doc commits |
| 4 | /milestone-closing |
Verify success criteria, document results, reset for next cycle | Updated roadmap/NNNN-slug.md + ROADMAP.md index |
| - | /commit |
Craft a conventional commit from staged/unstaged changes | Git commit |
Typical flow: inception (once) -> planning -> breakdown -> implementation (repeat per task) -> closing -> back to planning.
The milestone-driven workflow uses four bundled subagents: milestone-scout (delegated codebase reconnaissance for milestone-breakdown), task-worker (per-task task-implementation + commit worker for implementation-cycle), doc-updater (per-task documentation/examples sync, spawned by implementation-cycle after each task commit — a no-op unless the change is user- or developer-visible), and decision-lookup (read-only librarian that returns a compact briefing of the Architecture Decision Records relevant to a topic, so planning/breakdown inherit prior decisions without loading the whole log). All live in milestone-driven/agents/ and are installed alongside the workflow's skills.
Decision records and the architecture home. All architectural material lives under one architecture home — architecture/ by default, overridable per project via the .workflow-overrides/architecture-path file. It holds full ADRs at architecture/decisions/NNNN-title.md (context, decision, rationale, alternatives, consequences), a one-sentence-per-decision index at architecture/decisions.md, and crisp derived per-topic guideline summaries at architecture/<topic>.md (e.g. tech-stack.md, testing.md) that an agent reads instead of the whole log. The decision-making phases record substantial on-the-way decisions — ones that split the architecture, commit to a goal, or foreclose an expensive-to-reverse alternative — as ADRs: project-inception captures the foundational tech-shape decisions, strategic-planning the directional decisions a milestone commits to, and milestone-breakdown milestone-level architectural splits; task-implementation and milestone-closing read the log to stay consistent with it. The per-topic summaries are derived, not authored: after any ADR is recorded, the recording skill spawns the architecture-summarizer agent to rewrite the affected architecture/<topic>.md files. /spec-sharpener runs pre-implementation and writes no ADRs — the sharpened spec is its record — but reads an existing log to avoid re-opening settled decisions; a new spec-vs-ADR contradiction is routed (uphold the ADR and fix the spec, or supersede via /adr), never encoded over. In a domain-driven project the skill-owned artifacts (domain-model.md, context-map.md, bounded-contexts/, tasks/) are likewise read-only for it — findings about them route to the owning skill's revision mode.
A multi-phase system for building structured knowledge bases with source verification and quality auditing.
| Phase | Command | What it does |
|---|---|---|
| 1 | /research-inception |
Create project structure: INDEX.md, DECISIONS.md, glossary, topic stubs |
| - | /research-add-topic |
Add a new top-level topic (single chapter file or directory with chapter stubs) to an existing project |
| - | /research-add-chapter |
Add new chapter stubs under any existing directory in the topic tree (any depth) |
| 2 | /research-inquiry |
Add section outlines with RESEARCH directives to a chapter |
| 2 | /research-inquiry-cycle |
Batch research-inquiry-worker subagents over all stub topics; fully parallel within a batch (one topic per worker) |
| 3 | /research-investigation |
Write content for one section; runs as a forked research-investigation-worker subagent (context: fork) that drives the web search-fetch-verify loop inline |
| 3 | /research-investigation-cycle |
Batch Skill(research-investigation) invocations over all pending RESEARCH directives; forks run in parallel across distinct topic files within a batch, serial within a topic |
| 4 | /research-audit-consistency |
Check cross-topic contradictions; insert AUDIT directives |
| 4 | /research-audit-coverage |
Check gaps relative to the research plan; insert AUDIT directives |
| 4 | /research-audit-quality |
Check depth and sourcing adequacy; insert AUDIT directives. Fans out per-topic analysis to quality-auditor in parallel |
| 4 | /research-audit-coherence |
Check narrative flow; insert AUDIT directives. Fans out per-topic analysis to coherence-auditor in parallel |
| 4 | /research-audit-topic |
Audit one topic across every lens (consistency, coverage, quality, coherence, graphics) in one pass and advance it draft → audited; runs as a forked research-audit-worker subagent (context: fork) that inlines all lens analysis and CONFIDENCE verification |
| 4 | /research-audit-cycle |
Batch Skill(research-audit-topic) invocations over all draft topics; forks run in parallel across distinct topics within a batch, lenses serial within a topic. Takes [max-items][@workers]; drives topics to audited; resumable/idempotent |
| - | /research-ingest-source |
Ingest a specific source you already have (URL or file): vet it for legitimacy like investigation, then weave it into every existing section it corroborates or contradicts. Delegates the placement scan to corpus-locator |
| 5 | /research-refine |
Resolve audit findings (correct, expand, condense, restructure) |
| 5 | /research-refine-cycle |
Batch research-refine-worker subagents over the project's open AUDIT directives; one worker per topic file (each resolves that file's AUDITs serially via research-refine), parallel across distinct files/directories within a batch. Takes <count|all>@<workers>; resumable/idempotent. Ships list-open-audits.sh to enumerate open AUDITs deterministically |
| 6 | /research-restructure |
Structural changes at any depth: split, merge, promote, demote, nest, or flatten chapters |
| 7 | /research-glossary-sync |
Reconcile glossary against current topic content. Fans out per-topic candidate extraction to term-extractor in parallel |
Research skills track topic status through: stub -> inquiry -> draft -> audited -> done.
The research workflow uses nine bundled subagents: research-inquiry-worker (per-topic inquiry worker spawned in parallel batches by research-inquiry-cycle), research-refine-worker (per-file refine worker that resolves one topic file's open AUDIT directives serially via research-refine, spawned in parallel batches — one worker per file — by research-refine-cycle), research-investigation-worker (execution environment for the forked research-investigation skill — context: fork — spawned in parallel batches by research-investigation-cycle and also by direct human invocations of /research-investigation; hosts the inline web search-fetch-verify loop), research-audit-worker (execution environment for the forked research-audit-topic skill — context: fork — spawned in parallel batches by research-audit-cycle and also by direct human invocations of /research-audit-topic; runs every audit lens plus CONFIDENCE verification inline on one topic), confidence-verifier (CONFIDENCE-marker verifier shared by the four standalone research-audit-* lens skills; the forked research-audit-topic resolves markers inline instead), quality-auditor (per-topic depth/sourcing audit, spawned in parallel by research-audit-quality), coherence-auditor (per-topic narrative-flow audit, spawned in parallel by research-audit-coherence), term-extractor (per-topic glossary-candidate extraction, spawned in parallel by research-glossary-sync), and corpus-locator (read-only placement scout that maps a new source's claims to the sections they belong in, spawned by research-ingest-source). All live in research/agents/ and are installed alongside the workflow's skills.
A workflow for bootstrapping and maintaining an AI-consumable map of an existing codebase. Documentation is module-local so partial loading works: top-level CODEBASE.md plus <module>/CODEBASE.md per module, with derived CLAUDE.md files lifted from rule-tagged findings.
| Phase | Command | What it does |
|---|---|---|
| 1 | /codebase-survey-init |
Bootstrap: discover structure, synthesize module map, write top-level CODEBASE.md + per-module stubs |
| 2 | /codebase-survey-module <path> |
Deep-dive one module via parallel subagents (deps, API surface, wire API, tests, ops) |
| 3 | /codebase-architecture-assessment |
Cross-cutting findings (assessment.md, tagged kind: rule / kind: observation) plus synthesised architecture.md, tech-stack.md, and operations.md — all four docs/codebase/*.md files |
| 4 | /codebase-derive-instructions |
Lift kind: rule findings into CLAUDE.md (or AGENTS.md); source-anchored, verified for length and rule count |
| - | /codebase-survey-update [range/PR#] |
Incremental refresh driven by per-module surveyed_sha; only re-surveys modules whose code changed |
The workflow uses six bundled subagents (structural-discovery, dep-grapher, api-surface-extractor, wire-api-extractor, test-auditor, ops-detective) that live in codebase-survey/agents/ and are installed alongside the workflow's skills.
Skills for authoring content for Synaptic, an interactive online learning platform. A Synaptic track is a git directory of content files validated and snapshotted by the deterministic synaptic CLI; these skills draft that content against the CLI's file contract without ever adjudicating validity, minting ids, or hashing themselves. See synaptic-authoring/README.md for the content-kind and grounding contract these skills target.
| Phase | Command | What it does |
|---|---|---|
| 1 | /author-ingest |
Distil repo-local source material (a research KB or plain docs — never the web) into un-id'd reference/ files tagged with resolvable grounding refs; record reference/.ingest-state.yaml (source root, watermark SHA, provenance) for later updates. Spawns material-extractor |
| ↻ | /author-ingest-update |
Delta-aware re-ingest from a git commit range (or the recorded watermark): re-extract only changed source, reconcile against reference/ by grounding ref, and report which track nodes went STALE/BROKEN so they can be re-drafted. Repo-local only. Spawns material-extractor and grounding-tracer |
| 2 | /author-structure |
Propose the track DAG (nodes, prerequisite edges, priority) from reference/ + a track goal, then mint node ids via synaptic scaffold once the human approves. Spawns concept-mapper |
| 3 | /author-snippet |
Draft the learner-facing body of a scaffolded node from reference/ — playful low-stakes voice, always why it matters / what it unlocks, each claim grounded |
| 3 | /author-questions |
Draft multiple-choice questions with tight reference lists honoring "assessment is feedback, never a gate", then mint question ids and write files. Spawns question-smith |
| 4 | /author-gap-scan |
Audit an existing or proposed DAG for foundational gaps — concepts referenced but never taught, orphan roots, prerequisite leaps, redundant nodes. Spawns concept-mapper and coverage-auditor |
| 5 | /author-selfcheck |
The standing hand-off gate: run synaptic validate --json, summarise findings, and refuse to present an integrity-breaking snapshot |
Typical flow: ingest -> structure -> snippet (per node) -> questions (per node) -> gap-scan -> selfcheck before hand-off.
Update loop: when the ingested source moves on, ingest-update <range> refreshes reference/ and returns a worklist of STALE/BROKEN nodes -> re-run snippet/questions on those -> selfcheck.
The workflow uses five bundled read-only proposal subagents (material-extractor, concept-mapper, question-smith, coverage-auditor, grounding-tracer) that return structured reports and write no files — the orchestrating skill does the scaffolding and writing. All live in synaptic-authoring/agents/ and are installed alongside the workflow's skills.
A build workflow that takes a project from a blank page to shipped code via Domain-Driven Design strategic modeling, then drives a dependency-ordered task backlog to completion. It favors flow over batches — there is no milestone layer, just a growing backlog whose scheduling is governed by an explicit dependency DAG and organized by bounded context. Depends on the common workflow (installed alongside) for /adr and /commit. See domain-driven/README.md for the full specification.
| Phase | Command | What it does |
|---|---|---|
| 1 | /grounding |
Socratic vision session (adapted from the Agentheim brainstorm skill); produces a tight vision.md and stops there so the human controls each later phase |
| 2 | /domain-model |
Big-picture EventStorming: domain-event timeline, commands/actors, policies, external systems, aggregates, and a hotspots list → domain-model.md. Seeds with domain-seed-extractor; offers hotspots as ADRs. Re-entrant: revises the existing model diff-oriented, fed by the deviated drift worklist |
| 3 | /context-mapping |
Draws bounded contexts around the aggregate clusters + their DDD relationships + per-context ubiquitous language → context-map.md + bounded-contexts/<context>.md; the domain model's external systems land on the map as external contexts (each faced by one owned context, bound conformist/ACL/published-language). Seeds with boundary-proposer. The domain-compliance referent for every task. Re-entrant: revision mode ends with a backlog ripple pass (re-slug renames, flag split/merge tasks for /task-refine) |
| 4 | /architecture-foundation |
Socratic session (requires vision + domain-model + context-map) defining the architectural boundaries/guidelines — tech stack, persistence, integration between contexts, testing, cross-cutting concerns — general → specific. Seeds with architecture-proposer; records each decision as an ADR (via /adr), keeping the derived architecture/<topic>.md summaries in sync; makes artifact/env/context binding explicit. Closes a first run by proposing a walking-skeleton task (thin vertical slice exercising stack + persistence + one context-map relationship) so wrong ADRs surface while superseding is cheap. Re-entrant: extends the foundation pre-code; once tasks land, runs in revision mode — reads the architecturally-implicated deviated closings and supersedes contradicted decisions. The architecture-compliance referent for every task |
| 5 | /task-append |
Capture one or more tasks into the backlog as drafts from input of any quality (spec or raw dump), splitting on --- delimiters; mints an id per task, writes tasks/NNNN-slug.md, no interview |
| 6 | /task-refine |
Draft → ready todo: assess completeness/domain-compliance/size/complexity (via task-analyzer; complexity is an abstract low|medium|high reasoning-difficulty estimate persisted in frontmatter for later /task-cycle routing), interview, split oversized tasks (tombstone + rewire), wire depends_on, attach ADRs. check-dag hard gate |
| 7 | /task-cycle |
Drive ready todo tasks to done via task-worker (TDD → verify → commit). [<limit>|all][@<workers>] (default all@1); @N uses parallel git worktrees + serial integrator merge-back. Flags tasks that landed with non-trivial deviations (deviated: true) for the revision runs |
| 7 | /task-cycle-run |
Experimental workflow-backed twin of /task-cycle — a standalone Workflow script that drives the burn-down as a scripted agent() fan-out in the background, keeping the main session free for /task-append//task-refine while it runs. Same task-worker + integrator contract and argument; always uses worktrees (even @1) and pathspec-scoped scribe commits so it never sweeps the human's uncommitted work into a commit |
| ✓ | /task-status |
Read-only backlog board; the human front end to the bundled tasks.sh query helper |
| ✓ | /exemplar |
Out-of-band (the analog of /adr): brainstorm or intake one exemplar — a concrete sample artifact (config, dataset, payload, transcript, UI mock) pinning a piece of the spec down in bytes, the data twin of an ADR. Draft mode seeds a fully filled-in strawman via exemplar-drafter (values tagged grounded-with-source vs invented-as-open-question); intake mode ingests an existing artifact (sample HTML, Claude Design / Figma export — never a live URL) with the drafter annotating the provided bytes and surfacing ubiquitous-language/ADR conflicts; the bytes land on disk up front and the main session never loads the artifact — intake settles a sync mode: upstream keeps the copy a byte-exact snapshot of the export (corrections recorded as a Fix upstream list in NOTES.md, blocking promotion until a re-export closes them) while detached has the write-side exemplar-scribe apply them to the bytes. Both refine Socratically and write exemplars/<slug>/ as illustrative — the artifact plus a NOTES.md whose Pinned facts + Map (durable anchors) sections let downstream agents consume the exemplar without reading a large artifact whole; promotion to normative (binding for tasks: acceptance criteria + first test fixture) happens only via /spec-sharpener. Also offered by /architecture-foundation after decisions with a natural data shape |
| ✓ | /dossier |
Out-of-band (the fact-side sibling of /exemplar): build or extend the project's fact file on one subject — what a regulation requires, what an undocumented API actually does — as confidence-tagged, source-cited claims in dossiers/<slug>.md. Subject-keyed and accreting (contradictions kept both-ways, never silently overwritten); scoped by a human-confirmed relevance frame from vision + context map + backlog — the middle ground between answering inline and the research workflow, whose KB it distills (lifted confidence) when present. Sweep delegated to dossier-scout; writes no ADRs — decisional unknowns route out. Also the landing place for factual hotspots from /domain-model//architecture-foundation |
| ✓ | /showcase |
Human-invoked only, read-only: assess current progress and report what the human can already test or present — the done tasks composed into demoable capabilities (by bounded context, tied to vision outcomes, implemented normative exemplars as demo material) plus a step-by-step walk-through synthesized from their ## Closing → ### Manual testing records (setup commands, a numbered tour with expected observations per step, honest caveats incl. deviated departures; load-bearing steps verified against the repo first), closing with what the next /task-cycle run would add. The backward-looking demo companion to /task-status (state) and /whats-next (future) |
| ✓ | /whats-next |
Assess vision.md + domain-model.md + the context map against the backlog state (via tasks.sh, frontmatter only), surface coverage gaps incl. unintegrated external systems, an unvalidated foundation (no landed task exercises the ADRs end-to-end → walking skeleton is the top proposal), knowledge gaps (fact territory no dossier covers, open unknowns, aging watermarks → /dossier), and drift, and propose a prioritized list of next tasks — or a /domain-model//context-mapping//architecture-foundation revision when drift dominates; advisory — hands approved suggestions to /task-append, mints nothing |
The scaling law: the backlog can grow large, so no skill ever scans the task corpus — every question (ready, next-id, by-status, deviated, get, blockers, dependents, check-dag, board) is answered by the deterministic tasks.sh helper (bundled in the task-status skill dir), which parses only YAML frontmatter (yj → jq) and returns ids/counts. Ids derive from the NNNN- filename prefix. Requires yj and jq. Two sanctioned exceptions, both bounded status-gated worklists: a /domain-model or /context-mapping revision reads the ## Closing sections of exactly the ids tasks.sh deviated lists — the drift worklist that loops implementation lessons back into the strategic model — and /showcase reads the ## Closing sections of exactly the ids tasks.sh by-status done lists, whose ### Manual testing records are the raw material of its walk-through.
The workflow uses nine bundled subagents in domain-driven/agents/: six read-only scouts (domain-seed-extractor, boundary-proposer, architecture-proposer, task-analyzer, exemplar-drafter, and dossier-scout — the only scout allowed on the web, and only when the confirmed source list sanctions it) that write nothing, and three write-side workers (task-worker — TDD-implements and commits one claimed task, never touching status; integrator — sequential worktree merge-back, bounce-on-conflict; exemplar-scribe — applies the interview's anchored corrections to a sync: detached ingested exemplar artifact so /exemplar's main session never reads a large design export). The orchestrating /task-cycle owns every status write.
Takes a mixture of design references (live sites, local mocks/exports, named systems) plus Socratic dialog to a themable design system of pure HTML/CSS Tailwind components under design-system/ — kitchen-sink pages a project later lifts into a real component library. Every component has one shared DOM across themes; a theme is a <theme>-light/<theme>-dark directory pair varying only Tailwind classes and --ds-* token vars. Accessibility (WCAG AA contrast, semantic markup, focus-visible) and i18n (RTL-safe logical classes, long-string samples, locale-format slots, script-covering font stacks) are enforced by a deterministic gate (design-check.sh) plus a rendered review; assembly is deterministic (assemble.sh, marker-delimited blocks → resumable builds), and within each block every sample is a machine-addressable story (data-ds-story="variant-…|state-…|rtl|long-string", gate-checked against the spec's variant lists). Depends on the common workflow for /commit. See design-system/README.md for the full specification.
| Phase | Command | What it does |
|---|---|---|
| 1 | /design-foundation |
Distill references via reference-analyst subagents (persisted as references.md) + Socratic dialog on personality, color/type direction, density, a11y/i18n baselines, theme axes, and catalog trim → FOUNDATION.md. Offers /design-prototype loops whenever looking beats talking |
| 2 | /design-themes |
Theme axes → concrete themes: complete light+dark token strawmen via theme-drafter (contrast pre-checked, choices tagged grounded vs invented), refined Socratically with prototypes → THEMES.md + per-mode index.css/tokens.md |
| 3 | /design-components |
Spec the catalog → COMPONENTS.md: machine-readable ## Catalog list + per-component anatomy (one DOM for all themes), variants, states, a11y contract, i18n slots, theme variance. Seeded from a bundled standard catalog; no HTML yet |
| 4 | /design-build |
Burn down the catalog: one component-smith per component (all themes at once — that's what keeps the DOM shared) → fragments → deterministic assembly → design-check.sh gate → visual-critic close-out. [<limit>|all][@<workers>] (default all@4); resumable via the marker blocks |
| ✓ | /design-prototype |
Disposable side-by-side prototype (swatches with printed contrast ratios, type specimens, sample components, light + dark) in a temp file, opened for the human; only the verdict survives, recorded by the caller |
| ✓ | /design-add-component |
Spec one new component, append to the catalog, build across all themes, gate + scoped critic pass |
| ✓ | /design-add-theme |
New references (optional) + a sibling-constrained theme-drafter strawman + Socratic refinement, then reskin every component for the new pair — smiths reuse the existing DOM verbatim |
| ✓ | /design-revise |
Change an existing theme's tokens (value changes propagate free via CSS vars; renames trigger a targeted rebuild) or an existing component's structure (spec first, then rebuild everywhere); includes a foundation-drift check |
| ✓ | /design-audit |
Read-only standing gate: full deterministic check + rendered visual-critic pass → one severity-ranked report, every finding routed to the entry point that fixes it |
| ✓ | /deck-kit |
Extend the system with its presentation layer: slide masters specced into deck-kit/DECKKIT.md (seeded from a bundled standard master catalog), one deck.css bridge per theme mapping reveal.js's --r-* vars onto --ds-* tokens, masters built across every theme into sample decks via slide-smith; gated by deck-check.sh (contrast re-verified through the var chain) + deck-critic |
| ✓ | /deck-build |
Build one reveal.js presentation from the kit: scoping interview → human-approved OUTLINE.md (slide list instantiating masters + per-slide content), then SLIDE-mode slide-smith fan-out → deterministic assembly → gate → deck-critic. Overflow never shrinks type — it comes back as a proposed outline split. Resumable via the marker blocks |
| ✓ | /deck-revise |
Change the deck layer: a deck's content/order (OUTLINE.md first), a master's structure (DECKKIT.md first, rebuilt everywhere; built decks offered re-instantiation, never silently changed), or a theme's bridge (value remaps propagate free through the CSS vars) |
The workflow uses six bundled subagents in design-system/agents/: reference-analyst and theme-drafter (read-only seeds), component-smith and slide-smith (write-side — fragments only; assemble.sh/deck-assemble.sh alone write pages), and visual-critic and deck-critic (read-only — screenshot the assembled pages/decks in Chrome and judge what the deterministic gates can't: hierarchy, rhythm, dark-mode legibility, slide-frame fit, and fidelity to FOUNDATION.md).
A milestone-labelled, proof-driven build workflow. Milestones group and label tasks — never barriers or synchronization points — and every risky assumption a milestone stands on becomes a decision with an explicit proof obligation (proof: pending) that only a done task can discharge: /aim names what needs proving → /decide records it → /enrich wires a task's proves link → /land clears it with the user. Depends on the common workflow for /commit. See trajectory/README.md for the full specification.
| Phase | Command | What it does |
|---|---|---|
| 1 | /kickoff |
Socratic vision interview (users/needs, success, invariants, domain language) → VISION.md with a one-line-per-term ## Vocabulary section — the referent /enrich checks every task against. Re-entrant (diff-oriented revision); closes a first run by offering the foundational decisions (stack, persistence, testing) as a /decide batch |
| 2 | /aim |
Idea (or own proposal when invoked empty) → next milestone: outcome/benefit, decisions to make before breakdown, what needs proving. Recon via the aim-scout subagent |
| 3 | /decide |
One decision, Socratically understood then persisted to documentation/decisions/NNNN-slug.md + a DECISIONS.md index line; argless takes the next open item from the lowest-id open milestone; given an id, revises or supersedes. Milestone proof items land proof: pending + back-reference + a ## Proof claim list decomposing the decision clause by clause (so a part-proven decision can't close wholesale). Spawns decision-summarizer to rewrite the derived documentation/<topic>.md digests |
| 4 | /enrich |
Milestone → well-shaped tasks, all shaping before persistence (tasks are never split after — ids stay live for life): plan with files, decision/doc refs, complexity, depends_on, acceptance criteria, proves links. Hard gate: unresolved decision or needs-proving items refuse breakdown. Closes by writing the milestone's ## Breakdown coverage map (outcome element → tasks: or deferred:; an unresolved line holds the milestone OPEN). task-linker proposes links instead of duplicates; every task vocabulary-checked. Also re-shapes /burn's UNDERESTIMATED hand-backs |
| ✓ | /supplement |
Small milestone-less task (bug/chore/improvement) with the same rigor, incl. proposing a multi-task breakdown when the input outgrows one well-shaped task |
| 5 | /burn |
<count>@<workers> burn-down of the available set: burn-worker (TDD in a worktree, commits via /commit, model tier from complexity, overridable via .workflow-overrides/model-map) → grader (strict vs. acceptance criteria + linked decisions; reject = back to todo with feedback + one retry a tier up) → serialized burn-scribe (writes the closing record from the worker's parked report, pre-merge) → sequential merger (conflict = bounce, red post-merge suite = escalate once then break out) → serialized doc-syncer. Workers/graders self-brief from pointers; reports live in the worktree, not the session. Resumable/idempotent |
| 6 | /land |
Next all-done milestone: compliance vs. the original goal, deviations persisted (contradictions with decisions routed to /decide, never recorded over), test/demo walk-through from the closing records, docs updated, pending proofs cleared with the user claim by claim. Cross-milestone proof reported as blocked on proof: task NNNN (milestone MMMM) |
All mechanical bookkeeping runs through the bundled backlog.sh helper (ready, milestone-ready, pending-proofs, proof-claims, check, board, …) — no skill ever scans the backlog; check gates every write (dangling refs, cycles, live deps on rejected tasks) and board doubles as the user's task board. Milestone readiness is derived from more than task status: an unsettled milestone item, an unresolved coverage-map line, or an unticked proof claim each hold a milestone OPEN, because work that was never written down as a task is otherwise invisible to a status query. Ids derive from the NNNN- filename prefix. Requires yj and jq. Eight bundled subagents in trajectory/agents/: aim-scout, task-linker, grader (read-only) and burn-worker, burn-scribe, merger, doc-syncer, decision-summarizer (write-side).
| Command | What it does |
|---|---|
/pr |
Create or update a GitHub pull request for the current branch via gh — synthesises a What/Why/How body from commits and diff, defaults to draft (override with final), auto-pushes the branch |
/version-bump |
Bump the project's version (detects package.json, Cargo.toml, pyproject.toml, and similar) from major/minor/patch, an explicit x.y.z, or current (no bump — tag the version the manifest already declares, for cutting a scaffolded project's first release), then cut an annotated git tag — gathers a changelog from the commits since the last tag and writes it to CHANGELOG.md, the tag message, and the chat; defers the commit to /commit |
/setup-github-workflow |
Analyze the project and propose GitHub Actions workflows for CI and releases tailored to its stack and goal — or refresh an existing set to the latest action/library versions; interviews you on the judgement calls (branching model, CI triggers, release cadence), pins every action to a commit SHA, has target versions security-vetted by the action-security-auditor subagent, confirms before writing, and never commits |
/deckset |
Generate Deckset presentations from markdown content |
/adr |
Manually record one or more ADRs from the current conversation under the project's architecture home (architecture/decisions/ by default, overridable via the .workflow-overrides/architecture-path file), then refresh the derived architecture/<topic>.md summaries via architecture-summarizer — the human override for when a decision worth preserving was made in-session but no skill recorded it |
/audit-context |
Diagnose contradictions, ambiguities, and irrelevance in the current session context (or a given file list) |
/spec-sharpener |
Harden a greenfield project's spec/docs into an implementation-ready state — interviews you one issue at a time and edits docs in place; the sharpened spec itself is the record (no ADRs — it runs pre-implementation) |
/spec-sharpener uses two bundled subagents in common/agents/ to keep the main session lean: spec-surveyor (read-only — discovers the docs, reads the decision log, sweeps against the finding taxonomy, and returns a compact prioritized backlog; all the doc text stays inside the subagent) and decision-encoder (write-side — edits the affected docs for one resolved finding at a time; writes no ADRs). The main session holds only the compact backlog and runs the interview. Both are installed alongside the workflow's skills.
common also ships architecture-summarizer (write-side) — spawned by /adr and by every other ADR-recording skill to (re)derive the crisp per-topic architecture/<topic>.md guideline summaries from the ADRs; changelog-gatherer (for /version-bump); and action-security-auditor (for /setup-github-workflow).
/version-bump uses a third bundled subagent in common/agents/: changelog-gatherer (read-only — runs git log over the range since the last tag, classifies commits into Keep-a-Changelog sections, filters noise, and returns one ready-to-use changelog block). The raw commit list stays inside the subagent; the block is written to CHANGELOG.md, the tag annotation, and the chat.
/setup-github-workflow uses a fourth bundled subagent in common/agents/: action-security-auditor (resolves each GitHub Action to its latest stable release, pins it to the exact commit SHA, and assesses that target version for security risk — known CVEs, compromised tags, maintainer/ownership changes, unpinned transitive references — returning per-action version + SHA + findings). The raw registry/git/web lookups stay inside the subagent; the skill surfaces every finding to the human and writes the pinned owner/repo@<sha> # vX.Y.Z references.
Each skill lives in <workflow>/skills/<name>/SKILL.md and uses YAML frontmatter to configure behavior:
---
name: skill-name # becomes the /slash-command
description: ... # helps Claude decide when to auto-load
model: opus # which model to use (opus for planning, sonnet for implementation)
allowed-tools: # restrict which tools the skill can use
- Read
- Edit
disable-model-invocation: true # require explicit /slash-command (no auto-triggering)
argument-hint: "topic" # documents expected arguments
---Some skills include reference files alongside their SKILL.md (e.g., references/SAMPLE-PLAN.md) that are loaded as additional context.
For the full specification of skill frontmatter and capabilities, see the Anthropic skills documentation.
Skills are grouped by workflow at the repo root. Each workflow directory has its own skills/ and agents/ subdirectories — install.sh reads from those and symlinks them flat into <target>/.claude/skills/ and <target>/.claude/agents/.
codebase-survey/
README.md # full codebase-survey workflow specification
skills/
codebase-architecture-assessment/SKILL.md
codebase-derive-instructions/SKILL.md
codebase-survey-init/SKILL.md
codebase-survey-module/SKILL.md
codebase-survey-update/SKILL.md
agents/
api-surface-extractor.md
dep-grapher.md
ops-detective.md
structural-discovery.md
test-auditor.md
wire-api-extractor.md
common/
skills/
adr/SKILL.md
audit-context/SKILL.md
commit/SKILL.md
deckset/SKILL.md
pr/SKILL.md
setup-github-workflow/SKILL.md
spec-sharpener/SKILL.md
version-bump/SKILL.md
agents/
action-security-auditor.md
architecture-summarizer.md
changelog-gatherer.md
decision-encoder.md
spec-surveyor.md
design-system/
README.md # full design-system workflow specification
skills/
design-add-component/SKILL.md
design-add-theme/SKILL.md
design-audit/SKILL.md # + design-check.sh + references/conventions.md
design-build/SKILL.md # + assemble.sh
design-components/SKILL.md # + references/standard-catalog.md
design-foundation/SKILL.md
design-prototype/SKILL.md
design-revise/SKILL.md
design-themes/SKILL.md
deck-build/SKILL.md # + deck-assemble.sh + deck-check.sh
deck-kit/SKILL.md # + references/deck-conventions.md + references/standard-masters.md
deck-revise/SKILL.md
agents/
component-smith.md
deck-critic.md
reference-analyst.md
slide-smith.md
theme-drafter.md
visual-critic.md
milestone-driven/
skills/
implementation-cycle/SKILL.md
milestone-breakdown/SKILL.md
milestone-closing/SKILL.md
project-inception/SKILL.md
strategic-planning/SKILL.md
task-implementation/SKILL.md
agents/
milestone-scout.md
task-worker.md
doc-updater.md
decision-lookup.md
workflows/
implementation-cycle.js # Workflow script, exposed as /implementation-cycle-run
research/
README.md # full research workflow specification
skills/
research-add-chapter/SKILL.md
research-add-topic/SKILL.md
research-audit-coherence/SKILL.md
research-audit-consistency/SKILL.md
research-audit-coverage/SKILL.md
research-audit-graphics/SKILL.md
research-audit-quality/SKILL.md
research-audit-topic/SKILL.md
research-audit-cycle/SKILL.md
research-generate-graphics/SKILL.md
research-glossary-sync/SKILL.md
research-inception/SKILL.md
research-ingest-source/SKILL.md
research-inquiry/SKILL.md
research-inquiry-cycle/SKILL.md
research-investigation/SKILL.md
research-investigation-cycle/SKILL.md
research-refine/SKILL.md
research-refine-cycle/SKILL.md
research-restructure/SKILL.md
agents/
coherence-auditor.md
confidence-verifier.md
corpus-locator.md
quality-auditor.md
research-audit-worker.md
research-inquiry-worker.md
research-investigation-worker.md
research-refine-worker.md
term-extractor.md
synaptic-authoring/
README.md # content-kind + grounding contract the skills target
skills/
author-gap-scan/SKILL.md
author-ingest/SKILL.md
author-ingest-update/SKILL.md
author-questions/SKILL.md
author-selfcheck/SKILL.md
author-snippet/SKILL.md
author-structure/SKILL.md
agents/
concept-mapper.md
coverage-auditor.md
grounding-tracer.md
material-extractor.md
question-smith.md
documentation/
anthropic/skills.md # official Anthropic skills docs
install.sh # symlink installer (skills + agents) — takes <workflow|all> [target]