The AI Command You Shouldn't Ignore
In the AI space, everyone is talking about /loop.
The ability to give an AI agent a task and have it keep running until the job is done. It is getting a lot of attention, and the attention is warranted.
But the conversation has a gap. Here is our take on how loops work in practice, the process we built, use today, and adapt across projects.
What this means for your business
A year ago, building software required a team, a project manager, QA testers, and weeks of coordination. Today, a small team with the right AI infrastructure can ship the equivalent of hundreds of development hours overnight, with no overtime budget and no team expansion.
Here is a real example: we built crewmaps.com from scratch in under 48 hours. 9 development phases. Roughly 220 individual tasks. A human team wrote the specification and approved the end of each phase. Everything in between ran automatically, around the clock.
That is not a demo. That is a live product.
The critical difference between this and just running AI in the background: every task lived on a shared kanban board. Humans could see exactly what was happening at any moment, step in, course-correct, or redirect without stopping the entire build. Nothing was a black box.
Anthropic has stated that 90% of their own development now runs via /loop. This is the modern equivalent of directing a highly skilled team to complete a project. You are no longer limited by what software you can buy. You are only limited by what you can describe, and we can make that description a reality.
The business implication: the constraint on what you can build is no longer headcount or budget. It is the quality of your planning and the clarity of your specifications. And when something needs to change mid-build, you can actually find it.
The gap nobody is talking about
/loop alone does not do this. Two things are required that the current hype skips over:
- A structured plan
- Accountability
Without both, /loop is just an agent spinning in circles, making confident mistakes with no audit trail.
The architecture we use
Three agents: an orchestrator, a builder, and a QA agent.
Comprehensive specification first. The work starts with humans. A detailed spec defines every phase, every acceptance criterion, every integration point. We recommend structured approaches such as planning mode and phased sign-off. This is not a prompt. It is a contract.
An orchestration agent runs the /loop on a shared kanban board. Rather than spawning background subagents that disappear into the void, the orchestrator breaks the spec into discrete tickets on a board that humans can see and interact with. Each ticket is assigned to a builder agent, tracked through status changes, and carries a full record of what was done and why.
This gives you something most AI workflows do not: visibility. Not just "did it finish" visibility. Tool-call-level, reasoning-level visibility. If a feature needs to be adjusted or something breaks, you open the ticket, read what the agent reasoned through, and understand exactly where to intervene.
This also solves three core problems with naive agent loops:
- Drift control: the orchestrator catches when a builder goes off-spec before it compounds
- Context management: each builder gets a clean, scoped task, not the entire project history
- Coordination: work sequences correctly without agents stepping on each other
A QA agent acts as the gate. A third agent reviews each completed ticket against the original specification before it closes. The builder cannot move on until QA approves. This is what stops small mistakes from compounding into a broken system.
Human checkpoints at phase boundaries. After each major phase, the loop pauses. A human reviews the output, approves or redirects, and the next phase begins.
This process is adaptable. We have used versions of it across software builds, content pipelines, and research workflows.
The principle
Agents handle the execution load. Humans retain judgment at the decisions that matter. And the ticketing board keeps everything auditable when you need to troubleshoot, adjust, or hand off.
/loop is powerful. Power without visibility is just fast failure.
Build the structure first.