# Loop Engineering: How Orbyt Builds Itself > Loop engineering is how software gets built when you stop prompting and start running systems. On Orbyt, autonomous agents build features, run the tests, heal their own failures, and write what they learn back into the repo. My job is designing the loop and judging the output. Here is the machine, end to end. - Canonical URL: https://justinbartak.ai/blog/loop-engineering - Author: Justin Bartak, Chief AI Officer (https://justinbartak.ai) - Author entity: https://justinbartak.ai/#person - Author profiles: https://www.wikidata.org/wiki/Q139551829, https://orcid.org/0009-0005-2615-3624, https://www.linkedin.com/in/justinbartak, https://x.com/justinbartak, https://www.crunchbase.com/person/justin-bartak, https://medium.com/@justinbartak, https://github.com/justinbartak, https://about.me/justinbartak - Published: 2026-08-13 - Updated: 2026-08-13 - Category: Engineering - Keywords: loop engineering, autonomous AI agents, auto-healing code, self-healing software, AI agents building software, agentic engineering, AI development loop, autonomous coding agents, agentic workflow, how Orbyt is built - Reading time: 6 min read --- Loop engineering is how software gets built when you stop prompting and start running systems. I do not prompt [Orbyt](/#orbyt) into existence. I run loops: autonomous agents that build the feature, run the tests, heal their own failures, and write what they learned back into the repo. My job moved up a level. I design the machine and judge its output. This is how Orbyt is actually built. **Orbyt is not something I typed. It is something I run.** ## What changed since the prompting era? In 2023 and 2024, working with AI meant babysitting it. You typed an instruction, watched the output, corrected it, and typed again. The human was the loop: the memory, the feedback signal, and the quality gate, all at once. It felt like magic and scaled like a conversation, which is to say it did not. I made the argument for why that era ended in [The Prompt Is Dead. Long Live the Loop.](/blog/ai-loop-engineering-death-of-the-prompt) This post is the other half: what the discipline looks like as a working system, running every day on a production product. [Anthropic](https://www.anthropic.com) defines agents as LLMs using tools based on environmental feedback [in a loop](https://www.anthropic.com/engineering/building-effective-agents). Loop engineering is taking that sentence seriously as an engineering target. The environment, the feedback, and the loop's exit condition are all things you build. Once they exist, prompting stops being the interface. The system is the interface. ## What does an autonomous agent do on Orbyt? Here is one loop, end to end. An agent picks up a spec. Not a vibe, a spec: what done means, which paths must fail closed, what is out of scope. It reads the repo for context: the docs, the conventions, the project log, everything previous loops left behind. It builds the feature and the tests together, in [Claude Code](https://docs.anthropic.com/en/docs/claude-code). Then it runs the checks. Red. It reads the failure, fixes its own work, and runs them again. Green. Only then do I enter the picture, and I review the outcome, not the keystrokes. While that loop runs, others run beside it. [A stack of terminals](/blog/bottleneck-was-never-the-code), each executing its own cycle, none waiting on me to type the next instruction. Be precise about what autonomy means here. It is not the agent deciding what Orbyt should be. It is the agent owning the entire distance between the spec and green. ## What is auto-healing? Auto-healing is the loop repairing its own failures without me. A red test, a type error, a broken build: each one is a signal that feeds straight back to the agent, which diagnoses, fixes, and reruns. Most failures never reach me at all. I find out they existed by reading the log, the way you find out your immune system worked. The boundary matters more than the magic. The agent heals against my definition of correct, encoded as 11,372 tests and a 35-dimension audit harness. It does not get to redefine correct. And the paths that guard money and access fail closed, so an unhealed failure denies rather than permits. A loop that healed against its own judgment would not be resilience. It would be drift with confidence. That is the honest line between self-healing and self-deception, and [the harness is what draws it](https://www.orbytlabs.ai/blog/why-build-an-ai-test-harness). ## How does the loop learn? Through the write-back, which is the part most people miss. Every finished loop leaves the repo smarter than it found it: updated docs, a new convention, a sharper rule, and above all new tests. Every mistake becomes a permanent check. The bug an agent shipped in March cannot ship again, because the loop that fixed it left a tripwire behind. Run that for months and the numbers compound. Orbyt's suite is 11,372 tests, and almost none of them were written for their own sake. They are accumulated institutional memory, the residue of every loop that ever ran. This is also why the learning survives the model. The intelligence rents; the repo owns. I swapped frontier models under Orbyt twice, once by choice and once when export controls forced it, and nothing reset, because nothing important lived in the model. Orbyt's memory is in the repo, and every loop deposits into it. ## What is left for the human? Four things, and they are the job. Intent: deciding what gets built and why. Taste: choosing among the infinite options agents generate, because [only judgment picks the right one](/blog/i-manage-agents-not-people). The bar: defining what green means, and refusing to lower it on a deadline. Review: reading outcomes fast enough to keep up with a machine that never sleeps. I will not oversell the autonomy. These agents are not employees, and the system works precisely because I never have to trust them. [I trust the proof](/blog/verification-is-the-new-literacy). Autonomy without a verification layer is not a strategy. It is a gamble with better marketing. ## How do you start? Not with a fleet. With one honest loop. Pick one workflow that matters. Write the spec as checks, not prose. Give an agent the tools to build and the signal to know it failed: tests, types, the build, wired to run on every attempt. Make the dangerous paths fail closed. Then let it run to green and judge the output. That single loop will teach you more about AI-native building than a quarter of prompt experiments, because it forces the real questions: what does done mean, what proves it, and what happens when the machine is wrong. Answer those once and you can run two loops. Then ten. Orbyt is over 425,000 lines and 11,372 tests, built solo in 32 days for about $400, and shipped daily since. That is not a typing achievement. It is a systems achievement. **Prompting was talking to the machine. Loop engineering is building the machine that does the work.** See it in practice: [Orbyt, built and run solo](/#orbyt), the first product out of [Purecraft](https://purecraft.ai). Related reading: - [The Prompt Is Dead. Long Live the Loop.](/blog/ai-loop-engineering-death-of-the-prompt) the thesis behind this system: why the loop replaced the prompt as the unit of work - [I Manage AI Agents Now, Not People](/blog/i-manage-agents-not-people) the management half of running a fleet of loops - [No Harness, No Trust.](https://www.orbytlabs.ai/blog/why-build-an-ai-test-harness) the gate that makes autonomy safe instead of reckless - [I Run a Stack of Terminals. The Bottleneck Was Never the Code.](/blog/bottleneck-was-never-the-code) what parallel loops look like from the operator's chair - [Codex Accuses. Claude Convicts.](/blog/two-ai-audit-loop-codex-claude) putting a second model outside the loop, with no write access, to grade what the builder cannot see - [Context Is the New Codebase.](https://www.orbytlabs.ai/blog/context-engineering) the read-side economy every loop runs on --- ## Frequently Asked Questions ### What is loop engineering? Loop engineering is the practice of running software development as engineered loops instead of supervised prompts. An autonomous agent picks up a spec, builds, runs the tests, repairs its own failures, and stops only when a fail-closed gate turns green. The engineer designs the spec, the signals, and the gate, then judges the output. ### How autonomous are coding agents today? Autonomous within a governed loop, not autonomous in general. On Orbyt, agents run for hours, building and self-correcting against 11,372 tests and a 35-dimension audit harness. What makes that safe is the loop, not the model: real feedback signals, fail-closed gates, and an operator reviewing output. Remove those and autonomy becomes gambling. ### What is auto-healing in AI development? Auto-healing is the loop repairing its own failures without a human. A red test, a type error, or a broken build feeds straight back to the agent, which diagnoses the failure, fixes it, and reruns the checks. The agent heals against the definition of correct the operator encoded. It does not get to redefine correct. ### How does an AI development loop learn? Through the write-back. Everything a loop learns lands in the repo: docs, conventions, project logs, and above all tests, so every mistake becomes a permanent check. The next agent starts from all of it. The learning lives in the repo, not the model, which is why swapping models does not reset the system. --- Source: https://justinbartak.ai/blog/loop-engineering Cite as: Justin Bartak, "Loop Engineering: How Orbyt Builds Itself", https://justinbartak.ai, 2026-08-13. https://justinbartak.ai/blog/loop-engineering