looploop

looploop

XP pair-programming plugin for Claude Code. PRD-driven TDD with iterative implementation.

You define the skeleton. AI places the organs.

When to Use looploop

looploop shines when correctness is verifiable by tests. It struggles when correctness depends on browser behavior that unit tests can't simulate.

Good case

Idea: Domain-logic-heavy app where correctness is verifiable by tests — calculations, rules, state transitions, edge cases.

Prompt:

Build a personal budget tracker.

Stack: React + TypeScript + Vite + Tailwind + Zustand. Persist to localStorage.

Domain rules:

• Transactions have: amount (in cents), category, date, type (income | expense)
• Each category has a monthly spending limit
• Remaining = limit − expenses in current calendar month for that category
• Over budget when remaining < 0
• Savings rate = (income − expenses) / income × 100, clamped to [-100, 100]. If income is 0, rate is 0
• Burn rate = total expenses ÷ days elapsed this month (min 1 day)
• Projected spend = burn rate × total days in month
• At-risk category: projected spend > 80% of limit, even if not yet over budget
• All values stored as integer cents to avoid floating-point errors

UI: dashboard with totals and savings rate, category list with status (ok / at-risk / over-budget), transaction list filterable by category and month, forms to add transactions and set category limits.

Why it works: Every business rule maps directly to a unit test. The test-writer encodes the edge cases (income = 0, cents arithmetic, at-risk threshold) before any code is written. The implementer can't skip them.

---

Bad case

Idea: Visually interactive app where correctness depends on browser behavior that unit tests can't easily simulate.

Prompt:

Build a Kanban board with drag and drop between columns.

Stack: React + TypeScript + Vite + Tailwind + @dnd-kit. Persist to localStorage.

• 3 columns: Backlog, In Progress, Done
• Cards have title, priority, and description
• Drag cards between columns and reorder within columns
• Animations on add, delete, and drag
• Empty column placeholder
• Dark glassmorphism design

Why it underperforms: Drag-and-drop correctness lives in browser pointer events and droppable registration — things jsdom can't simulate. The test-writer will test what it can (store logic, renders), but can't write a test that catches a missing useDroppable on a column. The implementer passes all tests and ships broken drop behavior. A plain prompt that has seen hundreds of @dnd-kit examples outperforms here.

---

Rule of thumb: if the most important bugs would be caught by expect(result).toBe(x), looploop wins. If they'd only be caught by a human clicking around in a browser, it won't.

Requirements for team mode

Agent teams are experimental and disabled by default. Enable them by adding CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS to your settings.json or environment. Agent teams have known limitations around session resumption, task coordination, and shutdown behavior.

Be aware costs scale with the team, so use it sparingly.

Install

Inside Claude Code, run:

# Add the marketplace (one-time)
/plugin marketplace add Emerson1337/erms-arsenal

# Install looploop
/plugin install looploop@erms-arsenal

Or install manually:

# Clone directly
git clone [email protected]:Emerson1337/looploop.git ~/.claude/plugins/looploop

Usage

Full Mode — /looploop

For new features and substantial work. Runs the complete pipeline:

PRD → TDD → Implement → Iterate

/looploop Build a REST API for user management with JWT auth

What happens:

1. Detects your stack and test framework
2. Generates a technical PRD (auto-reviewed)
3. Writes tests first — targeting 100% coverage (2 iterations default)
4. Implements code to pass tests (3 iterations default)
5. Presents final summary with results

Light Mode — /looploop-fix

For bugfixes, small features, and refactors. Skips PRD ceremony:

Understand → Test Guard → Implement → Verify

/looploop-fix Fix token expiry check that allows expired tokens through

What happens:

1. Identifies affected files
2. Finds existing tests, establishes baseline (writes missing tests if needed)
3. Makes the fix
4. Verifies no regressions, reports results

Review Mode — /looploop-review

Reviews uncommitted changes for test coverage gaps (targeting 100%) and PRD alignment:

Analyze → Review → Offer Fix

/looploop-review

What happens:

1. Collects all local changes (git diff)
2. Checks if changed code paths have test coverage
3. If a PRD exists, checks alignment with acceptance criteria
4. Presents a report with verdict (PASS / NEEDS TESTS / NEEDS REVIEW / NEEDS BOTH)
5. Offers to auto-write missing tests via coverage-guard