Parallel Codex Legion With Integration Judge

Split a large mechanical job into 2–5 independent Codex lanes, each isolated in its own worktree with a frozen acceptance bar and binding judge, then block the final merge behind a full integration judge.

prompt
→ Claude Code
Dispatch a parallel Codex legion for a large mechanical job. Split the work into 2–5 genuinely independent lanes, one lane per piece. First announce a muster table with: - each lane, - the exact files that lane may touch, - the frozen acceptance check for that lane. Do not proceed until I approve the split. Before dispatch, the orchestrator must freeze and record each lane’s acceptance bar. After dispatch, each worker treats `.git` as read-only. Each lane must run in its own git worktree with: - a frozen acceptance bar recorded before code changes, - a strictly disjoint may-touch manifest, - its own sandbox, - read-only `.git` state for the worker. If any lane’s file footprint overlaps another lane, refuse the split and serialize the work instead. When a lane finishes, run a fresh-context judge against that lane’s frozen bar. The judge must return binding PASS or FAIL. Allow at most 2 retries per lane; stop after 2 failed attempts, then escalate loudly. Merge lanes in a fixed order. After merging, require a mandatory integration judge that reruns the full test suite across the combined result. Do not commit or merge unless the integration judge returns PASS. Hard cap: 5 workers. If there are more than 5 pieces, run later waves. Never merge without the integration judge.
claude-code

Implementation note

Praetor Legion Mode: parallelizes a large mechanical job across 2–5 disjoint Codex lanes. Same core laws as single dispatch: acceptance bar frozen before dispatch, binding fresh-context judge, max 2 retries before loud takeover. Legion-only laws: strictly disjoint may-touch manifests, overlap forces serialization, ordered merge, and mandatory integration judge across the combined result. The orchestrator may record/freeze bars in git before dispatch; workers keep .git read-only. Worker count is derived from the split, capped at 5, with overflow handled in later waves.

Source: luoxianzi/praetor ↗graded A · 100/100 — how grades work →

More automation loops

Ship PRD stories via dual-agent loop

Loop/ralphGitHubA

Ralph runs a generator and evaluator in tandem until all user stories pass acceptance criteria and browser tests.

prompt
→ Claude Code
# Ralph Harness — Agent Instructions ## Overview Ralph Harness is an autonomous AI agent loop that runs AI coding tools (Amp or Claude Code) repeatedly until all PRD items are complete. Each iteration is a fresh instance with clean context. Ralph supports two modes: | Mode | Architecture | When to use | |------|-------------|-------------| | simple | Single agent (self-implement, self-check) | Quick tasks, backend-only stories, well-defined small changes | | harness | Generator + Evaluator (dual-agent with contract) | UI-heavy features, complex stories, when quality is critical | ## Architecture: Harness Mode ralph.sh orchestrator │ ├── Planner (prd.json) │ Defines user stories, acceptance criteria, dependencies │ ├── Generator (generator-prompt.md) │ Drafts sprint contracts → Implements stories → Fixes based on feedback │ └── Evaluator (evaluator-prompt.md) Reviews contracts → Signs/locks → Tests in browser → Scores → Writes feedback ### Per-Story Flow 1. Contract Negotiation : Generator drafts contract.json → Evaluator reviews → Back-and-forth until Evaluator signs → Contract locked (immutable) 2. Build : Generator reads Hard cap: stop after 30 iterations even if PRD items remain.
automationhigh risk

Ship production-grade apps autonomously

Loop/ralphGitHubB

Hand an idea to Claude Code; it authors specs, designs, builds, tests, secures, and ships until enterprise done or budget exhausted.

prompt
→ Claude Code
# dare-to-be-stupid — Design (v2, refined) > A Claude Code plugin. One command, /dare , hands an idea or PRD to an autonomous > loop that authors specs, designs, builds, tests, secures, ships, fixes, and iterates > until the app passes an enterprise-production definition of done — or the budget dies. > > Named for the Weird Al song. The joke is that it runs the Ralph Loop on purpose , > with --dangerously-skip-permissions , and narrates the whole thing in the voice of an > '80s Junkion. Pre-production only. Never points at anything with users. This is v2. It keeps the strong core of the original spec (external reviewer, ratchet, guard hook, Junkion style) and adds the three phases the original left thin relative to the actual goal: PRD authoring, a design phase, and a real enterprise DoD including security, CI, docs/observability, and design quality (with quality plugins auto-installed). --- ## 0. The premise, in one paragraph The User builds documentation-first: spec → system docs → API contracts → CLAUDE.md → code. dare-to-be-stupid is the deliberate inverse, packaged as comedy that also solves two real engineering problems. It is a real build , not a joke ar

Set and ship autonomous goals

Loop/goalGitHubB

Run a persistent goal autonomously until completion, routing each task to the optimal model for cost and capability.

prompt
→ Claude Code
/goal <objective · /loop <task | Set a persistent goal · run autonomously until complete (≤25 turns) |
automationlow risk