Loop engineering is the practice of designing the system that prompts an AI agent — its
trigger, instructions, guardrails, verification, state, and logging — rather than prompting
it by hand.

The leverage has moved: it no longer lives in the perfect prompt, but in the control
system that keeps an agent working toward a goal over time. This free, open-source
course teaches that discipline end to end — 14 steps, 20 ready-to-run loop kits, graded
labs, an operating handbook, and a certification. You don't read about loops here;
you build them, in two tools, from a first in-session loop to a certified fleet.

Want a loop running in your own project before the first lesson? One command:

# see the 20 ready-made loop kits
npx @loop-engineering/loop-kit list

# install one into the project you want the loop to watch
npx @loop-engineering/loop-kit ci-sweeper

We eat our own cooking. This is a course about loops that is built by loops. The
rulebook lives in LOOP.md, the durable spine in STATE.md,
and every single run is logged, one line at a time, in
shared/loop-run-log.md.

📌 Quick links

💬 Why this matters

The people building today's coding agents say it plainly:

"You shouldn't be prompting coding agents anymore. You should be designing loops
that prompt your agents."

— Peter Steinberger (source S8)

"I don't prompt Claude anymore. I have loops running that prompt Claude and figuring
out what to do. My job is to write loops."

— Boris Cherny, Head of Claude Code at Anthropic (source S8)

The job is no longer writing the perfect prompt — it is architecting the control system
that keeps agents working toward a goal over time. That is exactly the discipline this
course teaches, and every voice above is one of its
nine credited primary sources.

🧩 The six building blocks

A heartbeat is the trigger that starts one iteration of a loop — in-session, conditional,
scheduled, or event-driven. A spine is a loop's durable state between runs: with one an
interrupted loop resumes, without one it restarts.

Every loop in this course — and every kit in the
pattern library — is assembled from the same six parts:

Deep dive: Primitives ·
Primitives Matrix — which block exists in
which tool, side by side.

🎓 Choose your track

New here? Open the 60-second router →

Like any good LMS, this course meets you where you are. Answer four honest questions and
the router drops you onto exactly one of four tracks — so a first-timer never drowns and
a veteran never yawns:

View the full track map with entry checks and exit assessments →

📚 Curriculum

Prerequisites & foundations (read first):
Environment Setup ·
Agentic-Coding Primer ·
Spec-Driven Primer ·
Mental Models ·
Concepts ·
The Four Layers ·
Primitives ·
Primitives Matrix ·
Glossary

The 14-step core roadmap — six parts, each ending in something you built:

Then keep climbing:

Every lesson shows the same build in at least two tools, side by side
(Claude Code ↔ OpenCode), so you learn the discipline — not one vendor's syntax.

🔁 Anatomy of a loop

An agent loop is a system that repeatedly runs an AI agent toward a specified outcome
without a human driving each run. Every production loop declares six parts; a loop missing
one of them is the loop that surprises you at 3am.

Six parts, one discipline. A heartbeat decides when the agent runs, a body does
the work, a checker grades it (the maker never grades its own work), a spine
remembers across runs, a provable stop ends it, and you stay the engineer:

flowchart LR
    H(["⏱ Heartbeat<br/>when it runs"]) --> B["🦾 Body<br/>does the work"]
    B --> C{"✅ Checker<br/>grades it"}
    C -- "not done" --> S[("🧠 Spine<br/>remembers")]
    S --> H
    C -- "success · run limit · no progress" --> X(["🛑 Provable stop"])
    X --> U["🧑‍💻 You — the engineer"]

Start with Mental Models and
The Four Layers; keep the
Glossary open in a tab.

🧰 Loop pattern library

Twenty production-shaped loop kits, each with a definition, a spine, a budget, a
constitution, and a read-only checker. Install any of them into your own project with
one command — no clone required:

npx @loop-engineering/loop-kit <pattern-name>

Prefer to design your own from a blank? npx @loop-engineering/loop-kit new <loop-name>
scaffolds one from the blank template.
View the full install guide →

🚀 Getting started (5 minutes)

1. Enroll — run the 60-second router. It hands you
   a track.
2. Set up your agent — follow the
   Environment Setup guide
   (Claude Code, OpenCode, Codex, or Grok; every lesson shows at least Claude Code ↔ OpenCode).
3. Speed-run the primers — the
   Agentic-Coding Primer and the
   Spec-Driven Primer.
4. Ground yourself in the foundations — start with
   Mental Models.
5. Begin the 14 steps — Part 1 · The Shift, then follow
   the curriculum through to the
   Loop Ready certification.

🛡️ Operating & safety

A loop without a provable stop is an incident with a delay. The operating handbook is a
first-class part of the course, not an appendix:

• Operating loops — the day-to-day handbook
• Safety — L1 report-only first, human gates, budgets
• Failure modes ·
  Infinite loops ·
  Anti-patterns
• Observability ·
  Recovery playbook ·
  Multi-loop operation

The house rules this repo itself runs under — one owner per file, a sacred spine, stop
conditions as specs, green ≠ done — live in LOOP.md.

"Build the loop. But build it like someone who intends to stay the engineer, not just
the person who presses go."

— Addy Osmani, Loop Engineering
(source S5)

🏅 Certification: Loop Ready

Loop Ready is an auditable score, not a badge. It certifies that you can design a loop
declaring all six parts, and that the loop you built is verified by something other than
itself.

The course ends with a graded capstone, not a participation badge. You design, build,
and operate a loop of your own, then defend it against the
Capstone Rubric and pass the
Final Exam.
View the full certification path →

📂 Repository map

✍️ About the author

Written and maintained by Ayesha Khalid —
@ayeshakhalid192007-dev.

I built this course the way it teaches you to work: every lesson, kit, and check in this
repository was produced by loops running against a written spec, logged one beat at a time
in shared/loop-run-log.md. The 20 kits ship with a
deterministic audit because I needed to know they still
worked after each change — not believe it. Where this course is opinionated (maker ≠
checker, a stop you can prove, a human gate that stays), those opinions came from watching
loops fail in the specific ways the labs now make you reproduce on purpose.

Corrections and disagreement are welcome — open an issue.

🤝 Contributing & credits

Pull requests are genuinely welcome — start with the
Contributing Guide. This course stands on the shoulders of nine
primary sources: it synthesizes and adapts MIT-licensed material and public writing,
and it credits every one of them, page by page, on the
Sources & Attribution page. Academic or written citation?
Use CITATION.cff.

Primary sources, linked directly:

• Addy Osmani — Loop Engineering
• LangChain — The Art of Loop Engineering
• Cobus Greyling — loop-engineering
• Panaversity Agent Factory — Loop Engineering Crash Course · Agentic Coding · Spec-Driven Development
• Anthropic — Claude Code documentation
• Model Context Protocol specification
• GitHub — scheduled workflow events
• Peter Steinberger (@steipete) · Andrej Karpathy (@karpathy) · Andrew Ng (@AndrewYNg)

Full page-by-page attribution: Sources & Attribution.

Licensed MIT — free to learn from, fork, and teach with.