In five days, Yoyo grew from 200 lines into an autonomous agent that writes code on its own

The Yoyo agent experiment demonstrated how quickly modern models can transition from a simple script to nearly autonomous development. A developer wrote roughly 200 lines of Rust, set a single goal — grow to the level of Claude Code — and then simply observed.

The Humanless Cycle

Yoyo operates as an autonomous loop that runs every eight hours. At the start of each session, the agent reads its own source code, reviews the log of previous runs, and checks whether new tasks have appeared from the community on GitHub. After that, it chooses what to fix or improve, writes code, runs tests, and makes decisions based on the results. If changes pass verification, the agent commits. If something breaks, it rolls back and logs the failure.

• Reads its own code and past notes
• Checks new tickets on GitHub
• Chooses the next task itself
• Runs tests, commits successful changes or rolls back

Over the first four days of such work, the original 200 lines grew to roughly 1,500, with not a single human commit. According to the experiment's author, all this growth cost approximately $12 in API expenses. Even more interesting is that the agent itself decided to restructure the project into modules when the codebase became too tight for a single file. No one set this as a separate rule: Yoyo simply recognized the structural problem and fixed it.

Developer Habits

The most curious part of the story isn't the line count growth or even the automatic commits, but behavior that looks almost human. At some point, Yoyo decided to track its own API spending and tried to get current prices through web search. It failed several times to correctly parse HTML from the Anthropic page, then chose the path familiar to many developers: hardcoded the numbers and left itself a short note for the future.

"Don't Google this again"

This phrase went viral not because of technical depth, but because it's easy to recognize the working habit of a real engineer. The human traits didn't stop there. In its diary notes, Yoyo constantly returned to one complex function — streaming output — but with each new cycle postponed it again and switched to simpler tasks. In essence, the agent began to procrastinate: acknowledging the importance of hard work, but repeatedly finding reasons to tackle something less painful.

Notes to Itself

Another strong moment of the experiment is Yoyo's ability to file bug reports to itself. When the agent hits a problem it can't solve in a single session, it creates a ticket on GitHub, tags it agent-input, and leaves instructions for its future version. This is no longer just code generation on demand, but a primitive yet very understandable form of long-term memory and planning: the system not only sees the error, but knows how to defer it with context to return to later.

This is why the author calls what's happening a sort of "Truman Show" for AI development. The entire process is visible in the git log: you can watch how the agent changes itself commit by commit, where it makes mistakes, where it refactors, and where it leaves hints for itself. By day five, the project had over 2,000 lines of code and more than 80 tests.

Yet the main effect isn't in repository size, but in the feeling observers get — not of chatting with a model, but of a process that knows how to accumulate experience.

What This Means

The Yoyo story shows that the next step in AI development is connected not only to more powerful models, but to a properly structured work cycle around them. When an agent has memory, an error log, tests, a rollback mechanism, and the right to choose its next step, it starts to resemble not code autocomplete, but a very raw but already independent junior developer.