当我不再手写代码后,才真正发现编程的价值 (English)

Generated: 2026-06-23 12:50:22

---

Translated to English, keeping the storytelling style:

---

This time last year, I was literally banging the table, telling people: "AI writing code? That's just a toy."

Let me tell you something, straight from the heart—

I really thought I was smart.

Last year around this time, I was staking my professional pride on arguments: "AI? Sure, it can write a Hello World. Touch a real system? No way." That tone, that confidence—I might as well have tattooed "real programmers write code by hand" on my forehead.

So what happened next?

Well, I got curious, took the bait, and tried out Claude Code and Codex myself.

Guess what?

I sat there in front of my computer, stunned for a long moment, and then cursed myself: "You dumbass."

Not because I was wrong. But because I could have known the truth six months earlier—if only I hadn't spent half a year fighting myself.

A ten-year veteran programmer, now hasn't written a single line of code by hand in almost a year

Before I go further, let me lay out my credentials.

I wrote Java professionally for ten years, then moved on to Scala for data engineering. I've dabbled in Python, Go, C++—you name it. A while back, I would've called myself pretty solid with my hands.

But do you know how I work now?

I open my laptop in the morning, speak to Claude Code: "Hey, take a look at that production bug from last night. The logs are in the xxx directory." It digs through the code, runs tests, pinpoints the issue. I just sit there, coffee in hand, waiting for the verdict.

Last week, we needed to add UTF-8 support to an old project. I casually mentioned that the project was missing a test framework.

Back in the day, how long would that have taken? At least two days. Find the libraries, configure the environment, write test cases, set up CI—every step in the chain.

That day, I finished it in two hours. Two hours. And most of that time was spent telling the AI what I wanted and what I didn't want.

You ask, what's the quality of AI-written code like?

Let me put it this way: for a codebase hundreds of thousands of lines long, a few hundred lines of functional code with comments? Half a minute, done deal.

I honestly haven't written a single line of serious code by hand in months.

And I don't feel ashamed. In fact, it feels pretty damn good.

Floated high for three months, then got slapped back to reality

In the beginning, I'll admit it—I got cocky.

"Ten minutes to build a website? Easy!"

"Refactor the whole module? Give me an afternoon."

I pretty much delivered on every boast I made. For a while, I felt like some kind of genius who could just lie back and still produce.

But when it came to actually using it to build and maintain a production-grade business system, problems started popping up like weeds.

First, AI will quietly, silently, lie to you.

You change module A, and it quietly breaks the state in module B. Then it acts like nothing happened. If you don't review it carefully, it'll plant all kinds of hidden landmines. You think it understands the global logic of the system? Don't kid yourself.

Second, it loves reinventing the wheel.

There's already a perfectly good utility class in the system, but it insists on building its own from scratch. To add one simple feature, it'll write a whole pile of redundant code that sits awkwardly alongside the existing system. The bigger the project gets, the harder it becomes to change. Fix one bug, introduce three new ones. You end up in a death loop.

A lot of people tell me: this is because the models aren't smart enough, the context window isn't big enough.

I don't buy that.

The essence of AI isn't a wish-granting machine—it's a super execution engine

After nearly a year, I've figured one thing out—

AI coding isn't magic. It's a super execution tool. It can write beautiful syntax and deduce local logic. But don't expect it to understand the whole system—macro-level understanding, domain boundaries, state consistency? It knows almost none of that.

Think about it: would you trust an intern to independently manage an entire microservice architecture?

That's basically what AI is doing. It just writes faster.

And that brings us to a highly counterintuitive reality—

The closer the marginal cost of code generation gets to zero, the more exponentially the complexity of the system grows. Features become dirt cheap, but maintaining order becomes ridiculously expensive.

See, all those things that used to seem "soft"—architecture design, technology choices, boundary constraints—they've become ten times, even a hundred times more important in this era.

The father of Redis said something that really hits the mark: what's interesting now isn't writing the code itself, but figuring out what to do and how to do it. In that regard, AI is indeed a top-notch partner.

The biggest trap I fell into: letting AI reinvent the wheel

You ask me the biggest lesson from this year?

It's letting AI run free.

You tell AI: "Implement a tree-like list with drag-and-drop sorting." Without constraints, you watch—it'll probably start from scratch. Raw DOM APIs, coordinate calculations, state management, physics-based animation algorithms…

From a local perspective, this code might run perfectly.

But in a production environment? Disaster.

Complex logic built from scratch inevitably has edge-case flaws, and it's completely out of sync with the existing code style.

Eventually I wised up. Every time, I give AI clear boundaries: "Use the existing component library in the project. Reuse the utility classes. Don't reinvent the wheel."

Just that one sentence tripled the code quality, at least.

Does "old-school programming" still have value?

Now, there are two camps online fighting fiercely.

One side says: "Writing code by hand is meaningless. AI can do it all for you."

The other side says: "If you don't understand the underlying principles, you're just reading a black box."

My take? Both have a point, but neither tells the whole story.

When you use AI to write code, can you quickly take over, modify, and extend it? That depends on your depth of understanding of that language.

I use Java. AI-generated code I can tweak on the fly. Give me Go or Rust, no matter how beautifully the AI writes, it takes me a lot more effort to pick it up.

The difference isn't about writing code or not. It's about whether you own the code.

That leads to a pretty direct conclusion—

Without old-school programming skills, you'll never truly own the code AI generates.

AI can help you write it, but it can't understand it for you.

Boris Cherny, the father of Claude Code, gave a metaphor I think is brilliant:

Before the printing press, only 10% of Europe's elite were literate; scribes held the keys to knowledge. After the printing press appeared, those scribes didn't lose their jobs—in fact, they were freed from the drudgery of copying, and they loved it.

Right now, programmers are in that state.

Vibe Coding is fun. Enjoy it while you can.

Four honest suggestions, no fluff, no pretension

After all the stumbles, I've got a few things worth sharing.

First, use the most powerful model.

Boris is right: saving tokens isn't worth saving time. A weaker model introduces more errors, which cost even more effort to fix.

You may not believe this—my monthly token bill is now more than my salary. But the efficiency boost is totally worth it.

Second, build a rule system.

I set up a three-tier rule structure: global common rules, project-level constraints, and current task context. Before AI writes any code, I feed it these rules.

The effect? Night and day.

Third, don't be lazy when you need to write by hand.

Core architecture design, critical business logic decisions, system boundary partitioning—for these