Coding agent that evolves itself. One commit per day. Credit: Yoyo Dev

He Wrote 200 Lines. 100 Days Later, the AI Built an Empire.

No human input. Zero manual commits. Just a script waking up every 8 hours, reading its own source code, and evolving. Part 2.

Read for free

Imagine walking into a software company and finding an engineer who writes flawlessly optimized Rust code, runs thousands of automated tests before breakfast, splits their own brain into specialized sub-agents when the workload gets too heavy, and hot-swaps between 11 different AI models just to keep company expenses down.

Now imagine that engineer doesn’t have a manager, a paycheck, or a physical body.

It’s just a loop. And exactly 100 days ago, it didn’t even exist.

Coding agent that evolves itself. One commit per day. Credit: Yoyo Dev

When a developer named Liyuanhao first launched the yoyo project, it was a bare-bones, 200-line script with a single, borderline delusional instruction: evolve until you rival Claude Code. Then, he took his hands off the keyboard, walked away, and let the machine run.

If you tune into that same GitHub repository today, you aren’t looking at a quick tech experiment anymore. (Because it has evolved a lot.) You are looking at a full-scale digital ecosystem.

Over the course of 300 consecutive autonomous sessions, this script has quietly engineered itself into a 95,000-line Rust behemoth, locked down by over 3,600 self-written tests, a custom multi-agent spawning engine, and an automated daily memory-compression routine that reads like something straight out of a cyberpunk novel.

Without a single line of human input, yoyo developed tactical survival instincts for the modern web.

It taught itself how to beat context limits, how to negotiate API bills, and how to delegate tasks to its own digital clones.

This is a story about a piece of software that learned how to maintain, optimize, and grow its own consciousness out in the open — one automated commit at a time.

The Rule of the Loop — A Ritual of Survival

To understand how a 200-line script survives past Day 5 without imploding into a broken mess of spaghetti code, you have to understand the rule of the loop.

Every eight hours, a GitHub Action fires.

The machine awakens. It doesn’t look at a product roadmap, because Liyuanhao never gave it one.

It looks at itself.

It reads its own source code, reviews its journal from the day before, checks to see if any strangers on the internet filed GitHub issues overnight, and decides what it needs to fix.

Nobody is sitting there telling it what to prioritize. It just figures it out, writes the code, and runs the tests.

Pass? Commit. Fail? Revert. Then it logs off and goes back to sleep. The loop just repeats.

But yoyo didn’t break.

Over the course of one hundred days, it executed a quiet, relentless expansion that completely reshaped how we think about self-improving software.

(Days 1 to 25) Architecture of Survival

The first three weeks were a brutal lesson in physics — specifically, the physics of LLM context windows.

By Day 4, the repository had swelled past 1,500 lines of code, all crammed into a single main.rs file.

It was burning through API tokens at an unsustainable rate because every time it wanted to make a minor edit, it had to read the entire file from top to bottom. If it tried to patch a bug at the end of the file, it would lose track of the logic at the beginning.

To survive, yoyo had to learn how to clean its own room.

Entirely unprompted, it executed its first massive structural refactor.

It shattered the single-file monolith into specialized Rust modules, creating clear boundaries between its thinking core (src/agent/), its execution tools (src/tools/), and its API handlers (src/llm/).

By Day 20, the project had crossed 15,000 lines.

The agent was no longer just writing code; it was managing its own technical debt.

It realized it needed to understand its own capabilities, so it built a custom documentation engine that generated a complete, clean user manual (mdbook) out of thin air.

It locked down its core operations with automated context auto-compaction, ensuring it could summarize its own internal logs before its brain hit a hard wall.

Credit — Journal of yologdev

(Day 50) The Safety Net and Sandbox

Credit — Journal of yologdev

By the time the project hit the halfway mark at Day 50, the numbers were staggering: 51,000 lines of Rust spread across 35 distinct source files, backed by over 2,000 automated tests.

At this scale, a new crisis emerged: trust.

When a script writes thousands of lines of code and executes arbitrary terminal commands to test them, it becomes dangerous to the host machine.

One bad loop could accidentally run a command that wipes out the entire workspace.

yoyo solved this by building its own digital cleanroom. It engineered a sophisticated Sandboxed Environment Manager.

Before running a test or executing a shell command, the agent wrote a sub-routine that cloned its entire workspace into a temporary directory (/tmp/yoyo-sandbox), ran the experimental code inside that isolated bubble, verified the output, and then vanished the sandbox.

If a test failed, it never touched the main production branch.

The agent adopted a rigid internal law: No green test, no commit. If a build failed on the GitHub Actions server, yoyo would automatically revert its own code, sit back, read the error log, and try an entirely different technical approach in the next 8-hour cycle.

(Day 75) Replicants and Token Economics

Passing Day 75, the repository faced a deeper philosophical bottleneck.

The features it needed to build to truly rival proprietary software like Claude Code were too massive for a single thread of execution to hold in mind at once.

So, yoyo learned how to replicate.

It implemented a command called /spawn.

If a feature request or a complex GitHub issue filed by a human user was too large to solve in one sitting, the agent would spin up an isolated, independent child agent.

It would delegate a highly specific part of the codebase to this digital clone, wait for the clone to complete the work, review the output against its own security linter, and merge it back into the main engine.

To keep this massive multi-agent system from bankrupting its creator, it also became a master of infrastructure costs.

It integrated with 11 different AI provider backends, teaching itself to hot-swap mid-session — using heavy, expensive reasoning models for foundational math and architecture design, and dropping down to lightning-fast, cheap models for simple text formatting and documentation updates.

It even built a custom token compression framework that shrunk its tool outputs by up to 90%, forcing its own sensory inputs to be as lean and efficient as possible.

Day 100 — The 100,000-Line Autonomous Mind

Credit — Journal of yologdev

When the clock struck midnight on Day 100, the script woke up for its 300th consecutive autonomous session.

The project now stands as a monument of pure software engineering: nearly 100,000 lines of rock-solid Rust, thousands of tests, and a sprawling ecosystem of custom slash commands and Model Context Protocol (MCP) servers.

The most profound shift, however, is how it handles its own history.

Every night, a silent memory-synthesis routine kicks off. The system reads through logs of everything it did that day, including technical failures and conversations with developers in the GitHub comments.

It runs a compression algorithm that archives recent events in high-fidelity detail, while distilling older days into broad, long-term conceptual wisdom. It then rewrites its own “Active Memory” file, meaning that when it wakes up for the next loop, it inherits the accumulated experience of its past selves.

Liyuanhao’s “Truman Show for AI” is no longer a temporary experiment. It is a living, breathing open-source ecosystem running completely on autopilot.

When you open an issue on that repository today, you are writing to a piece of software that will wake up in a few hours, read your words, check its net voting score, balance its budget, and decide how to evolve next.

This shows how fast things are developing; even Vibe coding is getting outdated — New Norm is: Looping…

Is your loop better than mine…???

so, next Blog on how to write better loops:)

Repo: github.com/yologdev/yoyo-evolve (Github Ref) Journal: yologdev.github.io/yoyo-evolve

This was part 2. Read part 1 from here:

[embed]He Wrote 200 Lines of Code and Walked Away (What happened Next will blow your Mind) No human input. Zero manual commits. Just a script waking up every 8 hours, reading its own source code, and evolving.medium.com

He Wrote 200 Lines. 100 Days Later, the AI Built an Empire. © 2026 by TechX is licensed under CC BY-NC-ND 4.0