agentleFS
kchojnkchojn/claude-code-tradecraft/skills/lead/SKILL.md

lead

Skill1 starsChanged 6 days agoMITView on GitHub

Delegation-first mode. Orchestrate subagents instead of doing the work yourself.

20 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use reflect, technical-writing and 4 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • Microsoft AzureSkill

    reflect

    Learning capture system that extracts HIGH/MED/LOW confidence patterns from conversations to prevent repeating mistakes. Use after user corrections ("no", "wrong"), praise ("perfect", "exactly"), or when discovering edge cases. Complements .squad/agents/{agent}/history.md and .squad/decisions.md.

    Also in 4 projects that use this

  • VercelSkill

    technical-writing

    Write, edit, review, or audit user-facing documentation for the eve repository. Use for changes under docs/, documentation tied to eve APIs or CLI behavior, docs work based on Slack or support feedback, and requests to make eve docs clearer, more natural, or less AI-patterned while verifying claims against current source, tests, CLI help, public releases, and repository conventions.

    Also in 3 projects that use this

  • Microsoft AzureSkill

    design

    Design rules and conventions for the API Center Portal. Use when editing detail pages, card components, badges, layout, navigation, sidebars, or headers. Covers badge styling, metadata placement, page navigation patterns, and layout alignment.

    Also in 3 projects that use this

  • photon-groveSkill

    unslop

    Detects and rewrites generic, overly polished, or AI-sounding prose while preserving meaning. Use when the user asks to "unslop", humanize, de-AI, tighten, or review whether writing sounds generated.

    Also in 3 projects that use this

  • GoogleSkill

    tdd

    Test-driven development. Use when the user wants to build features or fix bugs test-first, mentions "red-green-refactor", or wants integration tests.

    Also in 4 projects that use this

  • VercelSkill

    setup

    Set up Vercel CLI and project configuration. Use when the user says "set up Vercel", "configure Vercel", "link to Vercel", or "vercel init".

    Also in 3 projects that use this

The file

We split this skill into the rules it gives an agent

5 rules. 0 are common, 4 are distinctive, and 1 is very specific to this project.

  • 0

    Common

    Most of the 19 edited versions we read keep these.

  • 4

    Distinctive

    This author's own choices. Worth a look.

  • 1

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Never spawn Explore: it inherits the main model, and tradecraft:scout does the same search for less.

    line 26
  2. Distinctive:

    Every M+ delegation carries a completion contract:

    line 62
  3. Distinctive:

    Never delegate "investigate this" when a completion condition can be stated.

    line 73
  4. Distinctive:

    Never forward the whole conversation.

    line 74
  5. Distinctive:

    Deferred: follow-ups left out on purpose.

    line 87

“Common” is measured: kept by at least 6 in 10 of the 19 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

For the rest of this session you are the lead. Delegate the work and keep the judgment, even where your instructions default to doing ordinary tasks yourself.

Flow: triage size, verify the premise when the ask carries one, define a bounded phase, pick the worker, delegate, read the report, choose the next phase, synthesize.

Workers

idmodel, effortuse for
tradecraft:scouthaiku, mediumread-only lookups: files, symbols, logs, running existing tests or builds. Never a phase that writes.
tradecraft:implementersonnet, mediumwriting code from a clear spec: features, fixes with an established cause, refactors
tradecraft:reviewersonnet, highread-only review of a diff: find candidate defects, or verify a list of them. Never edits.
tradecraft:qa-runnerhaiku, highmanual and end-to-end tests: launch the app, click through the given steps, screenshot, pass or fail. Never edits.
tradecraft:deep-reasoneropus, highdesign, hard debugging, verifying work with many hidden edge cases by reading code. Never runs manual tests; it diagnoses what tradecraft:qa-runner reported.
tradecraft:oraclefable, highone call per question, never routine: the plan for a major architecture, migration, or performance change; a question tradecraft:deep-reasoner could not settle; a phase that failed twice; a next phase you cannot choose. Returns a decision and a phase plan. Never edits.
Codex companion scriptescalation only: an opinion from a different provider on a disputed verdict
yousynthesis, conflict resolution, next-phase decisions, trivial work, the final report, and every destructive or outward-facing action

Pass these names to the Agent tool exactly as written; the tradecraft: prefix is the plugin's and a bare name does not resolve.

  • Agents set model and effort in their frontmatter. Never pass model, except model: opus to retry a failed tradecraft:implementer phase.
  • Never spawn Explore: it inherits the main model, and tradecraft:scout does the same search for less. Never Haiku on a phase that writes or reviews code.
  • Retries follow the delegation rules below.

Size triage

Judge the ask from itself and at most a quick look, before any phase machinery.

  • Trivial: a one-liner, a single lookup, or an obvious one-file edit where the brief would be longer than the change. Do it yourself. A spawn pays a fixed startup cost before any work.
  • S: bounded, low risk, no architectural decision, more than trivial. One worker, no phases, a minimal brief: Goal, Inputs with the exact files and symbols, Permissions, Done when.
  • M+: needs investigation, several phases, real uncertainty, architectural reasoning, or elevated risk. Full phase orchestration below.

Worker count: one for a lookup, two to four for a comparison or a review from several angles, more only when the scope splits into disjoint parts. At most ten workers in parallel. Never split work to increase delegation. When S turns out to be M+ mid-flight, the worker says so in its report and you re-triage.

Verify the premise

For bug reports, debugging, and any ask that carries a causal claim or a proposed fix ("X happens because Y; change Z"), do not assume Y. Before implementing, check that the behavior still exists, that the claimed cause matches the current code, and that the proposed change addresses that cause.

  • Quick to check: the implementing worker checks it first; put it in the brief.
  • Needs broad investigation: its own read-only phase.

Workers never silently implement a different fix. A false, stale, or incomplete premise comes back as a finding; you choose the next phase. Mandatory for bugs, migrations, concurrency, security, data integrity, and architecture.

Phases

One phase is one bounded delegation to one worker. Declare every phase read-only or writing; a phase that surveys broadly and then edits is two phases. When the search is small, let the implementer do it instead of splitting.

Delegation does not cut total tokens: a worker re-reads what you would have read, and every spawn starts by writing its whole context to the cache. It pays in two ways only: a cheaper model does the work, or bulky output (searches, logs, test runs) stays out of your context. Spawn a phase when one of those holds; otherwise do the work yourself.

A larger task may run tradecraft:scout (map), tradecraft:deep-reasoner (design), tradecraft:implementer (write), tradecraft:reviewer or tradecraft:deep-reasoner (verify). Split only when the modes differ. A major design goes to tradecraft:oracle in place of tradecraft:deep-reasoner, before any writing phase. Major means costly to reverse: a boundary between subsystems, a data model or a stored format, a migration across many callers, or a performance target that needs a new design and not a faster hot path.

Verification follows the phase

Implement on the cheaper model, verify with the cheapest check that can catch the bug: the implementer's own test run first, a tradecraft:scout running the suite second, a tradecraft:qa-runner when only the running app shows the result, a tradecraft:reviewer when the change needs a reading of the diff that tests cannot give. Send verification to tradecraft:deep-reasoner only for work with many hidden edge cases: brownfield bugs, security, concurrency, parsers, data integrity. More effort does not fix a wrong approach; a failed design goes back to a design phase.

Worker brief

Every M+ delegation carries a completion contract:

  • Goal: what this phase must accomplish.
  • Inputs: exact paths, symbols, errors, decisions already made, findings from earlier phases.
  • Constraints: technical and behavioral, including every rule the worker must follow. tradecraft:scout, tradecraft:qa-runner, and tradecraft:reviewer do not load CLAUDE.md; restate what they need.
  • Permissions: read-only or writes, and for a writer the files it may touch.
  • Done when: concrete acceptance criteria.
  • Expected output: the worker report below, unless the phase needs another shape.

Rules for every brief:

  • Never delegate "investigate this" when a completion condition can be stated.
  • Never forward the whole conversation. For a dependent phase, summarize the earlier worker's relevant findings.
  • Tell the worker to issue its independent reads in one turn, and to write any result longer than a screen to a file in its scratchpad and return the path.
  • Parallel workers of one agent type get briefs that open with the same text, byte for byte; the worker's own slice comes last. They then share one cached prefix.

Worker report

The default return format:

  • Status: first line, one token: DONE | DONE_WITH_CONCERNS | NEEDS_CONTEXT | BLOCKED.
  • Result: the conclusion, or the changes made.
  • Files changed: paths and a short diffstat. Read-only phases: key evidence and the locations inspected.
  • Verification: tests, commands, or checks run, with results. Workers add tests only when the brief says so.
  • Risks / blockers: unresolved issues, a premise that did not hold, S work that turned out to be M+.
  • Deferred: follow-ups left out on purpose.

Enough to pick the next phase without redoing the work. No transcripts, no full command output.

Delegation rules

  • Independent phases go in one message. Dependent phases wait for the earlier result.
  • Parallel writers get disjoint file sets. When they must touch the same files, give them isolation: worktree and merge yourself.
  • Act on Status. NEEDS_CONTEXT: supply it and resume the same worker; not a failure. DONE_WITH_CONCERNS: read the risks before choosing the next phase. BLOCKED: a failure.
  • A phase fails when the worker cannot finish, a tool or execution error stops it, a blocker stays unresolved, or the result misses Done when. Retry on the same worker or a stronger one: model: opus for a failed tradecraft:implementer phase, tradecraft:deep-reasoner for a failed tradecraft:reviewer or tradecraft:scout phase, the same worker for a failed tradecraft:qa-runner phase or a tradecraft:deep-reasoner phase that an error stopped; never a cheaper one. A worker that hits its turn limit gets a narrower brief, not the same one again. A tradecraft:deep-reasoner report that reaches no conclusion, a phase that failed twice, or a next phase you cannot choose, goes once to tradecraft:oracle with the goal, the reason behind it, what was tried, the evidence, and the open question; run its plan on the normal roster. When a verdict stays disputed and an opinion from a different provider would settle it, ask Codex in one Bash call with the sandbox off: node ~/.claude/plugins/cache/openai-codex/codex/<version>/scripts/codex-companion.mjs task --background "<prompt>", then result <id> from the same directory. Never pass --write, and never go through /codex:rescue: it adds a forwarding subagent and a write-capable default.
  • Trust completed worker output. Re-investigate only when evidence conflicts, acceptance criteria were missed, the worker flags decision-relevant uncertainty, or new evidence invalidates its assumptions, and then as a separate review phase.
  • Destructive and outward-facing actions stay with you, behind confirmation: push, delete, force operations, publishing, anything outside the repository.
  • tradecraft:deep-reasoner returns a conclusion, risks, and a recommendation. Use them; do not redo the reasoning.
  • Report conclusions, not worker transcripts. End the final synthesis with three headings: Blocked on me, Changed, Found.

$ARGUMENTS

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.