In the past few days, the tech community has been stirred up by a blog post from Cursor.
The title was incredibly seductive—”Scaling long-running autonomous coding.” The story was even more compelling: they unleashed hundreds of AI Agents working around the clock on a project named fastrender. Within a few weeks, these agents wrote over 1 million lines of code, allegedly “building a web browser from scratch.”
Reading this, were you ready to bow down and welcome the arrival of AGI?
Don’t get on your knees just yet. When you wipe your glasses, pull the code to your local machine, and type that sacred command cargo build, what greets you isn’t the dawn of the future, but a red ocean of error messages.
This situation is actually quite fascinating. It’s exactly like that friend who posts gym selfies on social media—top-tier gear, perfect filters, motivational captions—but if you accidentally check the EXIF data, you see the photo was taken at 3 AM, or the mirror in the background reveals a staged lie. The flavor changes instantly.
This time, Cursor might have just posted the photo but forgot to put on the most basic engineering “underwear”: making sure it actually runs.
1. The Foundation of a Phantom Skyscraper: The Uncompilable “Million Soldiers”
Let’s unpack the logic here.
Cursor’s narrative core is “scale.” They wanted to prove that as long as there are enough Agents running for long enough, they can achieve “ambitious goals” that would take human teams months to complete. To prove this, they posted a GitHub repository link and even included a video that looks pretty cool.
But here’s the problem: Code is meant to be run, not weighed.
According to tests by various geeks (myself included), the fastrender repository is essentially in a “vegetative state.” The GitHub Actions CI (Continuous Integration) is full of red crosses, and Pull Requests are being merged despite failing checks. Some serious developers even traced back the last 100 commits and couldn’t find a single version that compiled clean.
This chart looks like a technological victory, but it’s actually a logical black hole. Behind every green square, there might be a hidden red compilation error.
You call this a “browser”? In the eyes of a geek, if a Rust project can’t even pass cargo check, it’s at best a “collection of text files that look like a browser.”
It’s like a construction company claiming: “We used 1,000 robots to stack up this 100-story building in a week!” You run over excitedly, only to find that while the building is indeed 100 stories high, it’s made entirely of toy blocks, falls over with a gust of wind, and you can’t even open the front door.
In their blog, Cursor uses extremely ambiguous language—”meaningful progress,” “extremely difficult”—to decorate this semi-finished product. They didn’t lie; they certainly didn’t say “this thing works.” But this marketing rhetoric that “implies success” carries a distinct suspicion of treating users like fools.
2. The Uncanny Valley: When Code Becomes “AI Slop”
Here we need to introduce a concept that has been trending recently: AI Slop.
Previously, we judged code quality by architecture, comments, and algorithmic complexity. Now there is a new dimension: does it have a “soul”?
The fastrender codebase presents a typical “AI hallucination aesthetic.” The code structure looks neat, function names appear legitimate, and even the file directories are organized. But when you dive into the details, you find that the logic is fractured, and the intent is blurry.
This is the “Uncanny Valley effect” of the coding world. It looks too real, yet it lacks vital signs.
This is currently the biggest blind spot of Agent programming: Tactical diligence, but strategic intent is missing.
Hundreds of Agents are like hundreds of tireless interns. Everyone is coding desperately, everyone thinks they are building a rocket, but no one looks up at the blueprints, and no one even presses the compile button. They are just constantly generating Tokens because their reward mechanism might just be “completing the task,” not “making the program run.”
Does this sense of “it doesn’t work, but I wrote a lot” remind you of those bloated weekly reports in big tech companies written just to fill space?
3. The Judgment of the Compiler: The Last Line of Defense in the Silicon World
Why do I care so much about cargo build?
Because in software engineering, the compiler is the only objective, unbribable judge.
When human teams develop software, even for an early MVP (Minimum Viable Product), the baseline is “it runs.” We have traffic light tests; we have Code Reviews. If a human engineer submitted code with 34 compilation errors and 94 warnings, they would likely be dragged into a small meeting room by the Tech Lead for a serious talk.
But Cursor’s experiment tells us: Agents don’t need dignity; they only need compute.
In this experiment, cost is displayed in a terribly distorted way. Cursor shows off “millions of lines of code,” but this is precisely the biggest waste. If 90% of those 1 million lines are non-functional slop, this isn’t just a waste of computational resources; it’s a plunder of human attention—because humans will eventually have to clean up this garbage.
This forces us to rethink the definition of “efficiency.” If AI efficiency is measured by “generation speed,” it won long ago. But if it’s measured by “usable output,” in this case, its efficiency is lower than a college student who has been learning Rust for two months.
4. Unfinished Thoughts: What If the Future is Full of “Look-Only” Code?
To be honest, I don’t feel any schadenfreude over Cursor’s “car crash”; instead, I feel a chill down my spine.
If this is the prototype of future software development, we might be facing an era of “Technical Debt Hyperinflation.”
Imagine a future GitHub flooded with these “zombie projects” generated automatically by Agents—looking extremely professional, fully documented, but completely unrunnable. In this world, the cost of distinguishing truth from falsehood will rise exponentially. We might need specialized AI just to identify which code was blindly made up by another AI.
Could we even see a more absurd scenario: software no longer strives to “pass compilation,” but relies on another extremely powerful AI to “patch” these logical loopholes in real-time during runtime? The so-called “Just-in-Time Debugging”?
If this prediction comes true, future programmers might really only have two career paths left: “Prompt Engineers” and “Garbage Classification Specialists.”
5. Final Words
Cursor’s experiment might be a magnificent failure.
It tore off the overly optimistic veil of “fully autonomous programming” and placed the bloody reality of engineering on the table: Piling up compute does not equal engineering capability, and generating Tokens does not equal writing software.
For us bystanders, the next time we see a shock-value headline like “AI actually built this!”, let’s keep our wits about us.
Don’t just look at the screenshots. Don’t just watch the video. Pull the code. Run the Demo.
After all, in this AI era where truth is hard to distinguish, the compiler might be our only remaining polygraph.
References：
