skills

Facilitate a Socratic session that defines a project's architectural foundation — the boundaries and guidelines every later task is built against — once vision.md, domain-model.md, and context-map.md exist. Opens the agenda with the domain model's still-open hotspots — the last gate where each must be resolved, explicitly parked, or reclassified before the build phase — then works general → specific: tech stack (languages/frameworks/runtimes), persistence/data stores, then communication & integration between contexts, testing principles, and cross-cutting concerns (error handling, observability, security, configuration, versioning, deployment). Seeds an agenda with the architecture-proposer subagent, then decides each item Socratically and records it as an ADR — which keeps the crisp per-topic summaries under architecture/ in sync. Where a decision is bound to a specific artifact, environment, or bounded context, makes that explicit. Closes a first run by proposing a walking-skeleton task — one thin vertical

Draw the project's bounded contexts and the relationships between them, working from the aggregate clusters in domain-model.md. Produces context-map.md (the overview + relationship map) and one bounded-contexts/<context>.md per context (its responsibility, boundary, relationships, and ubiquitous language). Seeds a first-pass boundary proposal with the boundary-proposer subagent, then refines it with the human. Offers to record boundary/relationship decisions as ADRs. Re-entrant: when context-map.md already exists it runs in revision mode — folding in what implementation taught (the `deviated`-flagged tasks' closing records), and ending with a backlog ripple pass that rewires or flags the live tasks a boundary change touched. The third phase of the domain-driven workflow; its contexts are the domain-compliance referent for every task.

Run a big-picture EventStorming session over the project vision and produce a single `domain-model.md` at the project root: a chronological domain-event timeline, the commands/actors that trigger them, policies and external systems, the aggregates that own consistency, and a hotspots list of unresolved decisions. Seeds the first pass with the domain-seed-extractor subagent, then refines it Socratically with the human. Offers to turn hotspots into ADRs. Re-entrant: when domain-model.md already exists it runs in revision mode, folding in what implementation taught (the `deviated`-flagged tasks' closing records) instead of re-storming from scratch. The second phase of the domain-driven workflow — its clusters feed /context-mapping.

Assess the project's vision, domain model, and context map against the current backlog state, surface the coverage gaps, and propose a prioritized list of next tasks to work on. Reads the domain artifacts directly and the backlog through the tasks.sh helper (frontmatter only — never scanning task bodies). Gaps include an unvalidated architecture foundation (ADRs recorded but no landed task exercises them end-to-end — proposes a walking-skeleton vertical slice first) and drift (deviated tasks routed to a /domain-model, /context-mapping, or /architecture-foundation revision). Advisory: it proposes tasks and, on approval, hands each to /task-append as a draft — it never mints ids, wires dependencies, or refines (that is /task-append and /task-refine). The forward-looking companion to the read-only /task-status board.

Drive ready `todo` tasks to `done`. Reads the dependency-respecting ready-set from the tasks.sh helper, claims each task (todo -> in progress), and delegates implementation to a task-worker subagent (strict TDD, verify, commit). With one worker it works in-place sequentially; with more it implements in parallel git worktrees and delegates sequential merge-back to the integrator subagent (bounce-on-conflict). The orchestrator owns every status write. Takes [<limit>|all][@<workers>] (default all@1); resumable and idempotent.

Read-only progress report for the domain-driven backlog. Runs the bundled tasks.sh helper to print a board — counts per status, the ready-set (todo tasks whose dependencies are all done), and what is blocked on what — derived live from the task files' frontmatter, never by scanning their bodies. The human-facing front end to the tasks.sh query surface every other domain-driven skill uses.

Facilitate a Socratic vision session for a new project (or a major new direction) and produce a single tight `vision.md` at the project root. Asks one question at a time, reflects back what it heard, and drives toward shared understanding of purpose, users, the problem, what success looks like, and explicit non-goals. Produces NO code, no context map, no tasks — those are separate later steps. The first phase of the domain-driven workflow. Adapted from the Agentheim brainstorm skill.

Capture one or more tasks into the domain-driven backlog as new `draft`s from human input of ANY quality — a polished spec or a half-formed brain-dump both welcome. Trigger whenever the user wants to record, capture, add, jot down, or "note for later" a task, idea, feature, or piece of work into the backlog — e.g. "add a task to…", "capture this…", "put this on the backlog", "we should also…", "remember to…", "new task:", or /task-append. Accepts several tasks at once when the input is split by markdown document delimiters (a line containing only `

Refine a draft task into a ready `todo`: assess it for spec completeness, domain-compliance (against its bounded context's ubiquitous language and relationships), and implementation size; interview the human until goal and success criteria are shared; split it if it is too big to land in one go; wire its dependencies; document the interfaces (HTTP/gRPC/protocols/traits/…) it touches and a detailed implementation plan with the files to be touched; and surface decisions, offering ADRs and recording the ones that affect it. Delegates the read-heavy assessment to the task-analyzer subagent. Advances the task(s) draft -> todo (or the original -> split).

Record one or more Architecture Decision Records from the current conversation. Trigger whenever the user wants to capture, record, log, or write down a decision, an architectural choice, or "the call we just made" — e.g. "record this decision", "let's ADR this", "capture this as an ADR", "write an ADR for…", "log this architectural decision", or /adr. Also the human override for when a decision worth preserving was settled in-session but no build skill recorded it on its own. Writes each as a full ADR under the architecture home (./architecture/decisions/ by default, overridable via an architecture-path: line in CLAUDE.md) using the shared NNNN-title.md + decisions.md convention, then refreshes the derived per-topic summaries. Grounds every section in what was actually discussed and confirms the list before writing; treats the invocation itself as the worth-recording call, so do NOT trigger for read-only questions about existing decisions ("what did we decide about…", "show me the ADRs") — those are lookups,

Assess and harden a greenfield project's documentation/specification so it is unambiguous enough to implement from. Hunts for ambiguities, contradictions, gaps, undefined terms, and unstated assumptions, then interviews the user one issue at a time (proposing concrete options), and applies each agreed fix directly to the docs — the sharpened spec itself is the record; no ADRs are written. Built to be run repeatedly until the spec is crystal clear.

Break down the next open milestone from ROADMAP.md into small, actionable, independently testable tasks in PLAN.md. Trigger whenever the user says "break down", "plan tasks", "create tasks", "task breakdown", "decompose milestone", "phase 2", "let's break this down", references PLAN.md in a planning context, or asks to prepare for implementation. Also trigger when the user has just finished strategic planning and wants to move to the next phase. This skill reads the codebase and docs to produce implementation-aware tasks with architectural hints, test cases, and file associations.

Close out a completed milestone by documenting results, noting discrepancies, adding manual testing/demo steps, and preparing PLAN.md for the next cycle. Trigger whenever the user says "close milestone", "milestone done", "wrap up", "close it out", "phase 4", "finish the milestone", "we're done", or when all tasks in PLAN.md are marked complete and the user wants to finalize. Also trigger when the user asks to document what was built, write demo steps, or prepare for the next planning cycle.

Facilitate project inception for new software projects by discovering the project's vision, goals, and planned feature set through Socratic dialogue, then producing a concise README.md and a CLAUDE.md with project-specific instructions for AI-assisted development. This skill precedes the four-phase milestone-driven workflow — use it once at the very beginning to establish the project's identity before strategic planning begins.

Facilitate strategic planning for AI-native software projects by adding new milestones to ROADMAP.md through Socratic dialogue. The strategic/planning entry point of the four-phase milestone-driven workflow — not for breaking down tasks or implementing code.

Implement the next unfinished task from PLAN.md using strict test-driven development. Writes tests first, then writes just enough code to make them pass, and prepares the result for human review and commit. Operates at the individual task level — one task per invocation. Trigger whenever the user says "implement the next task", "next task", "do the next task", "work on the next task", "implement task N", "let's implement", "start implementing", "TDD this task", "/task-implementation", "phase 3", or asks to begin coding the current PLAN.md task. Also trigger when the user has just finished milestone-breakdown and signals readiness to start building (e.g. "let's start coding", "build the first task", "go ahead and implement"). Do NOT trigger for ad-hoc code changes unrelated to PLAN.md, for planning/breakdown work, or when PLAN.md does not exist — those belong to other skills.

Ingest repo-local source material into un-id'd reference/ files plus grounding metadata, without touching the web. Handles both the `research` kind (a citable KB shaped as markdown + references.yaml + CONFIDENCE markers, e.g. from the deep-research workflow) and the `document` kind (any plain repo file — md/html/txt/yaml/csv/json). Distils the material's *facts and insights* (never its structure or verbatim prose) into reference/, tagging each with a resolvable grounding ref. Trigger when the user says "ingest", "bring in this source/material/corpus", "turn these docs into reference material", or "/author-ingest". Spawns material-extractor.

Delta-aware re-ingest of repo-local source material into the reference/ layer, driven by a git commit range so it knows exactly what changed. The update counterpart to author-ingest — instead of re-distilling from scratch, it diffs the ingested source over a commit range (or since the last recorded watermark), reconciles only the changed units against the existing reference/ files by grounding ref, and reports which downstream track nodes are grounded on changed/broken refs and therefore need re-drafting. Trigger when the user says "update the ingest", "re-ingest", "the KB changed", "refresh reference material", "the source moved on", or "/author-ingest-update". Reads the repo only, never the web. Delegates the read-heavy work to subagents: material-extractor (re-extract changed source) and grounding-tracer (scan the track for affected nodes).

Draft questions for every drafted-but-unquestioned node in a track by fanning question-smith subagents across nodes in parallel batches, then centrally minting question ids and writing the files. The batch counterpart to author-questions — the same drafter contract, run many-at-once, honoring "assessment is feedback, never a gate". Trigger after a batch of nodes is drafted, or when the user says "write questions for the whole track", "quiz everything", "add assessment to all nodes", "question the remaining nodes", or "/author-questions-cycle". Resumable and idempotent — each pass only picks up nodes that have no questions yet.

Draft the bodies of every un-drafted scaffolded node in a track by fanning snippet-drafter subagents across nodes in parallel batches, then centrally scaffolding the slugs they need and writing each node. The batch counterpart to author-snippet — the same drafter contract, run many-at-once. Trigger after author-structure has scaffolded a batch of nodes, or when the user says "draft all the nodes", "flesh out the track", "snippet everything", "draft the remaining nodes", or "/author-snippet-cycle". Resumable and idempotent — each pass only picks up nodes still carrying scaffold TODO bodies.

Draft the learner-facing body of a scaffolded knowledge node (or exercise) from reference/ material — playful low-stakes voice, always stating *why it matters* and *what it unlocks*, with each claim grounded in a resolvable grounding ref. Fills the scaffold's TODO title/grounding/body, and proposes the glossary/cheatsheet slug links the prose needs. Trigger after author-structure has scaffolded nodes, or when the user says "draft this node/snippet", "write the body", "flesh out <node>", or "/author-snippet". Spawns snippet-drafter. Scaffolds glossary/cheatsheet slugs as needed; never mints node ids or edits the changelog rules.

Audit research topics for narrative flow and coherence. Produces AUDIT directive comments for the refine phase. Arguments: optional topic path.

Audit research topics for cross-topic contradictions and inconsistent terminology. Produces AUDIT directive comments for the refine phase. Arguments: optional topic path.

Audit research topics for gaps relative to the research plan. Produces AUDIT directive comments for the refine phase. Arguments: optional topic path.

Audit research topics for depth and sourcing adequacy. Produces AUDIT directive comments for the refine phase. Arguments: optional topic path.

Audit a single research topic across every lens — consistency, coverage, quality, coherence, and graphics — in one pass, inserting AUDIT directives and advancing the topic to `audited`. Runs as a forked subagent that inlines all lens analysis and CONFIDENCE verification (no nested subagents). Arguments: one topic path relative to research/content/.

Research and write content for a single section of a topic file based on its RESEARCH directive. Runs as a forked subagent: drives the web search-fetch-verify loop inline, then synthesizes the section. Arguments: topic file path, optional section heading (defaults to the first section still carrying a RESEARCH directive).

Refine a topic file by resolving AUDIT comments or applying content-level corrections. Arguments: topic file path, operation (correct|expand|condense|restructure|cross-reference|update|free-text), optional details.

Report the derived status of every chapter in a research project — computed live from frontmatter and the RESEARCH/CONFIDENCE/AUDIT directives on disk, not from a stored enum. Use when the user asks for research status/progress, what's left, or which chapters are stub/inquiry/draft/audited/done. Arguments: optional path or status filter.

Audit an existing or proposed track DAG for foundational gaps — concepts referenced but never taught, orphan roots that assume prior knowledge, prerequisite leaps, redundant nodes, and dangling supplementary references. Produces a prioritized gap report and an authoring plan to close them. Trigger after author-structure, before a milestone hand-off, or when the user says "gap scan", "coverage check", "what's missing", "any foundational gaps", or "/author-gap-scan". Spawns coverage-auditor. Read-only analysis — proposes fixes, edits nothing.

Draft multiple-choice questions for a node with tight reference lists, honoring "assessment is feedback, never a gate", then mint ids via `synaptic scaffold question` and write the option/frontmatter. Trigger after a node is drafted, or when the user says "write questions for <node>", "quiz this", "add assessment", "challenge questions", or "/author-questions". Spawns question-smith. Prefers many narrow questions over few sprawling ones; never writes a gating or ranking question.

The mandatory hand-off gate for Synaptic content. Runs `synaptic validate --json` over the track directory, summarizes the findings, and blocks hand-off on any integrity violation. Trigger before proposing any content diff to a human, after any author-* drafting/structuring/changelog skill lands files, or when the user says "check", "validate", "self-check", "is this valid", "ready to push", or "/author-selfcheck". Reports which pieces fail and why, in the CLI's own terms, and refuses to present an integrity-breaking snapshot.

Propose the track DAG — a node list, prerequisite edges, and priority ordering — from a corpus of reference/ material plus a track goal, then mint ids for the accepted nodes via `synaptic scaffold node`. Enforces acyclic, AND-semantics, single-track structure and explains each edge's rationale. Trigger after author-ingest, or when the user says "structure the track", "build the DAG", "propose nodes/prerequisites", "outline the track", or "/author-structure". Spawns concept-mapper. Proposes only until the human approves; then scaffolds.

Add new chapter stubs to an existing directory in the topic tree. Works at any depth — a top-level topic directory or a nested sub-directory. Argument: parent directory path (relative to research/content/).

Add a new topic (directory + chapter stubs) to an existing research project. Use when the project already exists and you want to introduce a new top-level topic area. Arguments: topic name (required), optional summary to seed scoping.

Drive `draft` topics through every audit lens to `audited` status by invoking research-audit-topic — a context:fork skill that audits one topic across all lenses — in parallel batches. One fork per topic; forks run concurrently across distinct topics, and each topic's lenses run serially inside its fork.

Audit research topics for opportunities to add graphical representations (diagrams, graphs, schematics, tables, screenshots). Produces AUDIT directive comments for the refine phase. Arguments: optional topic path.

Generate graphics (SVG diagrams, charts, tables, schematics) from AUDIT comments with type: graphics. Creates assets in the topic's _assets folder. Arguments: optional topic path or specific file:line.

Initialize a research project structure with CLAUDE.md, INDEX.md, DECISIONS.md, glossary.md, and topic stubs. Use when starting a new research effort from scratch.

Ingest a specific external source (URL or local file) an author already has — vet it for legitimacy the same way investigation does, then weave it into every existing section it substantiates or contradicts across the topic tree. Arguments: source URL or path, optional topic hint.