> multi-agent supervisor framework

Easy Kit

A multi-agent supervisor framework: one Supervisor session enforces a Stage 0–5 pipeline through deterministic hooks, not just prompted convention. Install it into any git repo with one command.

  • Pipeline — plan → spawn isolated sub-agents → review → integrate → ship.
  • Claude Code — the Supervisor session and its hooks enforce every stage.
  • Other providers (Codex, Cursor) — Codex reads the full doctrine in AGENTS.md. Cursor gets a thin adapter. See Providers below for what carries over and what doesn't.

View the Supervisor GitHub repository for the source and installation reference.

Quick reference

Install
$ curl -fsSL https://raw.githubusercontent.com/thunderkds/easy-kit/main/setup.sh | sh
Update
Run the same command from your repo root and choose 1) Update — see Update flow.
Stages
0 → 1 → 2 → 3 → 4 → 5
Roster

What you get

Four spawnable sub-agent roles, skills for every pipeline stage, and enforcement hooks that gate merges and spawns — so "write a test first" and "update the board" are checked, not just written down.

  1. 00 Stage 0 · Define PRD.md, BRAINSTORMING_LOG.md
  2. 01 Stage 1 · Set up codebase map, CLI table, agent roster
  3. 02 Stage 2 · Plan PROJECT_SPEC + TASK_GUIDEs
  4. 03 Stage 3 · Parallel execution code in isolated worktrees
  5. 04 Stage 4 · Review findings + Evidence
  6. 05 Stage 5 · Integrate verify, merge, release plan
Pipeline as a vertical diagram The Easy Kit pipeline Six steps in order, top to bottom: Stage 0 define (requirements, grilling and direction), Stage 1 set up (environment and agent team), Stage 2 planning, Stage 3 parallel execution, Stage 4 review, Stage 5 integration. These stages are the extended track. Each step hands its output to the next. Stage 0 · Define PRD.md, BRAINSTORMING_LOG.md Stage 1 · Set up codebase map, CLI table, agent roster Stage 2 · Plan PROJECT_SPEC + TASK_GUIDEs Stage 3 · Parallel execution code in isolated worktrees Stage 4 · Review findings + Evidence Stage 5 · Integrate verify, merge, release plan

Minimal and extended tracks

Small work runs on the minimal track. Big or risky work runs the full pipeline above, which is the extended track. The Supervisor picks the track and says it in one line before it starts.

  1. Your request
  2. Is any one of these true?
    • Complexity C2 or above
    • Risk Medium or High
    • A word like refactor or migrate
    • It changes user data
    • More than one session or agent
    • A UI component
    • yes
      Extended trackthe Stage 0–5 pipeline
    • no
      Minimal track7 steps, one Decision record

Auto mode

  1. 01Requesttagged [auto]
  2. 02Track runsno questions asked
  3. 03Stop checkfinal report checked
  4. 04Auto verifyheadless /verify
  5. 05Close-outGates 5 and 6, report complete
  6. 06Donerow moved by the hook
Stays yours with [auto]
  • merge
  • push
  • ship
Details
  • The line is a statement, not a question: Track: minimal — C0, Risk Low, one file or Track: extended — C2, Risk Medium.
  • Extended track if any of these is true: Complexity C2 or above; Risk Medium or High; a word such as refactor or migrate; a change that deletes, moves, renames or converts user data (for example CSV to JSON); more than one session or agent; a UI component.
  • Minimal track otherwise. The Supervisor writes the code itself: test first, change, a /simplify pass, real run. It saves a Decision record in tasks/MINIMAL_LOG.md and adds a board row marked Track: minimal. It commits on a new branch without asking. It writes no task guide. It starts no sub-agent, except the read-only reviewers of /simplify (and of a Debate in auto mode).
  • Your override: reply full or minimal at any time and the Supervisor switches. It may move a task up to extended on its own. It never moves a task down.

Put the exact tag [auto] in your request. The Supervisor runs either track up to the point where it waits for your review and asks you no question. It pauses only for a few stops, such as a safety-hook block. It writes a final report that lists every decision and how it made each one. The task Risk sets how it decides:

  • Low: the Supervisor decides and logs the reason.
  • Medium: a Debate with 2 Advocates.
  • High: a Debate with 3 Advocates, and at least one decision is always debated.

In a Debate, read-only Advocate agents each frame the problem and propose their own option. resolve-question runs it in auto mode only. The Supervisor decides and takes the safer option on a tie. It marks the line ⚠ decided for you — please review. A task has at most 3 Debates. The 4th question goes to you.

A Stop hook checks the final report before the run may end. Safety hooks still block.

Auto verify runs for any task, with or without [auto]. When a task waits for your review, the Supervisor starts a fresh headless /verify run with python3 .claude/hooks/stop_auto_verify.py --start <ID>. A Stop hook starts it as a backstop. That run, not the Supervisor's own session, writes the verify row.

Close-out: after a pass, the hook moves the row to Done only if the run record proves the pass, the tests row and the UI rows hold, and the report is complete. With CLAUDE_AUTO_VERIFY=off, /verify is yours again for every task without [auto]. With [auto], merge, push and ship stay with you. With [admin] instead, the run is the same, and the Supervisor may also merge and push the task's own branch, and then push main, only after its auto verify passed. A task that changes only docs, task files, memory or tests has no runtime surface: when the run answers skip, the hook checks the changed paths in git and records a pass, so you need not type /verify. One path outside that list keeps the result blocked. A force push or a push of any other branch stays blocked. With [admin], ship runs as a plan only, never a deploy. The [admin] merge and push also refuse when the repo config holds a key that can run code or reach another host, such as a merge driver, a filter or core.hooksPath; the refusal names the key.

Install

Claude Code plugin

Run in a terminal:

$ claude plugin marketplace add thunderkds/easy-kit
$ claude plugin install easy-kit@easy-kit

Or, on Claude Code 2.1.292 or later, in one step:

$ claude plugin install easy-kit --marketplace thunderkds/easy-kit

Then, in Claude Code, run /easy-kit:init once in your git repo.

  • Claude Code only. For Codex, use setup.sh.
  • Each teammate installs the plugin. Without it, a teammate has no gates.
  • A plugin cannot set permissions. /easy-kit:init shows the kit's settings rules, and writes them only after you approve.
Plugin details
  • /easy-kit:init adds CLAUDE.md, AGENTS.md, the task board, tasks/ and memory/. It never changes a file that is already there.
  • Skills and agents are named easy-kit:<name>, for example /easy-kit:wake and easy-kit:backend-developer.

setup.sh: copy the kit into your repo

Prerequisites: an existing git repo, and git, curl, and a POSIX sh on your PATH.

$ curl -fsSL https://raw.githubusercontent.com/thunderkds/easy-kit/main/setup.sh | sh
  1. 01Run the commandinside your git repo
  2. 02Pick from numbered menusEnter takes the default
  3. 03Read the planCLIs, project type, backups
  4. 04ConfirmProceed? [Y/n]

Never deletes. A file it replaces is backed up first.

Restart Claude Code after install so it picks up the new .claude/agents/, .claude/skills/, and .claude/settings.json.

Details

Installing into an existing project never deletes what is already there: a file or folder the kit would replace is first moved to a backup, listed in the install output. Identical files are left alone.

How backups are named
  • After the kit version it replaces: CLAUDE.md.bak-<commit>, templates.bak-<commit>/, …
  • Today's date, such as CLAUDE.md.bak-20261008, when no earlier version is recorded, as on a first install.
  • A name already taken gets .1, .2, … so no backup is ever overwritten.

The command takes no options — you choose from numbered menus, and Enter takes the default each time:

  • What to do — 1) Install 2) Cancel (or Update / Reinstall / Cancel where Easy Kit is already installed).
  • Which CLIs — 1) Claude Code 2) Codex. Pick one or both (1 2 or 1,2); the ones found on your PATH are pre-selected, and Claude Code when neither is.
  • New or existing project — 1) New project 2) Existing / legacy project. An existing / legacy project gets CLAUDE_LEGACY.md's rules as its CLAUDE.md.

A plan then lists the CLIs, the project type and anything that will be backed up, and asks Proceed? [Y/n] before a single file changes.

  • No terminal (CI, containers) — no menus: the defaults are printed and taken.
  • Anything on the command line — it stops with nothing written.

To pull in newer Easy Kit changes later, run the same command again from your repo root and choose Update (see below).

Update flow

Run the install command again from your project and choose Update. Update keeps your edits.

Update compares each file with the hash saved at your last install or update.

  • Your copy isUntouched
    Overwrittenwith the latest upstream version
  • Your copy isCustomized
    You are asked, per filediff, overwrite or skip; overwrite backs yours up first
  • Your copy isNo longer shipped
    Removed if untouchedkept and named if you edited it
  • The file is.claude/settings.json
    Mergednot copied, on install and on update
Details

There is one command: run the same install line again inside your installed project (still a git repository). Easy Kit sees it is installed and asks what to do:

Easy Kit is already installed in /path/to/your-project.
  1) Update (keeps your edits)
  2) Reinstall (backs up your edits)
  3) Cancel
Choose [1]:

Before changing anything it shows a plan — files to ask about, files to remove because the kit no longer ships them, anything to back up — and ends with Proceed? [Y/n].

If the plan lists files you edited, one question about all of them replaces Proceed? [Y/n]:

How should Update treat your edited files?
  1) Ask me about each one
  2) Overwrite all of them (each backed up first)
  3) Keep all of them
  4) Cancel
Choice [1]:
  • 1 asks about each file, as in the table below. Enter picks it.
  • 2 moves each file to <file>.bak-<commit>, then overwrites it. A file it cannot back up is kept.
  • 3 keeps every edit. 4 changes nothing.
  • Answer n to go back to the menu. Cancel changes nothing.
  • No terminal (CI, containers, ssh without -t) — no menu: it prints the safe default — Update, keeping every edit — and takes it. Reinstall never runs without a terminal.
  • An existing update.sh in a checkout still works: it runs the same Update action.

Update re-fetches the framework fresh, then compares each MANIFEST file — plus CLAUDE.md — against the content hash recorded at the last install/update:

Your copyWhat Update does
Untouched since installSilently overwritten with the latest upstream version
CustomizedShows a diff and prompts per file: overwrite / skip / view diff again. Overwrite first moves yours to <file>.bak-<commit>; skip keeps it
No longer shippedRemoved if you never edited it; kept (and named) if you did
.claude/settings.jsonNot a MANIFEST file, so it is merged rather than copied — on install and on update
How the merge works
  • The kit's hooks are reconciled into it.
  • The kit's permissions.deny entries are appended to yours (add-only); your own permissions and hook entries are kept exactly as they are.
  • The kit's allow or ask rules are never copied.
  • If it cannot be merged — invalid JSON, a symlink, or no python3 — nothing is written, the block to add by hand is printed, and the run exits 2.
Where the hashes are recorded

In .claude/harness-lock.json, which also records the kit's commit ID as kit_commit — the version a .bak-<commit> backup is named after.

Every Update run adds a dated entry to the top of .claude/update-log.md: how your edited files were decided, what happened to each one, and counts for the rest.

An update log entry
## 2026-10-26 14:05 — Update 75040d9 → b122017
Decided by: auto-approve (overwrite all)
- CLAUDE.md — overwrote (your edits; backup CLAUDE.md.bak-75040d9)
- agents/qa.md — overwrote (your edits; backup agents/qa.md.bak-75040d9)
- 41 kit files you never edited — refreshed
- 2 files added

The log holds paths, outcomes and counts only, never file contents. Older entries stay below, unchanged. Cancel adds no entry.

CLAUDE.md is delivered from the same source the project was installed with — a brownfield/existing project keeps receiving CLAUDE_LEGACY.md's rules, never the greenfield CLAUDE.md — recorded per project in .claude/harness-lock.json.

Which CLIs get updated

Easy Kit stores no list of CLIs. Update asks no CLI question: it refreshes every CLI whose directory is already present. Reinstall shows the CLI menu, pre-selecting those. That means:

  • A Codex-only project refreshes .codex/skills/ and is not given .claude/{skills,agents} it never asked for.
  • A Claude project keeps its .claude/{skills,agents} links repaired — including when a link has gone missing, stale, absolute, or been replaced by a real directory.
  • Adding a CLI later: run the same command, choose Reinstall, and pick the CLI. A CLI already set up that you do not pick is kept and refreshed, and the plan says so — to drop one, delete its folder.

One edge worth knowing: if both .claude/skills and .claude/agents are deleted outright, Update leaves them absent. Restore them: run the command, choose Reinstall, and pick Claude Code.

Why Update leaves them absent

With nothing present, the project is indistinguishable from one that never picked Claude Code.

Settings tool

Pick the Claude Code settings you want and copy a ready settings.json, or paste yours to check it. The installer adds only the kit's hooks and 4 deny rules.

At Stage 1 the Supervisor offers the profiles below, and uses High security if you skip. It writes only after you approve, and never removes an entry. Everything on this page stays in your browser.

This tool needs JavaScript. Without it, read the official settings reference.

Target file
Start from


        

Install variants

Fork install — export your username first and swap it into the URL:

export GITHUB_USERNAME=your-username
curl -fsSL https://raw.githubusercontent.com/$GITHUB_USERNAME/easy-kit/main/setup.sh | sh

New vs. existing (brownfield) project — a menu choice in the same curl … | sh line: the menus read your terminal, not the pipe.

  • 2) Existing / legacy project — for an existing codebase. Uses CLAUDE_LEGACY.md, which adds legacy-codebase guidance (risk hotspots, strangler-fig patterns).
  • 1) New project — the default with no terminal. You get CLAUDE.md (only @AGENTS.md) and the full AGENTS.md.

Agent roles

Four roles are directly spawnable via the Agent tool, each scoped to a single TASK_GUIDE. Their shared base, general-agent-template, is not a spawnable role; it lives in templates/.

  • Supervisorspawns each role on one task guide
  • backend-developerserver-side APIs and services
  • common-infrastructureworktrees, installs, shared config
  • frontend-developerUI, state, accessibility
  • qa-expertindependent verification
Details
backend-developer
subagent_type: backend-developerblue

Use when a TASK_GUIDE assigns server-side work — a new API endpoint, a service or business-logic change, or a data-access fix.

Core backend engineering role — server-side APIs, services, business logic, and data-access layers, built test-first.

common-infrastructure
subagent_type: common-infrastructureorange

Use when a task needs worktree setup, dependency installs, migrations or shared config.

Environment and shared-config specialist — worktree setup, migrations, shared services; always runs first before implementers start.

frontend-developer
subagent_type: frontend-developerpurple

Use when a TASK_GUIDE assigns client-side work — a new UI component, a client-state or interaction change, or an accessibility fix.

Core frontend engineering role — UI components, client-side state, interactions, and accessibility, built test-first.

qa-expert
subagent_type: qa-expertgreen

Use when a task needs independent verification — checking a finished task's Acceptance Criteria with evidence, extending the smoke suite, or a regression check before merge.

Quality and evaluation role — owns the smoke suite, regression safety, and independent verification of acceptance criteria.

general-agent-template
not directly spawnable — shared base only, in templates/

Base template inherited by all four roles above. Contains the universal Base Rules, engineering principles, and output requirements that are not restated per role. It has no subagent_type of its own and is never spawned directly.

Model and effort per spawn

At Stage 1 you list each CLI and the model it spawns at each Complexity level (C0–C3) in the ## CLI Model Table of PROJECT_SPEC.md, and the effort at each level (low, medium, high, xhigh or max) in the ## CLI Effort Table beside it. craft-spawn-prompt reads both and recommends the model and the effort for each spawn. An empty model cell makes it stop and ask; an empty effort cell passes no effort.

When a task moves up to the extended track, or verify returns fail, the Supervisor first raises the effort of the next spawn by one step, before it changes the model or splits the task. It never lowers effort on its own.

Skills (37)

One inline instruction set loaded per invocation, grouped by which pipeline stage it belongs to.

  1. Stage 0 — Define

    brainstormingideate

  2. Stage 1 — Set up

    git-guardrails-claude-codemap-codebasesettings-setupcompanion-setupcraft-agent

  3. Stage 2 — Intent Transformation

    grill-with-docsto-issues

  4. Stage 3 — Parallel Execution via Isolation

    tddbugfixdiagnosecraft-spawn-promptmigration-safetyux-evaluate

  5. Stage 4 — Review

    blast-radiuscode-reviewhtml-reportscore

  6. Stage 5 — Integration & Verification

    shipdelivery-report

Any stage

compact-advisorcompact-memorycompoundcompound-refreshdotfiles learnoptimizeresolve-pr-feedbackresolve-questionself-reviewslim-skills strategyteachthinking-reportwake write-better-skill

ux-evaluate (Stage 3): the frontend agent screenshots its UI at 375px and 1280px, judges nine UX checks and the guide's UX rows, and fixes each fail. code-review runs it again.

Security finding rules

code-review (Stage 4): its security reviewer follows one short rule file, skills/code-review/references/security-reviewer.md. A finding must name who attacks, the boundary they cross and the harm. A lead that cannot be proven yet stays as needs_validation with the one fact still missing, and never blocks a merge by itself.

self-review

  1. 01You start it/self-review
  2. 02New records?none: stops
  3. 03One miner
  4. 04Up to 3 proposalscited
  5. 05You approve
  6. 06Kanban tasknormal pipeline

Never:

  • edit kit files
  • merge
  • push
  • call the network

Hooks

Deterministic shell/python guardrails the harness runs — not the model. Each fires on a PreToolUse, PostToolUse, or Stop event and either blocks the tool call or only advises (prints, never stops execution).

  1. Tool call
  2. PreToolUsebefore the tool runs
    • blocks a spawn with no task guide
    • blocks an unsafe push or merge
    • blocks a call past the step limit
    • asks before a sensitive path
  3. Tool runs
  4. PostToolUseafter the tool ran
    • advises logs every call to the trace
    • advises prompts a memory update
    • advises registers new task guides
    • inert a reminder to move the row
  5. Stopwhen the run ends
    • blocks an [auto] run until its report checks out
    • advises starts auto verify
    • advises reminds you of Stage 4 review
Details

The wiring lives in .claude/settings.json. Both setup.sh and update.sh merge every entry below into that file. No manual merge step.

What the merge keeps

It merges into a .claude/settings.json your project already has too, and keeps your own permissions and hook entries; the only permissions it adds are the kit's permissions.deny entries.

EventMatcherScriptBehavior
PreToolUseAgentpre_agent_validate_guide.pyblocks spawn if the TASK_GUIDE is missing; otherwise only advises (never blocks)
When it advises
  • The spawn prompt has no memory slice or no **Startup reads** block
  • A Depends on task is not Done
  • A task's Demonstration BEFORE is still blank
PreToolUseBashpre_bash_block_unsafe_merge.pyblocks git push/merge if pipeline gates are unsatisfied
PreToolUseEdit|Write|Bashpre_tool_sensitive_path.pyasks you to confirm before a call touches a path listed in .claude/sensitive-paths.txt — unless the active task's guide predicted that exact path
What the list covers

.env*, secrets, production configs, infra.

PreToolUseEdit|Write|MultiEdit|NotebookEditpre_tool_locked_oracle.pyblocks a sub-agent other than qa-expert from editing a test that a task guide locks, while the task is being built
PreToolUse.*pre_agent_step_limit.pyblocks a call once a sub-agent run, or the main thread, exceeds the step limit (default 90) — self-clearing on the very next call
PostToolUseWritepost_write_register_task.pyadvises — auto-registers new TASK_GUIDE files on the board
PostToolUseAgentpost_agent_move_to_review.pyinert — does not move anything and does not touch any step counter; it only prints a reminder to move the row by hand
Why by hand

The reminder is for the Supervisor. The hand move is deliberate, after two past defects made the automatic move actively harmful.

PostToolUseBashpost_bash_memory_update.pyadvises — prompts a diff-driven memory-update pass after git push/merge/pull
PostToolUse.*post_tool_trace.pyadvises — appends every tool call to memory/event-trace/<task>.jsonl; scripts/verify_trace.py <task> reports whether the trace still matches
How an edit shows

Each line is linked to the one before by a hash chain, with a copy of each line's hash kept outside the repo under ~/.claude/harness-anchors/.

Stop—stop_review_reminder.pyadvises — reminds the Supervisor to run Stage 4 review for pending tasks
Stop—stop_auto_mode_check.pyblocks the end of an [auto] run until its final report checks out — once; the second try stops
What it checks
  • The report is in its file, marked Mode: auto
  • Each Medium/High-risk choice was argued by 2 or 3 Advocates
  • Stage 4 review ran
Stop—stop_auto_verify.pyadvises — starts one headless /verify run per commit for an [auto] task that waits for review
What the run does
  • It writes the verify row and a run record
  • The merge gate accepts that row only with the record
  • The merge stays yours
  • With [admin], the Supervisor may merge and push the task branch after a pass

Agent focus

Each row is a mechanism the kit applies, and the cost or waste it saves. Where the idea came from one of three open-source repos, the last column says which.

Details
We applyTo saveIdea from
Memory slice — the spawn prompt pastes only the memory/MEMORY.md lines about the task's own files, capped at 30 lines / 4,000 characters
Also pasted

Any memory/decisions.md entry that lists those files, within the same cap.

Every agent reading the whole memory index before it startsheadroom
Startup reads list — the spawn prompt names what to read first; the agent's report ends with a Startup reads: line Stage 4 review checksRework from an agent that skipped the rules it must follow—
Response Standard — replies lead with the answer and stay short, but quote what matters verbatim; the audit trail stays fully detailed
What stays verbatim

Code, exact error text, file paths, commands and security warnings; reports point to path:line.

Output tokens, and the Supervisor carrying pasted logs for the rest of its sessioncaveman
Over-engineering reviewer — code-review checks any diff that adds a function, class, module, dependency or config optionCode nobody asked for, which someone must then review and maintainponytail
Measured compact-advisor — quotes the session's measured context size before judging whether to compact
Where it can measure

Where the kit repository's transcript meter is present; an installed project falls back to judgment.

Re-reading a long conversation on every call, the largest cost measured—
Measure before keeping — a claimed saving is measured from session transcripts first (DDR-0009)Building what doesn't pay: a headroom-style Bash-output compressor was measured at about 1 percent of spend and parked—

Packs (optional domain extensions)

Packs add domain-specific agents and skills on top of the four core agents, never replacing core resources. Every project ships all packs, inactive: they sit in packs/ and no CLI loads them.

PackDomainAgentSkills
mobileFlutter, React Native, Swift, Kotlinmobile-developerui-accessibility, platform-compatibility
dataPipelines, notebooks, ETL, dbtdata-engineernotebook-review, pipeline-safety
devopsTerraform, K8s, CI/CD, Dockerdevops-engineerinfra-safety, deployment-checklist
ai-agentLLM apps, RAG, MCP serversai-engineerprompt-review, eval-design
apiREST/gRPC, OpenAPI, auth flowsapi-designercontract-review, auth-checklist
tech-leadTop project documents: C4, sequence, journey, ER, risks, roadmaptech-leadarchitecture-docs
  • The installer never asks about packs.
  • Your Supervisor recommends packs for your project from its business domain, and activates each pack you approve by copying it into agents/ and skills/.
  • Update keeps the packs/ catalog current like any other kit file.

Providers

AGENTS.md plus docs/claude-md/ stay the one primary source of truth. Codex reads it directly; Claude Code reads it through the one-line CLAUDE.md import. Cursor gets a thin adapter.

Details
What an adapter carries

The kit's non-negotiable rules (the four Karpathy principle names and the six Hard-Stop Gate titles) inline, pointing back at the primary for everything else.

FileAuto-read byWhat it carries
AGENTS.mdCodex; Claude Code through the CLAUDE.md importThe full doctrine, plus a short section naming what Codex and Cursor cannot enforce
.cursor/rules/agent-base.mdcCursor (alwaysApply: true)Karpathy principle names, Hard-Stop Gate titles, the untrusted-content boundary rule, and the "no TASK_GUIDE = no work" rule, inlined from AGENTS.md

Codex executes the kit's skills directly, by name, from a projected .codex/skills/ directory (choose Codex in the installer's CLI menu) — it is not left with doctrine alone.

  • Each skill's body is capped at 8 KB per Codex's own limit.
  • A skill over the cap is skipped with a named, loud warning rather than truncated.
  • Four of this kit's skills currently exceed it and are skipped for Codex: bugfix, craft-spawn-prompt, diagnose, and write-better-skill.

What a non-Claude provider still cannot enforce: Claude Code's PreToolUse/PostToolUse hooks, the Agent spawn tool, and everything built on them:

  • code-review, security-review, verify, ship, migration-safety, and the git-guardrails hook.
  • Those stay on the Claude supervisor: an adapter carries the doctrine, and Codex can now run the skills it has room for, but the deterministic enforcement layer does not follow.

Repository layout

The mandatory folder structure created by install. Core resources are copied as real files; project-specific files are created fresh and never overwritten by an update.

PathWhat it contains
agents/Canon sub-agent definitions plus general-agent-template.md (DDR-0007)
skills/Canon custom skills (DDR-0007)
.claude/agents/Committed relative symlink onto agents/ so Claude Code can discover it (.claude/agents -> ../agents)
.claude/skills/Committed relative symlink onto skills/ so Claude Code can discover it (.claude/skills -> ../skills)
AGENTS.mdThe full doctrine. Codex reads it directly. Claude Code reads it through the CLAUDE.md import
CLAUDE.mdHolds only the import @AGENTS.md
.cursor/rules/agent-base.mdcProvider adapter for Cursor — see Providers below
tasks/Task guides generated at Stage 2 (per project)
tasks/attempts.tsvAppend-only log of blocked and stopped runs, built from the event trace after each merge
templates/Blank templates for PRD, PROJECT_SPEC, task board, TASK_GUIDE, and more
packs/Optional domain packs — each adds agents + skills for a specific project type
memory/Two-tier hot/cold memory files (per project) — see Memory System below

Memory System

A two-tier hot/cold memory design keeps agents aligned across sessions. Writes are Supervisor-only — sub-agents never write to memory directly.

  1. 01Supervisor writesthe only writer
  2. 02Hot tiermemory/MEMORY.md, an index capped in characters
  3. 03Cold tierdecisions.md, learnings.md, glossary.md
Agents read a slice pasted in the spawn prompt; never write
Details
FileTierHolds
memory/MEMORY.mdHot≤42,000 characters. Each spawn prompt carries a memory slice; the agent reads the whole file only if its work reaches what the slice misses
What the slice holds

Pasted into each sub-agent spawn prompt: the index lines naming the task's files, dependencies or ID, plus matching decisions.md entries.

memory/decisions.mdColdArchitectural and infrastructure decisions
memory/glossary.mdColdCanonical domain terms and core domain models
memory/learnings.mdColdSpec clarifications, patterns, gotchas
memory/codebase-map.mdStructuralDirectory tree, entry points, blast-radius hotspots — generated by map-codebase

MCPs

Four separate companion tools, not part of this kit: MCP servers to run alongside it. Your Supervisor offers them at Stage 1 (companion-setup); skip is the default, and the kit installs none.

easy-verifier-mcp

A separate companion tool, not part of this kit: a no-LLM evidence engine you can run alongside Stage 4 review.

Details
  • No LLM and no model API key — ratings are deterministic rules over cited metrics
  • Seven independently callable dimensions, from architecture to blast-radius
  • Auditable coverage — a "found 4/6" always shows the sources it did not find
  • Read-only and local — never runs the target repo's code, no outbound network
  • Kit-aware mode treats this kit's specs, task guides and memory as ground truth

easy-verifier-mcp on GitHub · Easy Verifier site

easy-ui-mcp

A separate companion tool, not part of this kit: a Dockerized MCP server for testing a web UI locally.

Details
  • Playwright browser automation that an agent such as Claude Code drives step by step
  • Returns a JSON and HTML report with screenshots — no server-side LLM, no test scripts to write
  • Separates claims from observations: ui_assert fails the run, ui_check records and continues
  • Captures console errors, page errors and failed network requests as "Browser problems"
  • Version 1 covers web only (Chromium) and runs locally only

easy-ui-mcp on GitHub

easy-memory-mcp

A separate companion tool, optional and not part of this kit: an MCP server that saves what a session found out and hands it to the next one.

Details
  • Without it installed, the kit runs as before — it is optional and not needed
  • After a long answer it saves a local note; your next prompt gets a short index of matching notes
  • MCP tools memory_search, memory_read, memory_list and memory_forget, plus a per-repo on/off switch and a report of sessions with memory on against off
  • One file, standard library only; notes are saved in clear text with mode 0600, so only you can read them
  • A working prototype: about 28% fewer tokens in scripted tests (experiment 03), not yet measured on real work

easy-memory-mcp on GitHub

easy-personal-mcp

A separate companion tool, optional and not part of this kit: an MCP server and dashboard about you, not a repo.

Details
  • Turns your local Claude Code activity into usage numbers, warnings and an improvement plan
  • Local-first: no network at runtime, metadata only and never message content, no LLM inside
  • Shows cost as API-equivalent cost (tokens times a dated price table), not what your subscription charges
  • Manages your personal tool connectors and keeps their secrets in the OS keychain
  • Version 0.2.0, runs natively on Linux

easy-personal-mcp on GitHub · Easy Personal site

Options

Environment variableDefaultPurpose
GITHUB_USERNAMEthunderkdsInstall/update from a fork instead of the canonical repo