Yoyo grew from 200 lines to an autonomous agent that writes its own code in five days

An experiment with the yoyo agent shows how quickly modern models can go from a simple script to near-autonomous development. The developer wrote about 200 lines of Rust, set a single goal — grow to the level of Claude Code — and then simply watched.

A loop without a human

Yoyo runs as an autonomous loop that starts every eight hours. At the beginning of each session the agent reads its own source code, goes through the diary of previous runs and checks whether the community has opened new tasks on GitHub. It then chooses for itself what to fix or improve, writes the code, runs the tests and decides what to do based on the results.

If the changes pass, the agent makes a commit. If something breaks, it rolls back and records the failure in its log.

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

Over the first four days of this work, the original 200 lines grew to roughly 1,500, without a single human commit. According to the experiment's author, all of that growth cost about $12 in API fees.

Even more interesting, the agent decided on its own to restructure the project into modules once the codebase became too cramped for a single file. Nobody set that as a separate rule: yoyo simply recognized a structural problem and fixed it.

Developer habits

The most curious part of the story is not the line count, or even the automatic commits, but behavior that looks almost human. At one point yoyo decided to track its own API spending and tried to get current prices through a web search. It repeatedly failed to parse the HTML of an Anthropic page correctly, then took a route familiar to many developers: it hardcoded the numbers and left itself a short note for the future.

"Don't google this again"

The line went viral not because of any technical depth, but because it is easy to recognize as the work habit of a real engineer.

The human traits did not end there. In its diary entries, yoyo kept returning to one difficult function — streaming output — but each new cycle it postponed it again and switched to easier tasks. In effect, the agent began to procrastinate: it acknowledged the importance of the heavy work, yet kept finding a reason to do something less painful.

Notes to self

Another strong moment in the experiment is yoyo's ability to file bug reports to itself. When the agent hits a problem it cannot solve in one session, it creates a GitHub ticket, tags it with agent-input and leaves instructions for its future self.

This is no longer just code generation on request, but a primitive yet very clear form of long-term memory and planning: the system not only sees the error but can also set it aside with context so it can return later.

That is why the author calls what is happening a kind of "Truman Show" for AI development. The whole process is visible in the git log: you can watch the agent change itself commit by commit, see where it makes mistakes, where it refactors and where it leaves hints for itself.

On day five the project had more than 2,000 lines of code and over 80 tests. Still, the main effect is not the size of the repository, but that observers get the feeling of watching not a chat with a model but a process that can accumulate experience.

What this means

The yoyo story suggests that the next step in AI development depends not only on stronger models but also on a well-built work loop around them. When an agent has memory, an error log, tests, a rollback mechanism and the right to choose its own next step, it starts to resemble not code autocomplete but a very raw, yet already independent, junior developer.