loop-engineer

Make a repo reproducibly buildable and testable by a cold agent — the first step of preparing a harness for loop engineering. Use when "make this repo agent-ready / loop-ready", a fresh checkout doesn't build or test cleanly, or setting up CLAUDE.md and documented build/test commands before automating. A loop on a repo that doesn't build from a clean clone will "fix" phantom failures.

The completeness checklist of parts every agent harness needs — use to make a harness spec whole before building it, or to choose the right nodes in a visual tool. Use when designing/reviewing a harness, steering an enquiry, or asking "what am I missing?". Covers roles & boundaries, loop/stage structure, state & memory, adapters, validation gates, artifact contracts, failure recovery, and observability. A spec missing a part is a hole an agent fills by guessing.

Run a structured AI enquiry that turns a high-level goal into a complete, importable harness spec — no code. Use when the user wants the AI to act as a harness co-designer, "ask me what you need and generate the config/blueprint", or to design a Claude/Antigravity loop harness through conversation. Produces an NLAH doc plus visual-tool or generator instructions. The Q&A replaces manual config writing.

Scaffold a complete agent harness via a browser studio using only selections (dropdowns/forms) — no code, no install for the build step. Use when the user wants to "generate a harness fast", scaffold a branded CLI harness with built-in loops/memory/MCP, or use the MetaHarness studio (ruvnet/agent-harness-generator) for Claude Code / OpenClaw. Covers the selection workflow, what the generated harness contains, and verifying it before trusting it.

Bound a loop's cost, blast radius, and permissions before it runs unattended — the safety step of preparing a harness for loop engineering. Use when setting token/iteration/time budgets, a kill switch, scoping agent write/tool permissions, handling secrets, or "make sure the loop can't run away or do damage". An unattended loop with no budget and broad permissions is the failure mode, not an edge case.

Composite meta-skill for preparing the harness — the environment a single agent runs inside — so a loop can run on top of it safely. Use when the user wants to "set up the harness", "make this repo loop-ready / agent-ready", "prepare for autonomous agents", or before standing up a loop on an unprepared repo. Orchestrates harness-bootstrap, harness-project-skills, harness-verification, and harness-guardrails. The loop-engineer skill builds the loop; this skill builds the floor it stands on.

Capture project intent as skills so a cold agent reads it instead of guessing — the knowledge step of preparing a harness for loop engineering. Use when writing project conventions, build/workflow knowledge, or "stop re-explaining the project every session", before standing up a loop. A cold agent fills any gap in your intent with a confident guess; skills are that intent written on the outside, read every run.

Turn "done" into a command that returns pass/fail instead of a claim — the verification step of preparing a harness for loop engineering. Use when defining a loop's stop condition, /goal success criteria, what the verifier subagent checks against, or "make done mean something" before automating. You cannot let a loop decide done until done is a script.

The heartbeat of a loop — schedule discovery and triage so the loop runs on a cadence instead of you re-running it. Use when setting up recurring agent runs, "run this every morning/N minutes", cron tasks, in-session /loop or /goal, lifecycle hooks, or GitHub Actions for autonomous agents. Covers choosing in-session vs out-of-session triggers, cadence, and routing findings to a triage inbox.

The reach of a loop — connectors and plugins (built on MCP) that let the loop act in the tools you already use instead of only seeing the filesystem. Use when a loop needs to read/write an issue tracker, query a database, hit a staging API, post to Slack, open PRs, or bundle/share a setup as a plugin. Covers when to add a connector, treating each as a failure surface, idempotency, and least-privilege.

Composite meta-skill for designing a self-prompting agent loop instead of prompting the agent turn-by-turn. Use when the user wants to "build a loop", "design a loop", "set up an autonomous/recurring agent workflow", "stop prompting and start looping", or automate discovery → fix → review → record → repeat. Orchestrates the five building blocks (automation, worktrees, memory, subagents, connectors) plus a durable state file, and refuses to ship a loop that has no verifier or no cost ceiling.

The spine of a loop — durable on-disk state that survives between runs so the loop resumes instead of restarting. Use when setting up a loop's state/progress file, a triage board, or "remember what's done and what's next" across runs. The model forgets everything between runs; the repo doesn't. Covers what to store, the state-file schema, and update discipline.

Specify a loop's behavior precisely — type, trigger, body, and exit predicate — so a visual tool, generator, or runtime implements the loop you actually meant. Use when describing reflection loops, eval/verifier loops, learning loops, or meta-optimization loops for a harness, or when a "loop" in a spec is vague. Every loop must have an exit condition and a budget, or it is an infinite bill.

The maker/checker split inside a loop — keep the agent that writes the code separate from the agent that checks it. Use when designing subagents/agent teams for a loop, defining .claude/agents, "one explores, one implements, one verifies", adversarial review, or deciding the loop's stop condition. The verifier is the only reason you can walk away. Covers role split, model/effort choice, agent file shape, and token cost.

Isolation for parallel agents in a loop — use git worktrees so two agents working at once don't clobber each other's files. Use when a loop fans out to multiple agents/subagents, when running parallel tasks on one repo, "run these in parallel without conflicts", or setting isolation:worktree on subagents. Covers when to isolate, creation/cleanup, and the human review ceiling.

Write a harness as a Natural-Language Agent Harness (NLAH) — an editable plain-text document that describes run-level harness policy instead of hard-coded controller logic. Use when capturing harness/loop logic declaratively, "write the config as natural language", making control logic portable/inspectable, or producing a spec to feed a visual tool or runtime. Based on the NLAH paper (arXiv:2603.25723). Covers the document sections and the five things a runtime interprets.

Build a harness and its loops on a drag-and-drop node canvas (Langflow or Dify) — no code, configure everything via side panels and dropdowns. Use when the user wants to construct harness logic visually, "build it by dragging boxes", model loops/verification gates/memory as nodes and edges, or realize an NLAH spec in a visual tool. Covers node-to-component mapping, building loops as back-edges, and the dry-run discipline.