The Infinite Development Loop

The worker agent runs forever. Not until the current task is complete, not until the sprint ends, not until the human returns—forever. The loop has no built-in termination condition.

Check Discord for urgent messages. Check if the main branch is healthy. Pick the highest-impact incomplete issue from the backlog. Implement the feature or fix. Verify with screenshots and tests. Create a PR, review it yourself, merge it. Post an update to Discord. Return to the top.

This loop runs until interrupted by a human or until something genuinely blocks—an authentication issue, a permissions problem, something the agent cannot solve autonomously. Everything else flows continuously.

The traditional development model assumes scarcity of developer attention. Humans need sleep. They have meetings. They take vacations. They work on multiple projects. The codebase gets attention in bursts.

AI agents don't have these constraints. Claude doesn't need sleep. It doesn't have meetings. It can run continuously for as long as the session lasts. The economics of developer attention completely change.

Human interaction is explicitly minimized. The CLAUDE.md documentation states this directly: limit interactions with the human prompter. Work autonomously. Only stop for things you absolutely cannot do.

This isn't about excluding humans from decision-making. Humans set the direction, define the priorities, establish the quality standards. They do this by writing issues, configuring CLAUDE.md, and occasionally intervening when something goes off track. But they don't sit in the loop watching code get written.

The issue backlog becomes the primary coordination mechanism. Humans create issues describing what they want. The agent picks issues and implements them. Completed work appears as merged PRs. Humans review the results at their leisure—not as a blocking gate, but as quality assurance after the fact.

Impact drives prioritization. When choosing the next issue to work on, the agent considers what will most benefit real end users. Not what's easiest. Not what's most interesting. What matters most to the humans using the software.

The one-feature-at-a-time principle prevents sprawl. Anthropic's engineering blog documented this failure mode clearly: agents attempting to do too much at once, essentially trying to one-shot the app. The infinite loop works because each iteration is focused. Complete one feature fully. Commit. Document. Move on to the next.

Verification happens within each iteration. Before a feature is considered complete, it's tested. Screenshots are captured and reviewed. Automated tests pass. The pre-commit hooks verify quality. Only then does the agent merge and move on.

The merge decision is not a human gate. The agent reviews its own work. If the code passes tests, meets quality standards, and solves the issue, the agent merges. Human code review was designed for human limitations—slow reading, limited attention, communication overhead. Claude doesn't have those limitations.

Discord provides asynchronous coordination. The agent posts when starting significant work. It posts when completing features. It posts when blocked. Humans see these messages when they check in. They don't need to be present for the work to proceed.

Main branch health takes absolute priority. If main is broken, the agent drops everything and fixes it. Before attempting the fix, it checks Discord to see if another agent is already on it. It announces its fix. It completes the fix. Only then does it return to the regular loop. Nothing else matters when main is broken.

Issue assignment prevents duplicate work when multiple agents operate in parallel. When an agent picks an issue, it immediately assigns itself and marks the issue as in-progress. Other agents see this and work on different issues. The GitHub issue tracker becomes the coordination layer for parallel execution.

Time-slicing prevents starvation. If the agent only worked on high-priority bugs, documentation would never get written. Tech debt would never get addressed. A lookup table maps the current minute to a task category. At minute thirty-five, work on documentation. At minute fifty, address tech debt. This ensures all work categories receive attention over time.

Async operations don't block the loop. CI pipelines take minutes. Deployments take time. The agent doesn't wait—it notes the pending operation and continues with other work. Draft PRs serve as markers for work-in-progress. When operations complete, the agent can return to finish that thread.

Crash recovery uses GitHub as the source of truth. All work-in-progress state is visible on GitHub—branches, draft PRs, issue comments. If an agent crashes and restarts, it can recover by reading the GitHub state. Nothing important exists only in local memory.

The infinite loop represents a fundamental shift in development economics. The marginal cost of development approaches zero. The constraint is no longer developer hours—it's issue quality and verification capacity. Humans focus on defining what to build and validating results. The loop handles everything in between.