┌─[ BATTLE SCHOOL // COMMAND DECK ]──────────────────────────────┐
│ │
│ ███████╗███╗ ██╗██████╗ ███████╗██████╗ │
│ ██╔════╝████╗ ██║██╔══██╗██╔════╝██╔══██╗ │
│ █████╗ ██╔██╗ ██║██║ ██║█████╗ ██████╔╝ │
│ ██╔══╝ ██║╚██╗██║██║ ██║██╔══╝ ██╔══██╗ │
│ ███████╗██║ ╚████║██████╔╝███████╗██║ ██║ │
│ ╚══════╝╚═╝ ╚═══╝╚═════╝ ╚══════╝╚═╝ ╚═╝ │
│ │
│ > a jeesh of AI agents for autonomous software dev │
│ > the enemy's gate is down │
│ │
└────────────────────────────────────────────────────────────────┘
"In the moment when I truly understand my enemy, understand him well enough to defeat him, then in that very moment I also love him." — Ender Wiggin
Ender couldn't fight every battle himself. His genius was the jeesh — Toon Leaders who commanded their own squads independently, after-action reports that let him course-correct without micromanaging, and Battle School's discipline of fresh formations against a fresh enemy.
Ender is that pattern, ported to AI agent development. You're the Hegemon. The Commander plans. Toon Leaders execute. Mazer reviews adversarially. Petra runs the live-fire sim. You walk away. They keep fighting.
The bottleneck in software engineering is no longer intelligence. It's human attention. A team can have a backlog of fifty features and the models smart enough to ship every one of them — but every commit needs review, every architectural call needs a human in the loop. The work stalls in the inbox.
Ender flips that. You describe what to build. A Commander runs a planning conversation with you, writes the victory conditions (what "done" means, in behavioral assertions independent of implementation), drafts a battle plan (engagements → features, each mapped to victory conditions), and gets your approval. Then it dispatches its jeesh.
╭─────────────────╮
│ HEGEMON │ you — approves, redirects
╰────────┬────────╯
│
╭────────▼────────╮
│ COMMANDER │ Ender — plans, dispatches
╰────────┬────────╯
│
┌─────────────────┼─────────────────┐
│ │ │
╭────▼─────╮ ╭─────▼─────╮ ╭────▼─────╮
│ TOON │ │ MAZER │ │ PETRA │
│ LEADER │────▶│ + BEAN ×N │─────▶│ live-fire│
│ ships │ │ scrutiny │ │ sim │
╰──────────╯ ╰───────────╯ ╰──────────╯
SPECIAL OPS · spawned at specific moments
╭──────────╮ ╭──────────╮ ╭──────────╮ ╭──────────╮ ╭──────────╮
│ GRAFF │ │ ANDERSON │ │ ALAI │ │ DINK │ │ CADET ×N │
│ strategy │ │ engineer │ │ replay │ │ forensic │ │ persona │
│ critic │ │ critic │ │ debug │ │ audit │ │ beta-user│
╰──────────╯ ╰──────────╯ ╰──────────╯ ╰──────────╯ ╰──────────╯
| Role | Who | What they do |
|---|---|---|
| Commander | Ender | Plans, scopes, dispatches Toon Leaders, decides follow-ups at engagement boundaries |
| Toon Leader | Bean, Petra, Alai, Crazy Tom — your workers | Implements exactly one feature in fresh context. Commits. Writes an After-Action Report. |
| Mazer | Mazer Rackham | Adversarial scrutiny pass. Tests, type checks, lint, parallel per-feature code review against the victory conditions. |
| Petra | Petra Arkanian | Adversarial live-fire pass. Spawns the live app, drives it through real user flows, verifies behavior — not appearance. |
| Bean | Bean (the analyst) | Fresh-eyes per-feature reviewer. Mazer spawns one per feature, in parallel. |
Toon Leaders work serially — one engagement at a time. Within an engagement, recon parallelizes (search, research, multi-file reads). Writes do not. Parallel feature workers conflict; they step on each other, duplicate work, make inconsistent architectural calls. Serial features compound correctness. The enemy's gate is down.
Five forms of agent coordination, woven into every mission:
| Strategy | In Ender |
|---|---|
| Delegation | Commander → Toon Leader; Toon Leader → read-only recon sub-agents |
| Creator-verifier | Toon Leader implements; Mazer + Petra check with separate context (no cost bias) |
| Broadcast | battle-log.md — every agent reads the shared state |
| Negotiation | Engagement boundaries — Commander decides follow-ups vs. accept |
| Direct communication | Avoided. State fragments without a coordinator. |
cp -r ender ~/.claude/plugins/enderThe plugin is self-contained — .claude-plugin/plugin.json is the manifest.
/ender:start ─▶ /ender:review-plan ─▶ /ender:next* ─▶ /ender:validate ─▶ /ender:final-exam ─▶ /ender:retro
│ │ │ │ │ │
▼ ▼ ▼ ▼ ▼ ▼
battle room Graff + Anderson Toon Leader Mazer scrutiny Dink forensic durable
scope + plan spar the plan ships feature + Bean reviewers audit lessons
victory conds Hegemon approves writes AAR Petra live-fire Cadet personas skill
( * loop per engagement passes → followups updates
engagement )
Anytime: /ender:status /ender:aar /ender:resume /ender:abort
| Command | What it does |
|---|---|
/ender:start <goal> |
Planning conversation. Produces victory-conditions.md + battle-plan.md under .ender/<slug>/. |
/ender:status |
Command Deck. Progress, active role, recent AARs, budget burn. |
/ender:next [slug] |
Dispatch a fresh Toon Leader for the next feature. Writes AAR on return. |
/ender:validate [slug] |
Run Mazer (scrutiny) then Petra (live-fire) at the engagement boundary. |
/ender:aar [slug] [feature] |
Inspect or repair After-Action Reports. |
/ender:resume [slug] |
Pick up a stalled mission. Diagnoses where it stopped, surfaces blockers, recommends or executes the next step. |
/ender:review-plan [slug] |
Spar the draft battle plan. Dispatches Graff (strategic) + Anderson (engineering) in parallel; synthesizes findings before the Hegemon approves. |
/ender:final-exam [depth] [slug] |
Pre-launch readiness audit. Dispatches Dink (forensic codebase) + Cadets (persona-driven live-fire). Optionally feeds findings back into a mission as follow-up engagements. |
/ender:retro [slug] |
Post-mission retrospective. Captures what worked, what didn't, durable lessons. Proposes skill updates for the Hegemon's approval. Adapts structure for failed/aborted missions. |
/ender:abort <slug> <reason> [--as failed|aborted] |
Formally stop a mission. Sets terminal state + reason. Destructive; requires confirmation. Recommends /ender:retro before the mission goes cold. |
Defined under agents/, dispatched by the commands:
commander— planning + coordination braintoon-leader— fresh-context single-feature implementermazer— runs tests/lints/types + spawns parallel Bean reviewerspetra— drives the live app via Playwrightbean— fresh per-feature reviewer (parallel sub-validator)dink— forensic codebase auditor for the Final Examcadet— persona-driven beta-user simulator for the Final Exam (one per ICP)graff— strategic plan critic for/ender:review-plan(Battle School commander)anderson— engineering plan critic for/ender:review-plan(Graff's deputy)alai— simulator-replay operator; dispatched by the Commander on failed/blocked AARs to find root cause before patching
Under skills/. Each captures one piece of the discipline:
victory-conditions— write the win conditions before any codecommanding-engagements— the Commander role end-to-endtoon-leader-execution— single-feature scope disciplineafter-action-reports— the forensic record that lets the jeesh self-healmazer-review— adversarial code-level passlive-fire-simulation— adversarial behavioral passpicking-your-jeesh— the right model in each seatserial-engagements-parallel-recon— when to parallelize, when not tofinal-exam— launch readiness audit: Dink (forensic codebase) + Cadets (persona-driven live-fire), with findings that flow back into the mission as new engagementsbattle-room-brainstorming— Phase 0 of every mission: explore the problem space before scopingaim-before-fire— tests-first discipline (RED → GREEN → REFACTOR) inside Toon Leader executionsimulator-replay— systematic debugging when an AAR fails or a finding has unclear root causesparring-the-plan— adversarial plan review (Graff + Anderson) before approvalmission-retro— post-mission learning capture, durable-lesson distillation
All mission state is files. Survives across sessions. Easy to inspect.
.ender/<slug>/
battle-plan.md
victory-conditions.md
state.json
battle-log.md # broadcast — append-only
aars/<feature-id>.md # after-action reports
validation/engagement-<N>-mazer.md
validation/engagement-<N>-petra.md
review/ # if /ender:review-plan was run
graff-review.md
anderson-review.md
synthesis.md
replays/ # if Alai ran simulator-replay
<feature-id>.md
final-exam/ # if /ender:final-exam was run
reconnaissance.md
dink-report.md
cadets/<persona-slug>.md
gap-report.md
followups.md
retro.md # if /ender:retro was run
> /ender:start build a realtime chat app with auth + channels
[Phase 0: Battle Room — Commander brainstorms with you to name the real
problem, generate alternatives, choose an approach]
[Phase 2-3: scoping conversation, drafts victory-conditions.md + battle-plan.md]
> /ender:review-plan
[Graff + Anderson dispatched in parallel for adversarial critique]
[Synthesis: 2 blockers (V4 is structural, Engagement 3 too thick), 1 concern]
[Hegemon accepts both blockers → Commander edits plan]
> approved
[plan saved, status=approved]
> /ender:next
[Toon Leader dispatched for Feature 1.1, returns when AAR is written]
> /ender:next
[Feature 1.2 ...]
# engagement 1 features done
> /ender:validate
[Mazer runs tests + spawns 4 Beans in parallel for per-feature review]
[Petra spawns the app, drives signup + channel-create flows,
takes screenshots, verifies persistence]
[2 victory conditions failed live-fire — Commander scopes follow-up features]
> /ender:next
[follow-up feature 1.x-followup-email-validation]
...
> /ender:validate
[engagement 1 passes → advance to engagement 2]
# all engagements done; final pre-launch sweep
> /ender:final-exam full <slug>
[Dink runs the forensic codebase pass — mocks, ghost code, security gaps]
[Cadet:sarah, Cadet:marcus, Cadet:mobile-first run serially against the live app]
[Gap report: Readiness 7.6/10; 3 P0, 8 P1 findings]
[Hegemon approves → 11 follow-up features appended as Engagement N: Final Exam Remediation]
> /ender:next
[Toon Leader starts fixing the first follow-up]
...
# all engagements + follow-ups validated
> /ender:retro
[Commander reads every AAR, validation report, and battle-log entry]
[Surfaces what worked, what didn't, 2 durable lessons]
[Proposes a tightening edit to `aim-before-fire` — Hegemon approves]
/ender:status is read-only — check the Command Deck any time.
If a mission gets interrupted, /ender:resume diagnoses where it stopped and recommends the next step.
- Victory conditions before code. Tests written after implementation confirm decisions; they don't catch bugs.
- Fresh formations. Each Toon Leader has clean context. Long context degrades attention.
- One engagement at a time. Parallel feature workers conflict. Serial compounds correctness.
- Recon parallelizes. Search, research, parallel code review — anything read-only.
- The right droid in each seat. Planning, implementation, and validation each want different things. Cross-family validators avoid shared blind spots.
- After-Action Reports are honest. Lies poison the next engagement. Forensic accuracy is what lets the jeesh run for days.
- Logic lives in prompts and skills. When models improve, the jeesh improves with them.
This plugin is themed around Ender's Game. The Battle School vocabulary — Commander, Toon Leader, Mazer, Petra, Bean, jeesh, engagement, victory conditions, After-Action Report — is a deliberate frame. The intent isn't whimsy; it's clarity. Military command structures have spent millennia refining how to delegate, hold scope, debrief, and integrate intelligence. Ender's jeesh is one of literature's tightest illustrations of that, and the model fits multi-agent software development cleanly.
The enemy's gate is down. Get to work.