48 hours. Less than 10,000 lines of code. End-to-end working.
I picked up that small box, deployed a model that had been released just two days prior, and watched the inference results come out. The feeling at that moment was strange—not excitement, not a sense of achievement, more like a dazed "oh, so this actually works."
By the way, I don't know how to code at all. I've never done software development.
And before this 48-hour sprint, I had gone through another 10-day marathon—producing nearly 300,000 lines of code, then deleting almost all of it.
This kept me thinking for a long time.
How It All Started
It all started with the release of Claude Opus 4.6.
The first time I used it, I was genuinely shocked. Not the "wow, that's amazing" kind of shock, but the "wait, what are the limits of this thing?" kind of shock.
An idea popped into my head: could I get it to build a project from scratch for me?
I roughly explained my idea, and it wrote an architecture document for me, then started development. Two days later, we had a prototype. Watching it write code line by line, I had an indescribable feeling—like watching a stranger build a house for me. I didn't know if the house was structurally sound, but it was being built.
As I continued, I started pondering a question: how could I get AI to work for me 7×24 and actually create value?
I saw two paths: first, have it compare the architecture document against the code to identify opportunities and implement them on its own; second, do massive amounts of real testing, running real operations on real devices, letting it observe bugs and fix them itself until the pipeline worked.
Looking back, both paths were a bit naive. But at the time, I genuinely thought they were feasible.
So I began a crazy experiment. While traveling, I used SSH + tmux on my phone to remotely control the entire development process. I consumed an absurd number of tokens—I won't say exactly how many, it hurts to think about.
Ten days later, the project had accumulated nearly 200,000 lines of Go code plus 100,000 lines of test code.
It had become a massive mountain of code.
And the strange thing was: during those 10 days, I had never actually used the product myself. I just had it write code, reviewed it, and had it write more.
Struggling in the Quagmire
When I finally stopped and started actually testing, problems emerged.
The most basic main pipeline simply didn't work.
I was stunned for a moment. 300,000 lines of code, and the basic pipeline didn't work.
I had the AI fix things based on test results. Fix, test, test, fix. Back and forth, and finally the pipeline worked. That moment felt pretty magical—after all, I'm a technical outsider, and in 10 days I had actually gotten a complex platform software running.
But soon, I discovered a deeper problem: any small change required an absurd number of tokens.
A 200,000-line project was incredibly difficult to modify. Like trying to excavate on a mountain of spaghetti code—slow, changes often didn't work well, and cost money. I watched the token consumption climb rapidly and started to panic.
I began to reflect: these 200–300k lines were cranked out in 10 days, and it seemed most of the code wasn't actually creating value. I had just been thinking of features and having it implement them, then reviewing, then developing and testing more.
This wasn't creating value. This was accumulating liabilities.
Tear It Down and Start Over
I made a decision: start from zero, build a new project.
This decision wasn't easy. 300,000 lines of code, deleted just like that—it stung a bit. But the more I thought about it, the more I realized keeping it would be the bigger waste.
This time, I spent a long time having deep conversations with Claude Code.
I asked it: what core problem am I actually trying to solve? What social value does solving this problem create?
Honestly, my initial motivation was simple—I just wanted to vibe code something similar to what the company built last year, to surprise everyone and prove that someone with zero coding background could make a decent product. A bit of showing off, I admit.
But now my mindset has changed. I want to do something truly meaningful, solve problems that actually matter to society and the world.
How did this shift happen? I'm not sure. Maybe it was when I deleted those 300,000 lines of code and suddenly realized: if what you're doing is inherently meaningless, then no amount of code is just self-gratification.
We went back to the core process of building a product: writing MRD documents, writing PRD documents, then architecture design.
During the architecture phase, I spent a lot of time on deep research—selecting architectural components, understanding what could be used and what shouldn't be, making key decisions.
I gradually realized something:
In the Vibe Coding era, implementation becomes fast, so product design, philosophy, principles, and architectural choices become incredibly significant. In 10 days, AI can produce a deceptively plausible mountain of spaghetti code. All subsequent investment becomes a continuous massive waste.
This time, I became much more prudent.
Every line of code is actually liability, not asset.
Because the more code you have, the harder AI maintenance becomes.
48 Hours of Restraint
Later, I spent half a day plus a night building an architecture and product that I felt was meaningful and valuable.
I documented the problem, innovations, and design philosophy all in the project.
During development, at around 5,000 lines of code, I started doing real testing on the most core functions and components. I brought in heterogeneous hardware, engines, and models early for real validation.
Before every change, I would ask: does this violate the design principles and philosophy I explicitly wrote down?
I often had to rework things.
This process was genuinely painful. I realized that even a powerful model like Claude Opus 4.6 isn't omnipotent. Maintaining restraint and simplicity really takes a lot of time, repeatedly laying the foundation. Sometimes changing one thing took several back-and-forths, and I started doubting if I was being too pedantic.
But later it proved that this pedantry was right.
48 hours later, end-to-end working.
One-click model inference deployment on the device. Tested some new capabilities—a model released just two days ago, running on our small box.
That feeling was truly strange. Not excitement, but a grounded "yes, this is the right path."
And at this point, the project's code volume wasn't excessive. AI maintenance, changes, and comprehension were still reasonably priced and fast.
I judged: this thing is actually feasible.
More Exhausting Than Actually Coding
Throughout this process, I discovered that collaborating with a Coding Agent is actually much more exhausting than writing code myself.
It's easy to enter a flow state—one Claude Code waiting, start a new one. Stuck? Start another. Constantly checking back on each one's progress, removing blockers, correcting course when things go astray, and thinking through the impact on the overall system.
After 5–6 hours, it feels like playing an intense video game, but triple-boxing solo.
Mind is mush. Body is drained.
I used to think vibe coding was easy—let AI do the work, you relax. Actually doing it, I found that's not the case. It's more like going from "the person writing code" to "the person directing five people writing code"—you don't write yourself, but you make more judgments, coordination, and decisions.
It's genuinely exhausting. But also addictive.
Epilogue
10 days to pile up 300,000 lines of code, then delete it.
48 hours, less than 10,000 lines of code, working.
Vibe Coding isn't magic that makes things easier. It's a lever—it can amplify your efficiency, or amplify your chaos.
Now I ask myself one question: before starting, have I figured out what truly matters?
This is a question AI can't answer for me.