How to Build Sustainable Claude Code Workflows with Loop Engineering: A Complete Guide

Loop Engineering replaces manual prompt‑by‑prompt interaction by designing a system that repeatedly invokes Claude Code, lets the model generate its own prompts, self‑audit, and decide when the task is complete.

Evolution of AI workflow design

2024 focused on Prompt Engineering – crafting a single effective prompt. 2025 introduced Multi‑Agent Orchestration – splitting work among several agents. By mid‑2026 the community converged on Loop Engineering – making the entire workflow self‑sustaining.

Three loop forms

Single‑Agent Loop

A single agent iterates autonomously:

research → draft → compare to target → fix weak spots → repeat until standards are exceeded

This mirrors a person revising a draft until satisfied.

Fleet Loop (Multi‑Agent Loop)

An orchestrator breaks a large goal into fragments, assigns them to specialist agents, which may further delegate to sub‑agents, forming a discover → plan → execute → verify closed loop.

Single‑Agent Loop is "one person repeatedly revising a draft"; Fleet Loop is "a whole team running an end‑to‑end project".

Open‑loop vs Closed‑loop

Open‑loop : agents explore many paths freely; token consumption is very high; suited for exploratory tasks; high cost makes it impractical for most teams.

Closed‑loop : agents follow a human‑defined path; token usage is predictable; suited for execution tasks with clear goals and acceptance criteria; currently the production‑ready mode.

Design practice: start with Closed‑loop, then consider Open‑loop for exploration.

Theoretical foundations

ReAct (Reasoning + Action)

From Princeton‑Google research, ReAct interleaves thought, tool execution, observation, and further thought until a final answer.

Thought → Action (run tool) → Observation → Thought → … → Final Answer

In coding this maps to: understand goal → write code → run code → observe output/error → diagnose → fix → repeat.

Reflexion (Failure as fuel)

Reflexion extends ReAct by verbalising failures, storing the reflection, and using it in the next attempt.

Task execution → Failure → Natural‑language reflection → Store reflection → Use reflection in next attempt

In Loop Engineering the persistent files SKILL.md and progress.md implement Reflexion.

Claude Code built‑in loop commands

/loop

– time‑driven periodic repeat (e.g., poll every 5 min). /goal – goal‑driven, runs until a condition is met (e.g., fix all failing tests). Requires version v2.1.139 (2026‑05‑11).

Dynamic Workflows – AI writes its own workflow, splits into dozens‑to‑hundreds of sub‑agents. Triggered by the keyword ultracode. Requires version v2.1.154 (2026‑05‑28).

All three eliminate the manual "prompt → wait → prompt" cycle; starting with /goal is the least error‑prone.

Two‑layer loop structure

Inner Loop – self‑verification within a single task

Strong agents perform a full verify‑modify‑test cycle before declaring "Done".

❌ Weak Agent: modify file → "Done!"

✅ Strong Agent: modify file → write tests → run tests → discover boundary failure → fix → rerun → all green → "Done!"

Outer Loop – experience accumulation across sessions

Agents persist lessons in files so later sessions can skip previously encountered pitfalls.

Session 1: pagination logic fails → record "pagination best practices" in SKILL.md
Session 2: similar task → read SKILL.md → avoid the same pitfall

Scope: Inner Loop – single task; Outer Loop – across sessions.

Purpose: Inner Loop – improve task reliability; Outer Loop – continuous improvement.

State: Inner Loop – within context window; Outer Loop – persisted files (SKILL.md, progress.md).

Maturity: many agents already support Inner Loop; Outer Loop is rapidly evolving.

"5+1" engineering components (Addy Osmani)

① Automations – run the loop automatically (cron + bash). Must include a stop condition.

② Worktrees – isolate parallel agent workspaces using git worktree to avoid file clashes.

③ Skills – store project knowledge in .claude/skills/*.md so each round does not relearn the project.

④ Plugins – connect agents to real toolchains via MCP server configuration (e.g., GitHub, Slack).

⑤ Sub‑agents – separate generation and evaluation (Generator ↔ Evaluator pattern). Use only for high‑risk steps.

+⑥ Memory – persist state outside the conversation (e.g., progress.md, lessons.md) to prevent forgetting.

Automation example (loop pacemaker)

while true; do
  claude --print \
    --system-prompt "$(cat system_prompt.md)" \
    "$(cat task_prompt.md)" \
    >> output.log
  sleep 300 # every 5 min
 done

A stop condition must be added; otherwise the loop becomes a token‑eating black hole.

Worktree isolation example

git worktree add ../agent-1-workspace feature/auth-fix
git worktree add ../agent-2-workspace feature/api-refactor
# agents work on different branches → no file clashes

Skill file example (testing guidelines)

# Testing Guidelines
- Test framework: Vitest
- File naming: *.test.ts
- Mock library: MSW
- Coverage target: ≥ 80%
- Edge cases: always include boundary and error scenarios

Plugin configuration example (MCP server)

mcp_servers:
  github:
    command: "github-mcp-server"
    env:
      GITHUB_TOKEN: "${GITHUB_TOKEN}"
  slack:
    command: "slack-mcp-server"
    env:
      SLACK_BOT_TOKEN: "${SLACK_BOT_TOKEN}"

⚠️ Lock permission boundaries early. Agent access to GitHub does not imply it can force‑push to main.

Sub‑agent GAN‑style diagram

┌───────────┐   generate code   ┌───────────┐
│ Generator │ ──────────────→ │ Evaluator │
│ (generator)│                │ (evaluator)│
│           │ ←────────────── │           │
└───────────┘   feedback      └───────────┘
      ↑                     │
      │          provide plan│
      │          ┌───────────┐│
      └────→ │ Planner │ ←─────┘
               │ (planner) │  evaluate result
               └───────────┘

💡 Use Sub‑agent mode only for high‑risk steps; ordinary CRUD does not need this complexity.

Memory file example (progress.md)

## Completed Tasks
- [x] Refactor auth module (PR #142)
- [x] Add tests for API endpoints (PR #143)

## In Progress
- [ ] Database migration

## Lessons Learned
- PostgreSQL 16 changed JSON path syntax
- Test environment must provide Redis mock

The agent forgets, the repository doesn’t. — Addy Osmani

End‑to‑End practical example: Daily Issue auto‑triage loop

Step 1 – Define goal and stop conditions

Goal : automatically discover new GitHub Issues, attempt a fix, and open a PR.

Stop conditions : (a) all Issues processed → output DONE; (b) maximum retries reached (5 rounds).

Max iterations :

MAX_ITERATIONS=5

Step 2 – Directory layout

project/
├── .loop/
│   ├── progress.md   # Memory file
│   └── run.log       # Execution log
├── .claude/
│   ├── loop_system.md   # System prompt
│   └── skills/
│       └── testing.md   # Testing guidelines
└── daily_loop.sh        # Entry script

Step 3 – Loop entry script

#!/bin/bash
# daily_loop.sh – triggered by cron at 6 am
REPO_DIR="/path/to/project"
PROGRESS_FILE="$REPO_DIR/.loop/progress.md"
MAX_ITERATIONS=5
cd "$REPO_DIR"
for i in $(seq 1 $MAX_ITERATIONS); do
  echo "=== Round $i / $MAX_ITERATIONS ==="
  claude --print \
    --system-prompt "$(cat .claude/loop_system.md)" \
    "Read progress file, handle next unfinished Issue. After fixing, update progress. If all Issues are done, output DONE." \
    2>&1 | tee -a .loop/run.log
  if grep -q "DONE" .loop/run.log; then
    echo "All tasks completed."
    break
  fi
done

Step 4 – Memory file design

The progress.md file records completed tasks, pending work, and lessons so the next run knows where to continue.

Step 5 – Cron trigger

# Run every day at 6:00 am
0 6 * * * /path/to/project/daily_loop.sh

Full flow diagram (textual)

[cron 6:00 am] → start daily_loop.sh
      │
      ├─► read progress.md (load state)
      ├─► fetch GitHub Issues (Plugin)
      │      filter unresolved Issues
      ├─► create Git worktree (isolated workspace)
      ├─► apply Skills/ guidelines
      ├─► run tests & lint
      │      └─► if tests fail → retry fix
      │      └─► if tests pass → Sub‑agent validation
      ├─► create Pull Request & update progress.md
      └─► next Issue or terminate

Four design principles for continuously improving loops

Principle 1 – Start with small Closed‑loops

Define a clear goal, a stop condition, and a bounded runtime (e.g., a 10‑minute verification loop) before scaling to a fleet.

Principle 2 – Every loop must have a stop condition

Verification‑pass stop – all tests green, lint clean.

Iteration‑limit stop – max rounds reached, then notify a human.

Human‑hand‑off stop – agent marks the task as needs‑human with analysis when out of scope.

Loops without stop conditions are bugs, not features.

Principle 3 – Outer loop should generate compound experience

After each Inner Loop, spend ~30 seconds updating a lessons.md file with "what went wrong and how it was solved". The next run can read this and avoid the same pitfall.

Principle 4 – Cognition must keep up with code

Periodically review loop outputs, verify decisions, and ensure recorded lessons are valuable. The loop designer remains ultimately responsible for quality.

Conclusion

From 2024’s Prompt Engineering to 2025’s Multi‑Agent Orchestration and now 2026’s Loop Engineering, the collaboration model shifts from writing individual prompts to designing autonomous systems that continuously improve. The key is to move effort from granting unlimited authority to a high‑capability individual toward building an environment that reliably produces outcomes.