AI Coding Takes Away the Joy of Handcrafted Code

From the train heading back to Beijing, the window framed a dark night dotted with scattered lights. Crossing this long darkness, work begins tomorrow. Thinking that tomorrow I'll probably open Codex again, I suddenly recalled the various feelings I had when writing code in the past. While I still remember, I might as well write them down. I'm afraid that after coding with AI for a while longer, even those once-familiar joys will gradually fade.

How do I describe the joy of the old-school programming era to someone new to the field?

The joy of seeing an alert go up online, staring at metrics, flipping through logs, tracing call chains, ruling out countless possibilities one by one, until the chaotic phenomena collapse into a clear causal chain, and clarity dawns. Now, just give Codex WebSSH access and it can find the problem on its own.

The joy of watching a project's complexity rise, existing designs gradually fail, concepts and logic in the system entangle and collide like molecules in random motion; then through renaming, abstraction, splitting, decoupling, introducing layering, modularization, and architectural patterns, restoring order to chaos, like cleaning a room. Now, just describe concepts to AI, provide documentation, and code grows on its own. Feelings for code gradually reduce to abstract numbers like +10000, -100 in the top-right corner of Codex.

And the fulfillment of writing code line by line, building a service by hand. Knowing exactly why each line exists, how the next line will affect the whole system, that grounded sense of certainty, is also fading away.

I used to think programmers mainly possessed three abilities: Root Cause Analysis, architecture design, and code writing. Whether it's platformization, configuration, design patterns, or architectural patterns, the essence is separating concerns between volatile and stable parts, abstracting stable, reusable functions, modules, and processes to build an orderly conceptual system that adapts to an ever-changing real world. The core pursuit of code writing is to keep the core code as 'thin' as possible while the system gets 'thicker', constraining complexity growth so the system remains within human comprehension and maintainability.

But are these design principles, born from human memory limits and cognitive load constraints, still as important in the AI era? When AI generates tens of thousands of lines in one go, it's already hard for humans to review every line. Does code maintainability still mean it must be understandable by humans? If future code is mainly written and modified by AI, do many of the constraints established for human understanding need to be re-examined?

Thinking back to earlier this year, I was still asserting confidently, 'How can you not look at AI-written code? How dare you!' Now, it feels like a different era.

Watching AI write code rapidly in the terminal, a sense of emptiness sometimes rises. Seeing the things I once struggled to understand, AI explains in a few sentences; seeing AI easily accomplish what I once spent great effort on, I wonder: were those nights spent troubleshooting a problem, those books read to write more 'elegant' code, all in vain? If AI had existed then, could I have gotten fewer sleepless nights and read more leisure books?

Of course, I know I can't do the math that way. That knowledge at least helped me solve real problems, and today it lets me roughly judge whether AI writes correctly. Complexity won't disappear because of AI. Systems still need maintainability, observability, performance, and reliability, but these concrete things that programmers once polished by hand might be gradually turning into abstract requirements posed to AI.

In the past, we wrote code by understanding the system, shaping it into our understanding as we went. Now, we generate code by describing requirements and defining constraints, then verify it matches expectations through testing and validation. The final result might be better, but the process is different.

In the code I wrote before, you could always find traces of my thinking and exploration. How a problem was discovered, why a piece of logic was organized this way, why a module was split into parts — these decisions remained in the lines of code. Occasionally flipping through code I wrote right after graduation, through those naive names, clumsy abstractions, and ugly implementations, I can still see a young man. What he understood then, where he made mistakes — after all these years, I can still discern some signs from the code.

Everyone needs things that belong to them. Those codes were immature, but I wrote them line by line — my own echo to myself.

Now, like Kong Yiji asking the child, 'Do you know the four ways to write the character for aniseed?' I want to ask myself entering the field this year, 'Do you know the design patterns for managing system complexity?' It's probably the same loneliness from a bygone era.

But the wheels of history roll forward. If I truly had to go back to the days of hand-writing code line by line and struggling to troubleshoot problems, I wouldn't want it at all. Those days weren't all joy either. The anxiety of failing to trace a production outage, the frustration with messy code, the weekends wasted away for no reason — thinking about them still gives me a headache.

It's just a pity that the joy that came with them seems to have disappeared too.

Maybe newcomers will find their own joys, just as we struggle to understand the feelings of earlier programmers punching holes in paper tape. Every generation has tools they take for granted and ways of working that seem natural.

I don't think there's anything particularly worth nostalgic about the past. It's just that those things that once made me happy, if I don't write them down, will soon feel foreign to myself.

Outside the window, sparse lights still twinkle. The train continues toward Beijing. Tomorrow at work, I'll probably open Codex happily and let it write line after line for me. As for the joy of hand-coding in the past, I'll leave it in this night.