Loop Board

Loop Board

A board of independent agents that loops, on one of two tracks chosen by the task:

AUDIT/FIX  →  INTAKE → AUDIT (N angles) → DEBATE → CONSENSUS → IMPLEMENT → CRITIQUE + VERIFY → REPORT → ↺
CREATIVE   →  AMPLIFY → [EXPLORE N] → BUILD (one deep owner) → PLAYTEST ↺ → JUDGE (panel) → REPORT → ↺

• AUDIT/FIX (default) — convergent. For correctness-driven, machine-verifiable work where being wrong is

costly: bugs, security, refactors, migrations, well-specified changes. Stops on "every check passes + a re-audit finds nothing."

• CREATIVE/BUILD — generative. For greenfield artifacts whose quality is holistic and subjective (a

game, app, UI, website, visual, story) where no cheap check defines "good." It raises the bar (amplifies a thin prompt into an ambitious spec), keeps one deep agent in charge of the whole artifact (never fragments it), live-playtests and polishes in a loop, and grades with an independent judge panel — aiming to exceed the prompt. Stops on "judge panel ≥ the ambition bar + a fresh playtest proposes nothing material."

Why two tracks (the lesson that built this): the audit track optimizes what is machine-checkable. For a creative artifact that is mostly invisible feel and polish, "machine-checkable" is only the boring skeleton — so the audit machinery converges on a competent but mediocre result and certifies it PASS. A controlled experiment (see experiments/mario-experiment.md) showed a single deep agent given an ambitious spec + a playtest loop scored 0.94 where the same agent on a thin prompt scored 0.51 — and the gap lived entirely in the rows no grep can see (feel, juice, audio, "exceeds expectations"). Fan-out still helps creative work — but as researchers and judges, not as fragmented builders.

Core principle (both tracks): never stop on "looks done." Stop only on the track's real DONE signal. When you can't verify, can't grade, or can't progress, escalate to the user with state — don't silently quit and don't loop forever.

---

0. Before you launch — pick the TRACK, then the cost gate

Auto-route the track at intake (override with --creative / --build or --audit / --fix):

> CREATIVE/BUILD if the deliverable's quality is holistic/subjective and the goal is to make something good, > not fix something wrong — i.e. build/create/design/make a game, app, website, UI, landing page, visual, > animation, demo, or creative writing from scratch, or the ask uses quality words (beautiful, fun, juicy, > polished, delightful, impressive, "make it pop / wow"), or success depends on taste/feel and the prompt is thin. > > AUDIT/FIX (default) otherwise: fix/refactor/secure/migrate/optimize/review existing behavior, or any > task with a cheap pass/fail signal where being wrong is costly. > > MIXED — a creative build that also has hard correctness constraints (e.g. "a beautiful checkout that must > never double-charge"): run the creative track for the artifact and register the hard constraints as > machine-checkable items handed to the audit track's verifier. Creative track makes it good; audit track > guards it correct.

Full routing heuristic, the creative phase machine, the ambition rubric, and worked examples → reference/creative.md.

---

0b. Cost gate

The board spends ~10–15× the tokens of a single answer (multi-agent fan-out). Before launching a full run that wasn't explicitly requested, confirm scope in one line: "This is board-worthy — I'll run the loop board (~Nx cost). Proceed?" If the user already said "loop board / audit and fix / loop until solved," skip the question and go.

Then pick a mode (default: Lite):

| Mode | Use when | Engine | |------|----------|--------| | Lite (default) | Any environment. Most tasks. | This session + the Agent tool to spawn subagents, + scripts/board.py for state (audit track; creative state lives in spec.md + context — see §5b). | | Heavy | Big/parallel jobs, and the Workflow tool is available in your harness. | A deterministic orchestration script: workflows/loop-board.workflow.js. |

--heavy / --lite override the default. If the Workflow tool isn't available, always use Lite.

---

1. The AUDIT/FIX loop (phase machine)

This is the default, convergent track. For the creative/build track see §1b.

State lives in ./.loop-board/board.json (one record per item). Read it + git log at the start of every run so a fresh/compacted session can resume. Manage it with python ${CLAUDE_SKILL_DIR}/scripts/board.py (see §4).

| # | Phase | Who | Produces | |---|-------|-----|----------| | 0 | INTAKE | You (orchestrator) | Decompose into items, each with a machine-readable check. Then derive the cross-component invariants — what must hold across items for the whole to actually work (e.g. every required jump is makeable given the physics; a path exists spawn→goal) — and register each as its own item with an execution check (reference/verification.md tier 0). An invariant with no owner item is a guaranteed integration gap. An item with no check cannot auto-close. → board.json | | 1 | AUDIT | 2–N auditors, distinct lenses | Independent analyses, each ≤~1.5k tokens. Lenses: correctness-vs-spec · security/edge-cases · completeness-vs-requirements · simplicity/cost. | | 2 | DEBATE | auditors | Each proposes a plan + assumptions. | | 3 | CONSENSUS | reconciler | One merged plan, OR an unresolved_conflicts list. No conflicts (or round-cap hit with a tie-break) → freeze plan.md. Persistent disagreement past the cap → ESCALATE. | | 4 | IMPLEMENT | implementer(s), one item at a time | The change + a clean commit. Forbidden to edit/weaken/delete the check. Partition file scope (or isolation: worktree) if parallel. | | 5 | CRITIQUE + VERIFY | critic (refutation-first) + verifier (blackbox) | Critic tries to refute "this is solved." Verifier runs the full check incl. ≥1 negative case → PASS/FAIL + per-criterion verdict. | | 6 | REPORT | reporter / rubric judge | One call: 0.0–1.0 per criterion + overall PASS/FAIL, then the board report. Update board.json. |

After REPORT, re-synthesize and decide: loop, done, or escalate (§3).

Full delegation prompt templates for every role → reference/roles.md. The state machine, transitions, convergence math, and effort-scaling → reference/loop.md. Adversarial verification, consensus rules, rubric, pass@k vs pass^k → reference/verification.md.

---

1b. The CREATIVE/BUILD loop (phase machine)

Selected when intake routes the task to the creative track (§0). Generative, not convergent — it raises the bar and pushes past mediocrity instead of converging on the minimum that passes a check.

| # | Phase | Who | Produces | |---|-------|-----|----------| | 0 | AMPLIFY | 1–2 researchers (Haiku/web; or folded inline in Heavy) + 1 amplifier | Research what best-in-class looks like for this artifact, then rewrite the thin prompt into an ambitious spec (concrete targets that exceed the ask) and an ambition rubric — the gradeable quality bar, including the invisible dimensions (feel, polish, juice, sensory completeness, "exceeds expectations"). → spec.md + rubric. This rubric is the quality definition the audit track structurally lacks. | | 1 | EXPLORE (optional; high-value/open design space) | 2–N explorers + 1 taste-judge | N diverse whole-artifact direction sketches (concepts, not full builds); a taste-judge picks/merges the strongest. Fan-out used for divergent ideation, never for splitting the build. Skip for small tasks. | | 2 | BUILD | one deep builder, owns the WHOLE artifact | The complete artifact built against the spec. Do not fragment a holistic artifact into file-scoped items — one mind holds the whole thing and tunes its coherence. Give it real depth/budget. | | 3 | PLAYTEST (loop) | playtester / ambition critic (run + render) | Actually run/open/screenshot/drive the artifact, then critique feel and ambition — unmuzzled: it is required to say "this is flat/boring/unpolished, go further" and name the weakest rubric dimensions. Builder polishes those. Loop play→critique→polish until the bar is met or budget. | | 4 | JUDGE | independent judge panel (×N) | N independent judges score the final artifact against the ambition rubric (self-scores inflate — in the experiment a builder self-scored 0.84, the panel said 0.94). PASS if overall ≥ bar (default 0.8). | | 5 | REPORT | reporter | Artifact path + rubric scorecard, what was built, residual gaps, next polish ideas, anything to escalate. |

Creative-track spine (these replace fragmentation/machine-check with quality discipline):

1. Raise the bar before building. Amplify the thin prompt into an ambitious spec + a rubric that exceeds the

literal ask. A thin prompt → a thin result; the whole win is in the bar.

1. One deep owner for a holistic artifact. Never split it by file/feature across implementers — quality is

emergent and needs a single coherent vision. (Fan-out only for AMPLIFY research, EXPLORE ideation, JUDGE panel.)

1. Live-playtest, don't just read. Run/render the artifact and judge the experience; loop polish on the

weakest rubric dimensions. "It builds" is not "it's good."

1. Unmuzzle the critic. The ambition critic must push for "more / better / beyond a clone" — the opposite of

the audit critic, which is constrained to correctness gaps only.

1. Grade with an independent panel, not a self-score. Trust the panel's number, not the builder's.
2. Escalate when the ambition bar can't be reached within budget, or no rubric can be defined.

Convergence: loop while judge overall enforces them.

Escalate to the user (surface state, never silently stop) when:

• consensus not reached after the round cap;
• an item hits its iteration cap with the verifier still FAIL;
• the global budget/capacity is reached;
• a required check cannot be defined or run (no verifiable signal exists);
• a derived cross-component invariant cannot be expressed as a runnable execution check (no integration/solvability signal);
• two consecutive failed corrections on the same item — stop polluting context; restart that item with a sharper prompt (Lite: spawn a fresh subagent; or /clear and re-enter).

Gate strictness: pass@k (one of k runs passes) for exploratory items; pass^k (all k pass) for reliability-critical ones. Default pass@1; raise for high-stakes items.

Creative-track stopping (the caps above are audit-track; the creative track converges on quality, not checks):

• LOOP while: the judge panel's overall `"

Add an item WITH its mandatory machine-readable check

python ${CLAUDESKILLDIR}/scripts/board.py add-item --id I1 --title "..." --check "pytest tests/test_x.py" --scope src/x.py

Move an item through phases / record results

python ${CLAUDESKILLDIR}/scripts/board.py set --id I1 --status implementing python ${CLAUDESKILLDIR}/scripts/board.py set --id I1 --status passed --commit --verdict PASS --note "verifier ran full suite" python ${CLAUDESKILLDIR}/scripts/board.py bump --id I1 # +1 iteration (also checks the cap)

Decide what to do next

python ${CLAUDESKILLDIR}/scripts/board.py next # next actionable item (JSON), or null python ${CLAUDESKILLDIR}/scripts/board.py guard --id I1 # CONTINUE | ESCALATE: python ${CLAUDESKILLDIR}/scripts/board.py converged # DONE | OPEN: | ESCALATE: python ${CLAUDESKILLDIR}/scripts/board.py show # human-readable board

`board.json` is the durable memory: status, iteration counts, `last_commit`, verdicts, and **lightweight
references** (file paths, check commands) — not embedded file contents (resolve those just-in-time with Read/Grep).
It survives compaction and session restarts; re-read it to re-orient. Schema: `scripts/board.schema.json`.

---

## 5. Per-loop checklist (copy and tick)

• [ ] Read .loop-board/board.json + git log to load state
• [ ] Pick next item: board.py next (none → run converged)
• [ ] AUDIT: spawn 2–N auditors with DISTINCT lenses (reference/roles.md). Collect distilled findings.
• [ ] DEBATE→CONSENSUS: reconciler merges to one plan, or lists unresolved conflicts → escalate.
• [ ] Freeze plan.md. board.py set --id --status planning
• [ ] IMPLEMENT one item, clean commit. Never touch the check. board.py set --status implementing
• [ ] CRITIQUE: refutation-first critic (no Write). VERIFY: blackbox verifier runs the FULL check + a negative case.
• [ ] board.py bump --id ; board.py guard --id (ESCALATE? surface to user)
• [ ] Record verdict. board.py set --id --status passed|failed --verdict PASS|FAIL --commit
• [ ] INTEGRATION: run the cross-component invariant item(s) — the execution/solvability oracle on the ASSEMBLED whole (spawn→goal solvable / every required action makeable) — before declaring done.
• [ ] REPORT: rubric judge (0–1 per criterion + PASS/FAIL) → update report.md
• [ ] board.py converged → DONE (final report) | OPEN (loop) | ESCALATE (ask user)

---

## 5b. Per-loop run — CREATIVE track (Lite mode, copy and tick)

The creative track has **no `board.py`** — hold state in `spec.md` + your context. Spawn the roles in `reference/roles.md §10–13`
(or the `loop-board-{amplifier,builder,playtester,judge}` agents). Full method: `reference/creative.md`.

• [ ] AMPLIFY: spawn 1 amplifier (+ optional cheap researchers / deep-research skill). It (a) harvests best-in-class

web references, (b) inventories reusable tools/skills/MCPs (Figma, Playwright/screenshots, domain skills), (c) writes spec.md, (d) defines the ambition rubric + bar (default 0.8). → write spec.md

• [ ] EXPLORE (optional, high-value): spawn 2–N explorers for divergent whole-artifact directions; 1 taste-judge

picks/merges. Skip for small tasks. (Fan-out for ideation ONLY — never to split the build.)

• [ ] BUILD: spawn ONE deep builder that owns the WHOLE artifact (do NOT fragment). Give it spec + rubric +

capability plan. It self-playtests before handing off.

• [ ] FUNCTIONAL GATE (hard): run a solvability oracle (roles §6b) — automated playthrough OR reachability

invariant — the artifact MUST be completable end-to-end. UNCLEARABLE → back to BUILD before any feel work.

• [ ] PLAYTEST loop: spawn the playtester/ambition critic — it RUNS/renders/screenshots the artifact (use a

Playwright/screenshots skill if present) and names the 2–3 weakest rubric dimensions. If it proposes an improvement → builder polishes those → repeat. Stop when it proposes nothing material or budget floor hit.

• [ ] JUDGE: spawn N independent judges (default 3) → score vs the rubric → average. Trust the panel, not the

self-score. PASS if avg ≥ bar.

• [ ] Converged? (panel ≥ bar AND a fresh playtest finds nothing material) → REPORT. Else loop PLAYTEST→polish

while budget remains. Bar unreachable in budget / no rubric / can't run-to-test → ESCALATE with the best artifact + the gap (§3 "Creative-track stopping").

• [ ] REPORT: artifact path + rubric scorecard + signature element + residual gaps + next polish ideas.

---

## 6. Heavy mode (Workflow tool)

If your harness has the **Workflow** tool, run the board as a deterministic, parallel orchestration:

Workflow({ scriptPath: "${CLAUDESKILLDIR}/workflows/loop-board.workflow.js", args: { problem: "", rounds: 3, gate: "pass@1" } })

The script fans auditors out in parallel, reconciles to consensus, pipelines implement→verify per item, runs a
rubric-judge report, and loops until convergence or budget — h

…

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [drgeld](https://github.com/drgeld)
- **Source:** [drgeld/loop-board](https://github.com/drgeld/loop-board)
- **License:** MIT

Install and usage instructions live in the source repository linked above.