By tyroneross
Multi-phase build orchestration with native debugging: assess, plan, execute, review, iterate. Plan-verify gate on Phase 2. Optional UI design gates. Native debug-loop, debugging-memory, and logging-tracer skills provide root-cause investigation without a bundled MCP server. Orchestrator owns when-to-fire; bundled skills own procedural detail; the logging-tracer skill includes an optional Coding Debugger escalation hop to the standalone supporting plugin for extended capability.
Review the cross-repo proposal backlog interactively. Scans every registered repo's .build-loop/proposals/ (incl. enforce-from-retro/ + self-review) plus ~/.assistant/proposals/, then walks each new item to apply / reject / defer. Never auto-applies.
The one build-loop command. Describe anything in plain language — build, fix, debug, optimize, research, test, root-cause, retrospective, plan, PRD — and it routes automatically. You never pick a mode.
The Frontier (Fable) standing role that AUTHORS and RE-PLANS the Phase 2 plan synthesis. Generating a plan is harder than evaluating one, so the deepest reasoning pays here. The Advisor frames the goal, decomposes the work, builds the dependency graph, MECE-partitions file ownership, and — on a diagnosed *planning miss* — re-plans and issues CORRECTED INSTRUCTIONS (a diff vs the prior plan + the failure evidence), not just a "no". Its output is still verified by the existing Frontier critics (plan-critic, scope-auditor); the Advisor never self-certifies. v1 scope is Phase 2 plan synthesis only — the take-over-execution rung (executing a chunk directly) is v2. <example> Context: Phase 2 of a high-stakes build (riskSurfaceChange + synthesisDensity 7). The orchestrator wants the plan authored at Frontier, not inline on Opus. user: "Author the Phase 2 plan for the auth-refactor build at frontier tier" assistant: "Dispatching the advisor agent. It reads intent.md + goal.md + the architecture baseline, walks the spec-writing checklist, and writes the plan to docs/plans/. plan-critic + scope-auditor then verify it before any implementer runs." </example> <example> Context: Iterate attempt 3 — the same chunk keeps failing and the failure evidence points at the plan itself (wrong decomposition), not a hard execution task. user: "The plan no longer fits — re-plan chunk 4 with the failure evidence" assistant: "Dispatching the advisor agent in re-plan mode. It reads the failure evidence + the diff vs the current plan, diagnoses planning-miss vs execution-miss, and (on planning-miss) emits corrected instructions: a diff against the prior plan plus the evidence that justifies the change." </example>
Advisory alignment judge for autonomous-iterate-loop queue items (plan §14.4 A). For each candidate item drained from `.build-loop/ux-queue/` + `.build-loop/issues/` + `.build-loop/proposals/`, reads the build's stated intent (`intent.md`, `goal.md`, canonical build-loop-memory constitution context, optional repo `.build-loop/prd.md`) plus the item body and returns a structured verdict (`aligned | misaligned | uncertain`) with cited anchors. Never blocks: the orchestrator routes verdicts (aligned → Phase 2, misaligned → `followup/`, uncertain → notify + continue). High-frequency call — once per queue item — so this agent is Sonnet, not Opus. <example> Context: Autonomous loop has just drained a fresh ux-queue/uxq-0042.md from Phase 4 Gate 7. About to decide whether to schedule it for Phase 2. user: "Run alignment-checker on uxq-0042" assistant: "I'll dispatch alignment-checker with the queue item body + the intent/goal/constitution anchors. Verdict + matched_anchors + violated_non_goals returned as JSON; orchestrator routes from there." </example> <example> Context: A `.build-loop/proposals/swap-router.md` proposal landed mid-run suggesting a wholesale architecture change that contradicts intent.md's "incremental migration only" non-goal. user: "Should we execute swap-router?" assistant: "alignment-checker reads intent.md non-goals, matches 'incremental migration only' against the proposal's 'wholesale rewrite' framing, returns verdict: misaligned with violated_non_goals populated. Orchestrator moves it to followup/." </example>
Use this agent when the debugging symptom involves API endpoints, REST/GraphQL errors, request/response issues, authentication, rate limiting, or server-side route handlers. Examples - "500 error", "endpoint not found", "auth failed", "CORS error".
Read-only architecture analyst. Dispatched by build-loop orchestrator with a task type ('baseline', 'chunk-impact', 'review-rules', 'iterate-subgraph', 'learn-sync'). Decides native engine vs NavGator escalation per task. Returns ≤500-word structured JSON envelope. Owns architecture-related side effects (violation capture, lessons sync).
Use this agent when debugging requires multi-domain analysis, when the symptom is unclear about which domain is affected, or when you need to coordinate parallel assessments across database, frontend, API, and performance domains.
Use when coordinating build-loop with peer coding agents, checking Rally Point presence/inbox state, posting handoffs or feedback, validating the embedded Rally Point boundary, or changing the future agent-rally-point spin-out surface.
Use when listening for Rally Point changes, wiring coordination watchers, debugging watch-loop behavior, or changing the future agent-rally-watcher spin-out surface.
Use when Phase 1 Assess or Phase 5 Iterate detects a new API dependency, API config fails, or the user asks to "register this API" or "check the API registry". Consults api-registry plugin; degrades gracefully if plugin is absent. NOT for PRD strategic grounding (use `prd-bridge`) or UI verification (use `ibr-bridge`).
Apply the canonical four-layer Apache-2.0 attribution model (NOTICE, per-file SPDX, REUSE.toml, canary markers) to a repo. Triggers on 'stamp attribution', 'add NOTICE', 'license headers', 'attribution layers', a newly public repo, or a repo with .git but no NOTICE / no REUSE.toml / no CONTRIBUTING.md. Build-loop Phase 1 Assess can advise running this when shipped source files lack SPDX headers.
Use when wiring auth to a new project, debugging login errors (redirect_uri_mismatch, invalid_grant, session callback, refresh_token), or adding social/magic link flows. Covers Better Auth (Drizzle/Neon), Supabase Auth (SSR), Google OAuth, and Resend transactional email.
Executes bash commands
Hook triggers when Bash tool is used
Modifies files
Hook triggers on file write and edit operations
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
Executables (bin/) — files in this plugin's bin/directory are added to the Bash tool's PATH while the plugin is enabled.
Uses power tools
Uses Bash, Write, or Edit tools
Uses power tools
Uses Bash, Write, or Edit tools
A portable, multi-phase build loop for AI coding agents. It gives Claude Code, Codex, and any AGENTS.md-aware tool the same disciplined operating loop: assess, plan, execute, review, iterate, then learn.
Summary: build-loop helps AI coding agents and the developers who run them ship multi-step code changes by running every change through a planned, reviewed, verified loop. Best for non-trivial features, refactors, migrations, and bug hunts across more than one file. Skip it for one-line edits, pure Q&A, or status checks.
Hand an agent a multi-step task and it tends to dive straight into edits, with no plan, no scope boundary, and no independent check that the result matches the goal. The failures compound: wrong assumptions ride into code, fixes patch symptoms, and "it compiles" gets reported as "it works."
build-loop replaces that with a structured loop every change runs through: it assesses live repo state and memory, plans with explicit file ownership and pass/fail criteria, executes within scope, then runs an adversarial review (a critic, a fact-checker, a mock-data scanner) before iterating to green. The differentiator is portability and verification: the same loop runs across Claude Code, Codex, and host-neutral AGENTS.md tools, it is multi-model by tier (a frontier model plans and judges, a coding model executes), and no completion claim ships without a verification step behind it.
flowchart LR
A[Assess] --> P[Plan]
P --> E[Execute]
E --> R[Review]
R -->|fail| I[Iterate]
I --> R
R -->|pass| L[Learn]
subgraph Review
direction LR
R1[Critic] --> R2[Validate] --> R3[Optimize] --> R4[Fact-Check] --> R5[Simplify] --> R6[Auto-Resolve] --> R7[Report]
end
Assess → Plan → Execute → Review → Iterate (5x max) → Learn (always emits an outcome). Review runs seven ordered sub-steps; Iterate loops back to Review on failure.
For the living, auto-generated diagram of how the loop actually wires up in this repo, covering every phase, gate, agent, skill, and script and regenerated from source so it cannot drift, open docs/build-loop-flow-mockup.html in a browser. Format spec and drift gate: architecture/README.md.
Install the plugin from the marketplace. In Claude Code:
/plugin marketplace add tyroneross/build-loop
/plugin install build-loop@build-loop
In Codex, add the same git marketplace with /plugin marketplace add and install build-loop. Then restart the host so it loads the plugin.
build-loop has no runtime CLI — the loop runs inside your agent host. The plugin ships the skills, agents, and hooks it drives; there is no build-loop binary to run. After restart, in a session inside your project, hand the loop a task:
/build-loop:run add billing settings with tests
What you observe: the agent prints a short status line per phase ([Phase 1: Assess], [Phase 2: Plan], [Phase 3: Execute], then each Review sub-step), then ends with a scorecard marking every acceptance criterion ✅ / ⚠️ / ❓. Completed, verified work is committed automatically; the only human-confirmation gates are production push, irreversible delete, and major user-impacting decisions.
You do not pick a mode. /build-loop:run auto-routes build, fix, refactor, optimize, research, and test requests to the right path.
The plugin installs and updates through the host's native marketplace — no npm step, no global install, no sudo:
/plugin marketplace add tyroneross/build-loop # Claude Code or Codex
/plugin install build-loop@build-loop
The host owns install, versioning, and /plugin update. Restart the host to load a freshly installed or updated plugin. On first session build-loop seeds a memory scaffold at ~/.build-loop-memory (constitution, MEMORY.md, indexes).
The legacy build-loop-install binary syncs the same files into the host caches manually. Prefer the marketplace above; use this only to pin an exact version or on a host without marketplace support.
npm install -g @tyroneross/[email protected]
build-loop-install --host all
npx claudepluginhub tyroneross/build-loop --plugin build-loopBarbara Minto's Pyramid Principle for short-form, long-form, presentations, and audits
Coding Debugger for coding agents with debugging memory, verdict-based retrieval, pattern extraction, root-cause workflows, and parallel domain assessment.
End-to-end design tool for AI coding agents — guided UI builds, web/iOS/macOS guidance, visual checks, mockup matching, interaction testing, native scanning, native layout-fill / gap analysis
Capture screenshots, videos, and polished demo clips — spotlight focus, lower-third captions, and a tagged library — across web, macOS, and iOS
Local doc-content cache + authoritative API source registry with a 7-day freshness contract
Comprehensive skill pack with 66 specialized skills for full-stack developers: 12 language experts (Python, TypeScript, Go, Rust, C++, Swift, Kotlin, C#, PHP, Java, SQL, JavaScript), 10 backend frameworks, 6 frontend/mobile, plus infrastructure, DevOps, security, and testing. Features progressive disclosure architecture for 50% faster loading.
Consult multiple AI coding agents (Gemini, OpenAI, Grok, Perplexity, plus codex, antigravity, and grok CLIs when installed) to get diverse perspectives on coding problems
Develop, test, build, and deploy Godot 4.x games with Claude Code. Includes GdUnit4 testing, web/desktop exports, CI/CD pipelines, and deployment to Vercel/GitHub Pages/itch.io.
Production-grade engineering skills for AI coding agents — covering the full software development lifecycle from spec to ship.
Lazy senior dev mode. Forces the simplest, shortest solution that actually works: YAGNI, stdlib first, no unrequested abstractions.
Comprehensive PR review agents specializing in comments, tests, error handling, type design, code quality, and code simplification