Loop Engineering 101

The complete guide to ship code while you sleep

📌1. What is a Loop?

A loop is an agent that works, checks, and retries by itself—without you prompting each step.

📌Key Steps in a Loop:

Discovery: Find what it needs to know.
Planning: Break the goal into clear steps.
Execution: Do the work.
Verification: Check the result against the goal.
Iteration: Fix the gaps and run again.

📌Example:

Reproduce the bug, write a failing test, fix the code, rerun the suite, repeat until it’s green. You write the cycle once and walk away.

📌Key Takeaway:

A task is loop-ready when:

It repeats often enough to be worth wiring.
It has a definition of done you can check automatically.
A wrong attempt is cheap to throw away.

📌2. Open vs Closed Loops

📌Open Loops = Exploratory

Agents freely explore and discover.
High token usage (50K–2M+).
Can drift off-target and produce AI slop.
Risky as a starting point.

📌Closed Loops = Bounded

Clear goal, defined steps, validation checks.
Agents operate within constraints.
Predictable, efficient, and easier to control.
Better for most teams.

Key Takeaway: The closed loop focuses on what matters most. It improves with each pass, sharpening the result over time.

📌3. The Anatomy of a Loop

A loop’s anatomy is six parts you wire once:

Triggers: What starts the loop.
Isolates: What narrows the scope.
Informs: What provides context.
Connects: What links agents.
Builds: What creates the result.
Remembers: What stores the lessons learned.

📌The 6 Building Blocks of Every Good Loop:

Automations

The hardware, runtimes, and agents.

Worktrees

Parallel agents, safe collisions.

Skills

Project knowledge, active recall, every loop.

Plugs & Connectors

APIs, PRs, tickets, Slack.

Subagents

Split the builder and reviewer into two agents.

Memory

Links the conversation; the loop never forgets.

📌Key Takeaway:

Don’t keep rules and memory only in the chat.
Don’t trigger every run by hand.
Don’t wire all six parts before you need them.

📌4. Single Agent vs Fleet

📌Single-Agent Loop:

One agent improves its own work by repeating the cycle until the result is good.
Simple, cheap, and enough for most tasks.

📌Fleet Loop:

Multiple specialized agents work together under an orchestrator.
Use it when one agent isn’t enough for the job.

📌5. Loop in Practice

📌Implementation:

A loop is implemented as:

The goal and rules loaded from disk.
The maker, checker, gate, and one line where the loop turns a failure into a new rule.
# Example of loop implementation  
rule = load("RULES.md")  
for review in reviews:  
    if not maker.run(goal, rule):  
        checker.run(goal, review, tests)  
        gate.append(review.reason)

📌Key Takeaway:

Automate the reproduce-fix-verify grind, but keep the merge yours. A good loop proposes the fix and pings you. It never ships on its own.

📌6. The Quality Gate

A loop without a gate produces slop faster. The gate is the check your work must pass before it ships and is the only thing keeping the loop well-functioning.

📌Build the Gate:

Compiler
Type system
Integration tests
Mutation tests
Property-based tests
Linters, analyzers, and CI

📌7. Self-Learning Loop

📌Key Principle:

A loop only improves if it can carry its lessons forward and be held to them.

📌Rules for RULES.md:

Add no rule whenever the agent repeats a mistake.
Don’t let it auto-repair the same issue twice.
Don’t let the loop auto-fill with noise.

📌Key Takeaway:

Your job is not only designing loops that prompt your agents. It’s designing loops that learn from experience.

📌📖 Real-Time Story

Imagine Alice, a software engineer, debugging a recurring issue in her team’s CI pipeline. She sets up a closed loop:

Trigger: The loop starts whenever a test fails.
Isolate: It narrows down the failure to the specific module.
Inform: It pulls logs and error messages for context.
Connect: It links the failure to the relevant GitHub issue.
Build: It proposes a fix and reruns the tests.
Remember: It stores the fix in RULES.md for future reference.

Over time, Alice’s loop evolves into a self-learning loop, reducing repetitive failures and freeing her team to focus on new features.

FAILURE
↷
ISOLATE
↷
INFORM
↷
CONNECT
↷
BUILD
↷
REMEMBER

Alice’s loop becomes the backbone of her team’s productivity, shipping reliable code while they sleep.