The plugin for coding agents: Claude Code, Codex, GitHub Copilot
The ddd-ts-kit repository is the marketplace of the plugin for three coding agents:
| Agent | Install | A skill is called |
|---|---|---|
| Claude Code | /plugin marketplace add ddd-ts-kit/ddd-ts-kit, then /plugin install ddd-ts-kit@ddd-ts-kit |
/ddd-ts-kit:start |
| Codex | codex plugin marketplace add ddd-ts-kit/ddd-ts-kit, then install ddd-ts-kit from /plugins and trust its hooks in /hooks |
$start |
| Copilot CLI | copilot plugin marketplace add ddd-ts-kit/ddd-ts-kit, then copilot plugin install ddd-ts-kit@ddd-ts-kit |
by its name, start |
| Copilot cloud agent, VS Code | declared by the .github/copilot/settings.json that init writes: the cloud agent installs it, VS Code recommends it |
by its name, start |
Twenty-six skills, in the order a project meets them:
| Skill | Use |
|---|---|
start |
conduct a project from a statement of needs to working contexts (run by the user) |
discover-domain |
a light event storming in writing |
bounded-contexts |
find the contexts and classify them core, supporting or generic |
glossary |
the ubiquitous language of a context and its CONTEXT.md, before any code |
context-map |
upstream, downstream and relationship pattern for each pair of contexts |
bootstrap |
choose the stack and create the project (run by the user) |
plan-slices |
the work as vertical slices per context, ordered, with their generator commands |
parallel-work |
split the slices between several agents or people without collision |
intent |
capture an idea as an intent before any story, in the words of whoever has it, for the product owner to accept in a pull request (run by the user; story workflow) |
story |
take one user story from its questions to a green pull request in one session, one story per terminal (run by the user; story workflow) |
fix |
repair one defect in its own worktree, its regression spec written and locked before any code (run by the user; a fix) |
pull-request |
take the pull request of a story to green: sweep its review comments and failing checks under the rules of the story, push, wait, repeat; then report what changed and what was declined (run by the user) |
scaffold |
one file of any role, from a template |
use-case |
one feature end to end, test first |
integration-event |
make two contexts collaborate through a versioned event |
wiring |
ports as abstract classes, declarations, the composition root, fakes in tests |
persistence |
repositories, unit of work, outbox, read models, migrations, whatever the ORM |
access-control |
authentication, permissions per use case, the explicit actor, policies |
cross-cutting |
logging, metrics, tracing, error reporting, audit trail, resilience and caching from outside |
testing |
fakes instead of mocks, builders, given / when / then, end to end |
clean-code |
naming, function order, comments, testability |
document |
OpenAPI contract and its typed clients, event catalog, AsyncAPI, generated lists, decision records |
extract-service |
keep each context ready to run as its own service, and extract it |
deviation |
what to do when asked to go around a rule |
quality-gate |
run the checks at the right scope and fix at the root cause |
commit-discipline |
one slice per commit, generated files with what generated them |
Six agents: domain-explorer (read-only answers about what exists and where),
context-builder (builds the slices of one context in its own worktree),
domain-test-writer (turns it.todo entries into specs) and architecture-reviewer
(read-only review of a diff, a branch or a context, under the REVIEW.md of the project when it
has one: the passes of the team on top of the agent's method, each finding tagged with its pass),
acceptance-judge (judges a change to a
locked acceptance test, independently of the session that made it, and writes its verdict), and
story-verifier (read-only verification of a story at its close, in a fresh context: it starts
the application as the end-to-end tests do, exercises the routes of the story and the two nearest
flows, and reports what does not match the design or a decision).
The description of each skill says when to use it in at most 320 characters, and the 26 take
at most 6,500 together; an agent's, at most 400. Claude Code loads the listing of the skills into
every session within 1% of the context window, counted in characters, not tokens: 8,000
characters on a 200k window, shared with every other skill of the session, those of Claude Code
and of other plugins included. Past it, the listing shortens the descriptions of the skills invoked
least, which then stop triggering on their keywords. bootstrap, fix, intent, pull-request,
start and story, run by the user only (disable-model-invocation), are not listed; the 20
others take about 5,600 characters with the ddd-ts-kit:<name> each entry carries, about 70
percent of the 8,000 for the kit alone. They fit on their own; next to many other skills, the
least invoked of the kit lose their description, and are still run by name. A share of 2,400
characters, which would let them all survive in a crowded session, would cut every description to
a third of what it needs to trigger, so the kit accepts the loss. A test of the plugin
(node --test plugin/skills/descriptions.test.mjs) holds the limits.
The body of a skill is read whole once the skill loads, so what one option of stack needs is
kept beside it: the body keeps every rule and one line, "under stack.<key>: <value>, read
<file>.md first", and the file, read on that stack only, opens with when it is read and points
to the page of docs/ it paraphrases (under concepts/, tools/ or guides/). wiring keeps
the declared style and reads explicit.md, nest.md and earlier-layouts.md;
access-control reads relationships.md under rebac; persistence reads tenancy.md,
event-sourcing.md, personal-data.md and migrations.md; use-case reads factories.md,
function-routes.md and file-upload.md. A test of the plugin
(node --test plugin/skills/bodies.test.mjs) holds these four bodies under a ceiling of words,
as wc -w counts them: wiring 1,200, access-control 1,900, persistence 1,200, use-case
2,200.
The hook is the part that makes the rest binding. In a project that has a
ddd-ts-kit.config.json it reminds the workflow and the context map at session start, says
when the installed packages are not the version the skills describe, refuses
a hand-written file where a generator exists, any edit of a generated contract and the writing
of the baseline of the errors (check --baseline write however the kit is launched, a package
script included, or an edit of ddd-ts-kit-baseline.json:
the project owner writes it, in a terminal), refuses a git command that skips the hooks of the
project (--no-verify, -n on a commit, -c or --config-env of core.hooksPath or its setting
in the environment, LEFTHOOK=0, HUSKY=0, LEFTHOOK_EXCLUDE, git commit-tree: the hooks are the local gate
of the pipeline; the words of a command are read as the shell gives them, quotes removed) and, to a sub-agent, a git config that sets a value or a git -c of a key that
runs a command in every checkout (core.fsmonitor, core.pager, core.editor, core.sshCommand,
an alias.*, a diff, merge or filter driver, diff.external, an include.path, a credential
helper, a pager, a tool of mergetool or difftool, a gpg program, a protocol.*), given by
-c or --config-env, or a variable of the environment that hands git a program or settings
(GIT_EXTERNAL_DIFF, GIT_PAGER, GIT_EDITOR, GIT_SSH_COMMAND, GIT_CONFIG_*...), asks the
project owner before a suppression or a skipped test is written in a source, a test or a script
(a document that only names one is prose), or a change of the rules is written by the editor
tools, checks
every written file and returns the violations with their fix (the first five of a Codex patch, the
others named as not checked; with "dependenciesBeforeWrite": true, on trial,
it refuses before the write a new import that breaks a dependency rule), and refuses to finish while
architecture errors remain in a tree with uncommitted changes (a clean tree is left to the
pre-commit hook and the pipeline; a check that does not end in time, or that answers more than the
64 MiB the guard reads, lets the session finish and says so;
a session start past ten seconds of CLI calls skips the ones left and says it was cut short). With "formatOnWrite": true in the config (written by init for a new project), and outside the regulated profile, it first runs the Biome
the project installed on the written file (the bin of its @biomejs/biome package, format --write, one file,
never another formatter), so that the layout is settled at the write and the lint findings
that follow a wrapped line come back in the same output; a run that fails changes nothing. It reminds, without blocking, when the uncommitted changes exceed
the advised size of a commit, and in a worker's worktree (.ddd-ts-kit/worker.json) it
refuses a write outside the worker's context, by the editor tools or by the shell. The editor
tools of a builder are held wherever the file stands, from its first call: a path that forgot its
worktree is refused in the checkout of the conductor, in another worktree and outside every project
but the temporary directory, and told to name the file under its worktree. It reads the
whole command line, every command of it, not only one that starts with cd <worktree> &&: a worker
runs every command that way, and one that writes without moving into its worktree is refused with
that instruction: from another checkout a worker only reads (cat, ls, grep, git that reads,
git add and git commit in its own worktree, the kit asked to list, describe, report or read a
briefing, and its checks that write nothing: check without --baseline, lint without --fix,
rules, docs --check without --stored-events, verify-merge, cited, affected without
--run), whatever the program. A session opened above the project holds its worker to the project
its command names, and a worker standing in its worktree stays pinned to it when a command starts in
another project. It follows a cd only when it is certain (after &&, into a directory that
exists, and that no folder of CDPATH sends elsewhere), refuses a worker the variables that move
where the shell or git find their places (TMPDIR, CDPATH, HOME, GIT_DIR, GIT_WORK_TREE,
PATH, set for a command or exported), so a write after cd dir; or a failed cd is refused rather than placed wrong; it reads a
name the shell computes (a variable, a substitution, a brace list), a wrapper (nice, ionice,
setsid, flock, busybox, su -c, env -S), a package runner (npx, npm exec) and the
command it runs; and it knows the writers the file tables miss (>&, a sed or awk script that
writes, vim/ed, rsync, curl -o, wget -O, tar -x, git stash/reset --hard/worktree add/checkout -f, eslint --fix, biome --write). A worker's only free places outside its scope
are /dev/null, the standard devices and the temporary directory ($TMPDIR) outside every project (a project cloned there keeps its rules); any other absolute
place is refused. A file is judged where it lands: a link of the scope, or a folder of its path that
is one, is the place it reaches, a link of the temporary directory into a project is that place, and
a file of the scope that has another name elsewhere (a hard link) is refused. A command nested deeper than the reader follows (more than five shells or evals, or more than 32
wrappers and assignments before its program, which then names no program it knows)
is refused rather than let through unread; so is, to a worker, a line that ends inside a quote or
with a here-document that never closes, and a command the reader breaks on. Code it cannot read (inline code such as node -e, a
script, a shell fed on its input, make, a package script or runner such as npm test or npx)
runs, but before each command of a worker that runs some (every command but the pure readers:
cat, ls, grep, git log, git status... named by their name, git without a setting given to
the command nor an option that hands the files to a program such as grep -O or --ext-diff; the
kit counts as the program, or as the first operand of node or of a package runner), the guard notes the state outside the scope (the
git status and HEAD of the worktree, of the session's checkout when it is another, and the
manifest and bin of the kit's CLI and of Biome in node_modules), and compares it at the worker's
next call. A read leaves the note of the worktree standing, for what the command left running in the
background, until a change or a new note. The worker's stop compares it one last time, with what its branch holds outside the scope since the
base its scope file records (baseCommit: the commits since then, what the trunk brought in left
out, and the uncommitted files; a scope file without a base leaves the commits uncompared, as the
guard fails open): the worker
goes on once to put a file back, and what stays is said to the conductor in lastStop.outside of
agent.json, in its report, in status --workers and in worker-scope --resume. A git status
that does not answer in full compares nothing, and the guard says so. A file of the worktree changed outside the scope, deleted or committed included, stops the
worker until it is put back with the command the guard names: its committed content (git checkout <commit> -- <path>, then git commit when a commit changed it), the content it had before the
command when it was already changed (kept under .ddd-ts-kit/guard/held/), git mv back for a
rename, rm for a new file. A file past 16 MiB is compared by its size and time, unread, and no copy
of it is kept: already changed before the command, it is said, not held, and the worker names it in
its report. A file left changed in the working tree of the session's checkout (not
one the conductor commits or merges meanwhile) is said to the worker once and refuses nothing: the
worker puts nothing back there and names it in its report, for the conductor, who alone knows
whether it made the change. A change of those packages refuses the next call once, for the conductor too,
and so does a change of what the guard stands on there: the config of the kit, the settings, hooks
and plugins of a coding agent, a scope file. What the project's own scripts (npm run format,
lint:fix, regenerate, docs:generate, openapi:generate, events:generate, not run in another
folder by --prefix, -C, --dir or --filter), alone on the line, rewrite outside the scope among the files their tools rewrite (code, JSON, docs/) is said
with the script that rewrote it, not held: the worker leaves it out of its commits. The scope is pinned at the worker's first
call, and the pin follows the worker: it is kept under the git directory the worktrees of the
repository share (ddd-ts-kit/guard/ there), so a call that starts in another checkout is judged
against the worktree pinned, and told to run as cd <worktree> && .... Where several workers have
a worktree, a first command that names none pins nothing: it reads, and what it writes is refused
until a command names its worktree, or an editor tool a file under it. A pin that cannot be read
holds every call until the conductor launches the worker again. A scope file removed or changed (its context, its base, its base commit or its branch) stops the worker until the conductor restores it, and the mode of the
guard is pinned with it, so a config that turns the guard off, in the worktree or in another checkout
of the repository, or grows past what
the guard reads, does not lift a worker, its change being compared as any other. A branch the worker
merges into its own is its work: only what the trunk holds is the trunk's. The trunk is the base
its scope file recorded when the worker was pinned (a branch of the repository, an integration
branch as well as the main one), the branch origin/HEAD names, main or master, each as it
stood before the command that merged: a trunk fetched and merged by one command is not known yet,
so the fetch goes in a command of its own, or merge-trunk does both. A merge of any other branch
is held without a command to undo it, and the worker reports it to the conductor. The kit's own
merge-trunk is not noted, unless --trunk names another ref than that base, and an install of the lockfile leaves the packages out of the note. It
refuses a dependency change and another formatter than npm run format. The architecture-reviewer, the
domain-explorer and the story-verifier change no file of a project by the shell, nor its work
tree by git (they read with git show and git diff). A sub-agent is refused
deleting, moving or resetting a branch checked out in another worktree (another worker's, or the
trunk), short options bundled or long ones cut included. A worker's git changes its own worktree
only: from any other checkout it reads (status, log, diff, worktree list, fetch into no
ref...), so only the conductor lands a branch or moves its checkout, and no worker removes a
worktree or writes a ref by update-ref or symbolic-ref. In its worktree, its git keeps to its
own branch, the one its scope file records (else the one checked out there): it pushes that branch
alone (git push, git push -u origin <branch>, HEAD:<branch>), without --force, -f,
--force-with-lease, a + refspec, a deletion (:<ref>, --delete, -d) nor --all,
--tags or --mirror; it fetches into no ref (git fetch origin main:main), makes no tag, and
checks out or switches to no other branch nor creates one (-b, -c, --orphan, --detach). The same shell reading holds the domain-test-writer to
the paths of a test (a spec, the root test/ or the test folders of a context, and a file it names:
a place only the shell knows is refused to it), the code of a story to its build gate, and every
session's hand-writing of a generated file or the baseline, each by the places a command writes
rather than its text, in the project that owns the place, whatever the checkout the session stands
in. What a redirection, sed -i or tee types in a file is held as the editor tools are: the code
of a context in the main checkout of the trunk, a new file of a generated role. A generated file
put back or deleted (git checkout, git restore, git rm, rm) stays free, since it is rebuilt
after; so does what a session other than a worker or the test writer writes where only the shell
knows. A Codex apply_patch sent through the shell is read as a patch, each patch of the line,
in a here-document or an argument; one the command does not hold (a file, a pipe) is refused. A
file a patch deletes, or leaves by a move, is held as rm holds it (the baseline, the scope of a
worker).
For a context-builder (the agent of the plugin, ddd-ts-kit:context-builder: an agent of the project
named context-builder without that prefix is held to the scope of its worktree, but neither counted nor
recorded), it counts the tool calls inside those same hooks and warns the agent
twice before its turn limit, records its runs in its worktree (.ddd-ts-kit/agent.json), and
listens to two rare events of Claude Code, filtered by that agent: SubagentStart (a launch or a
resume starts a new count) and SubagentStop (when it ends on its own, it is kept going once to
commit a slice that passed verify-slice, to rewrite a stale report or to put back what its last
command changed outside its scope). At session start, it
names the workers to resume (parallel work). In a project
init created ("worktrees": "required"), it refuses the code of a context and the generators
that write it in the main checkout of the trunk, and in a worktree of .worktrees/ without its
own node_modules: npx ddd-ts-kit worktree <name> opens the place to write it; a project
started before is only told at session start. In the
worktree of a story (.ddd-ts-kit/story.json, which the session there and every sub-agent change in
no way, nor .ddd-ts-kit/worker.json in the worktree of a worker, a removal of a folder above it
included: rm -r, a find -delete or -exec rm whose -name tests can find it, git clean -x
or -X, git stash --all, and git clean -d or git stash --include-untracked when git does not
ignore it), it refuses any code of a context until each row
has its design review and the acceptance is written and locked, says the phase of the story at
session start with where it meets the other open stories, says once per file when the session
writes a file another open story changes, and refuses once to end the session before its report
(story workflow). In the worktree of a fix ("kind": "fix" in that file),
it opens the code once the regression spec is locked, and refuses every edit of a locked spec,
by the editor tools and by the shell, to its sub-agents: a folder that holds the spec counts as the
spec, and so does a write whose place only the shell knows (xargs sed -i, cd dir; sed -i), while
a find -exec is judged by the folders it starts from, and reads through either stay free. The
session itself may write a new version,
which acceptance reports and the acceptance-judge agent rules on. A command that writes the lock
of an acceptance or a verdict (judged by the places it writes, a glob expanded, not by its text; a
folder that holds them, test/acceptance or test, counts as them, and so does a place only the
shell knows on a line that names the acceptance) is refused: a command may move or check a path
(cd, pushd, popd, pwd, test), read the file (cat, grep, rg without --pre, sed
without -i, awk, less, jq), version it (git add, commit without -a, log, show,
status, none of them with --output) or run the kit (ddd-ts-kit, npx ddd-ts-kit); any other
program (a bare npx or pnpm, git checkout/stash), or a redirection to a file, is a write,
which only the CLI and that agent make. The judge itself reads git without adding or committing,
and runs the kit only to read (acceptance without --lock, list, describe, explain,
status, story, stories, story-check). No hook
runs on every tool call: an ordinary session starts no more processes than before. It fails open: a broken guard never blocks work, which makes it a guide, not a security boundary: it runs the project's own ddd-ts-kit CLI and Biome from node_modules (the bin each package names, with Node, never one installed above the top of the repository, and no config nor CLI in a folder another user may write, the shared temp directory above all; under the regulated profile it runs neither, so no check at the write nor at the stop), and of what code it cannot read writes, it compares only what is noted above: other git-ignored files and the places outside those checkouts are not enumerated, and the state it keeps between two calls lies in the project, within reach of code that aims at the guard; to isolate an agent, see Sandboxing coding agents. Set
"guard": "advise" in the config to be asked instead of refused, "off" to silence it.
Each agent gets what its host runs. The skills work in all three. The six agents are sub-agents
of Claude Code; Codex loads no agent from a plugin, and one session per worktree takes the place
of context-builder. The hook runs wherever the host runs the hooks of a plugin: it reads the
patches of Codex, the tool calls of Copilot and the editor tools of VS Code as well as those of
Claude Code. VS Code keeps no matcher, so there each hook of an event runs on every tool: a tool
the guard names a reader (read_file, list_dir, the searches, memory when it views) writes
nothing, and a tool it does not name that gives a path is judged as a write
(ADR-0007). Codex cannot put
a question to the user, so what Claude Code asks the project owner is said to the user there,
and left to the checks of the pipeline.
Without any plugin, a project still guides every agent: init writes AGENTS.md, the guide
Codex, Copilot and most agents read (CLAUDE.md imports it; its ## Verifying your work
section gives each verification command with the lines it prints when it passes, to run before
reporting done and to paste, a failing check fixed in the code and never in the check, and its
## Mistakes seen here section is the team's: a review finding or a TODO(review) made twice
becomes a line there, or a rule of the config, the rule of two the architecture-reviewer
agent and the quality-gate skill apply, after the AI-native SDLC playbook of Anthropic,
PDF),
the rules by layer for Claude Code
in .claude/rules/ and the same rules for Copilot in .github/instructions/, scoped by
applyTo, REVIEW.md, the review policy every reviewer reads, written once and owned by the
team (Working as a team), .claude/settings.json,
the permissions of Claude Code (the checks and generators run without asking; .env and the
generated contracts are never read or edited; generate and init with --force, git push, npm publish, the files that hold
the rules and the pipeline, the migrations of the ORM, Dockerfile, docker-compose.yml and
docker/ ask first: the list is in the
README of the CLI, and ddd-ts-kit doctor says what a
project lacks of it; init --agent-profile regulated adds the sandbox block and the two hooks of
a regulated organisation, Sandboxing coding agents), and, with the GitHub
pipeline, copilot-setup-steps.yml, which installs the project
before the Copilot cloud agent starts. npm run verify and the pipeline hold every agent to
the same rules.
What holds each skill
Section titled “What holds each skill”A skill is advice: it tells an agent what to run and what to decide, and an agent can ignore it.
The AI-native SDLC playbook of Anthropic
says what a regulated team asks before it accepts a skill at all: a policy that must always hold
needs something deterministic behind it, a hook that blocks the action or a check that catches it
later. This table names that control for each skill of the plugin: the rule ids of ddd-ts-kit rules (held by the checker, the ESLint plugin or dependency-cruiser, see
who checks what), the gates of the guard, and the checks of
the pipeline. A test of the plugin (node --test plugin/skills/controls.test.mjs) fails when a
rule id named here is unknown to the CLI, or when a skill has no row.
| Skill | Deterministic control behind it | Gap |
|---|---|---|
start |
ddd-ts-kit status reads docs/architecture/plan.md and slices.md and names the next step; the guard reminds the workflow at session start |
the shape of plan.md is read, not checked |
discover-domain |
none of its own: docs/architecture/discovery.md is read by the next steps, not checked |
strategic truth is not checkable, as the methodology says |
bounded-contexts |
context/no-cycle, context/extractable, tree/context-doc (every context has its CONTEXT.md), docs --check |
the classification of a context is read, not judged |
glossary |
the generator refuses a name the glossary does not hold; language/glossary-term, language/declared-vocabulary, language/no-technical-name |
|
context-map |
context/no-cycle, context/declared-relationship, context/published-language-only, context/published-language-is-a-contract, the context map regenerated and compared by docs --check |
|
bootstrap |
init writes a project green under npm run verify; config/valid; doctor --strict |
|
plan-slices |
status, story-check and worker-scope --rows read the rows of slices.md and refuse an unknown one; plan-waves replays the generator commands of the rows and refuses a name whose words the glossary does not define, any command the generator refuses, with its refusal under the row, and a row that builds on what a row it does not wait for generates; verify-slice |
the order of the rows is advised (plan-waves), never refused |
parallel-work |
the worker guard (.ddd-ts-kit/worker.json: a write outside the context is refused, by the editor tools and by the shell), verify-merge, merge-trunk, status --workers |
|
intent |
story-scope --from refuses an intent whose status is not accepted; the ## Origin block of the story, which story --gate close requires |
the content of an intent is read by people, not checked |
story |
story --gate build and --gate close, the guard in the worktree of a story (no code before the design review and the lock), acceptance --lock, test/acceptance-black-box, the acceptance-judge agent |
the design pass of story-check holds names, not behaviour |
fix |
story-scope --kind fix, acceptance <code> --gate written and --lock on the regression specs of ## Regression, the guard in the worktree of a fix (no code before the lock, no edit of a locked spec by a sub-agent), the acceptance-judge agent |
the locked spec is held unchanged; that it passes is proven by the test runner, not by acceptance |
pull-request |
the checks of the pull request and the branch protection (a code owner approves); the guard of the worktree of the story while it works | nothing of the kit reads the review threads: the skill does |
scaffold |
the guard refuses a hand-written file of a role; tree/closed, tree/documented-paths, naming/suffix, naming/one-concept-per-file, naming/business-name, naming/search-not-list, test/spec-required, test/builder-required, lifecycle/status-through-machine, process/sends-commands-only, scheduling/job-name, scheduling/job-registered, scheduling/job-triggers-use-case |
|
use-case |
the controls of scaffold, then application/handler-shape, application/command-query-separation, domain/aggregate-encapsulation, domain/value-object-class, domain/value-object-immutability, domain/no-generic-error, domain-events/dispatched-on-save, domain-events/transactional-before-commit, errors/code-listed, errors/code-unique, errors/through-factory, files/upload-content-rule, presentation/controller-shape, presentation/controller-delegates, schema/presentation-only, schema/no-duplicate-shape, the tests of the context run by verify-slice |
|
integration-event |
events/defined-in-published-language, events/name-declared-once, events/name-format, events/outbox-required, events/consumer-idempotent, event-sourcing/upcaster-required (the stored-events lock), the event catalog and the AsyncAPI document compared by docs --check |
|
wiring |
ports/abstract-class, ports/no-token-constant, ports/no-concrete-dependency, ports/implements-never-extends, ports/value-import, declarations/role-declared, declarations/constructor-injection, declarations/barrel-current, declarations/port-adapter-wired, composition/only-in-module, the barrel regenerated by docs |
|
persistence |
layer/domain-purity, layer/application-inward, files/port-not-connector, search/store-from-platform, persistence/migration-history, persistence/primary-key-order, persistence/no-file-content, persistence/read-model-listed, tenancy/scoped-statement, the contract suites, the coverage floor of infrastructure/ (test/coverage-governed) |
an adapter without its contract suite is reported by test/spec-required only when its spec file is missing |
access-control |
authz/declared, authz/granted, authz/in-application, authz/actor-explicit, authz/policy-asked, authz/scope-narrows, authz/resource-modelled, authz/system-actor-granted, authz/fields-by-schema, presentation/guard-at-the-edge |
|
cross-cutting |
aspects/outside-in, aspects/timeout-covers-delegate, tracing/platform-only, standard/no-parallel-interface, purity/no-system-clock, purity/no-ambient-randomness, purity/no-environment, presentation/shared-cache-varies |
|
testing |
test/no-mocks, test/spec-required, test/builder-required, test/helper-placed, test/coverage-governed, test/acceptance-black-box, the shape of a test (test/no-only-no-skip, test/title-states-a-rule, test/no-logic, test/assertion-present, test/refusal-by-code, test/no-snapshot), the acceptance lock |
a regression spec is locked only inside a fix story |
clean-code |
clean/stepdown, clean/function-size, clean/file-size, clean/blank-lines, clean/braces, clean/one-export-per-file, clean/no-escape-hatch, clean/no-commented-out-code, clean/no-noise-comment, clean/no-flag-argument, clean/no-hash-private, clean/no-magic-number, clean/formatted (Biome in the commit hook and in the pipeline), language/no-technical-name |
the formatter runs at the commit and in CI, not at the write |
document |
docs --check (npm run docs:check, the docs gate of the pipeline), declarations/barrel-current, tree/context-doc, sdk --check |
|
extract-service |
context/extractable, context/published-language-only, imports/alias-only, the per-context entry point generate service writes and its boot test |
|
deviation |
governance/recorded-deviation, config/suppression-needs-reason, config/rule-off-everywhere, the guard asks the owner before a suppression, a skipped test or a change of the rules |
|
quality-gate |
npm run verify, the Stop hook of the guard (it refuses to finish while architecture errors remain in uncommitted changes), the gate job of the pipeline |
|
commit-discipline |
check --commit-size (advice), commitlint in the commit-msg hook and the title check of the pipeline |
the size is advised, never refused: a choice of the kit, kept |
Two gaps belong to no skill: a secret in a diff is caught by gitleaks in the pipeline only, and the layout of a file is settled at the commit, not at the write.
Evals of your own skills
Section titled “Evals of your own skills”A project that writes skills of its own (a policy of the organisation, a convention of a team)
can hold them to the same test: an evals/ directory next to them, run by claude plugin eval,
one case per promise, with the project's real tasks as prompts and graders that read the result.
The kit generates nothing for it: the playbook's suite is built from the tasks of the project,
which no template knows. The suite of the plugin itself, under plugin/evals/ of the
repository, is a worked example, and CONTRIBUTING.md
says how a case is written, when one is added and what it costs.