Working Genius
A development workflow for Claude Code — 24 skills, five subagents (an inventor, an attacker, a builder, a reviewer and a design critic, each shipped inside the skill that spawns it), and a work-file format that carries a piece of work between sessions. Built on one observation:
Work doesn't fail at random. It fails at whichever stage got skipped.
Patrick Lencioni's Six Types of Working Genius names the six stages every piece of work must pass through — Wonder, Invention, Discernment, Galvanizing, Enablement, Tenacity. Human teams fail when they jump from idea straight to implementation. Coding agents fail exactly the same way, just faster:
| Skipped genius | What it looks like in an agent session |
|---|
| Wonder — questioning the work | It built exactly what you asked. What you asked wasn't what you wanted. |
| Invention — generating options | The first plausible design became the only design. |
| Discernment — judging and choosing | A plausible-but-wrong approach shipped because nobody tried to kill it. |
| Galvanizing — mobilizing the plan | A decision everyone liked and no fresh session could start from. |
| Enablement — building with feedback | A huge diff, no tests, revealed big-bang at the end. |
| Tenacity — finishing with evidence | "Done!" — on stale evidence, or none. It was "done" three times. |
This plugin walks every piece of work through all six — and every stage runs only when you type its command (Invention runs inside /discern, since nothing in it waits on you), so one you don't type simply doesn't run: the work file shows what ran and what didn't. Gaps stay visible instead of becoming mysteries.
Install
In Claude Code:
/plugin marketplace add donald-ada/workinggenius
Nothing to build, nothing to run. The skills are plain markdown folders under skills/; what rides inside them is Claude Code's — five subagents, two judges registered when you type /enable or /tenacity and never by installation, blocking the two failures the flow has measured (a coordinator that announces a dispatch and ends its turn, a builder that hands back a claim instead of evidence), and the format's own instrument, whose counts are injected before /genius, /compact, /reconcile and /distill read.
Then, in any project:
/genius add per-user rate limiting # start a piece of work
/wonder # correct its story, answer its questions, confirm the problem
/architect # (greenfield) build-or-adopt first, then one committed architecture
/designer # (UI work) settle the look before the pixels
/discern # fresh inventors diverge, blind attackers hit every path, commit to one, record the kills
/galvanize # slice into fresh-session-ready vertical slices
/enable # build one slice, red-before-green, tight loops
/tenacity # verify everything fresh, review, clean up, commit
Small work, where the problem needs confirming and no design is in question, takes the short path — the same depth at every stage it runs, and the stages it skips are skips you make by not typing them:
/genius fix the date parser on two-digit years # start it
/wonder # confirm the problem and how you'll judge it done
/enable <slug> # build it straight against those criteria, tests first
/tenacity # verify fresh, review, commit
Two commands stand outside the flow and track nothing: /attack puts a plan you hand over under blind attack, and /fresh-eyes has a diff reviewed by eyes that never saw it written.
/genius at any time shows where every piece of work stands and what to run next. Run /setup-working-genius once per repo: it pins the work-file directory, verify commands, and issue tracking, and writes the pointer that tells every future session this project works this way.
One piece of work = one folder at .genius/<slug>/ — the snapshot (current truth, bounded by a character ceiling), the append-only log behind it, a tree of one short root and one branch per stage or slice, so a session opens only the branch it needs, the contract that binds the unbuilt slices, and the work's own artifacts. The files — not conversation memory — carry the work: the confirmed problem, the options and their kill-reasons, the slices and where they stand. Any fresh session picks up exactly where the last one stopped. Not every piece of work deserves all six stages — dropping one is your call, made by not typing it; the snapshot's missing section is the record.
Skills
The map (user-invoked only — the flow never hijacks work you didn't put in it):
- /genius — status of all work, the backlog of what the flow discovered and nobody started, genius-gap diagnosis, post-mortem patterns, mid-flow entry points
The six stages (five commands you type — the flow never advances itself):
- /wonder — the live interview that turns a raw idea into a user-confirmed problem
- /discern — first Invention: fresh inventors find structurally different paths, each grounded in the repo; then one blind attacker per path tries to kill it, the favorite included; commit to one, kills on the record (
/invent alone still explores without attacking)
- /galvanize — the decision converted into slices a fresh session can grab cold
- /enable — one slice per fresh context, tests leading the code, reality voting every few minutes
- /tenacity — "done" as a claim about fresh evidence: everything re-run and read, then cleanup, commit, post-mortem
Support:
- /architect — adopt an existing system or build — and if build, one committed architecture in
ARCHITECTURE.md: qualities ranked, boundaries by ownership, stressed against the field and the future, proven by a walking skeleton, confirmed in consequences
- /designer — the style conversation building momentum never starts: audience first, a written brief every direction is drawn under (13 template bases when you name a look), taste settled by looking at real states, a critic reading the chosen one against the brief, accessibility computed as the floor, one committed language of tokens with roles in
DESIGN.md
- /attack — any plan or set of approaches under blind attack, one attacker per path, the wounds checked against the repo before you see them; nothing tracked
- /fresh-eyes — a diff reviewed against what you say it should do, by a reviewer with no memory of how it was written; findings checked before you see them, nothing tracked
- /waitwhat — type it when an answer lost you: the re-pitch adds the missing premises; a repeat sends the term to the glossary
- /blindspot — the unknown-unknowns pass: territory before unfamiliar work, judgment before a choice, a quiz before acceptance
- /reconcile — the drift sweep: settled decisions, glossary terms, pinned commands and live contracts checked against the repo they describe, each finding carrying what produced it
- /triage — the backlog's own rules put to its lines: seeds that shouldn't still be there, pairs that are one discovery, seeds that outgrew a line, the order nobody stated — one at a time, your call
- /distill — retroactive log distillation for done work that closed before the rule existed: what the repo now answers leaves, what it cannot stays
- /compact — the compaction question put to a snapshot that drifted: what no longer constrains unfinished work is routed out, a file in some other shape brought to the format on the way, proposed before moved
- /setup-working-genius — per-repo pinning of directory, verify commands, and issue tracking, plus the cross-agent pointer
- genius-file (model-invoked) — the work-file discipline: the files carry the work, absence is the record
- record-prose (model-invoked) — how every record under
.genius/ is written: for a cold reader and the owner both, reasoning load-bearing, evidence as data
- domain-glossary (model-invoked) — the project's shared language in
CONTEXT.md: challenge collisions, record resolutions
License
MIT
