Every time someone openly admits they use AI heavily to write code, a certain crowd reacts like you just stepped on their tail. Out comes the same tired script: what about fundamentals, what about the low-level stuff, what about raw hand-coding ability, what about the true spirit of programming. The performance is so dramatic you’d think that if a piece of software wasn’t typed out character by character by human hands, then the code is somehow impure, technical dignity is dead, and civilization itself is about to collapse on the spot.
But the biggest problem with that reaction is not even that it is emotional. It is that these people never figured out the basic question in the first place: what exactly are programmers being paid for?
Companies do not pay you to watch you flex muscle memory on a keyboard. They are not paying tribute to some sacred ideal of handcrafted coding. Most of the time, they are paying for one thing only: can you turn requirements into a working result with high enough quality, low enough risk, and reasonable enough cost, and can someone be accountable when it blows up. Code is just the medium. It is not the value itself. Treating code-writing as some holy act is basically like judging a carpenter by how elegant his hammer swing looks. It misses the point so hard it is almost impressive.
That is also why AI is not really disrupting professional ability itself. What it is disrupting is the chunk of labor many people wrongly mistook for professional ability all along. The first things AI compresses are repetitive implementation tasks: boilerplate, API glue, documentation lookup, first-pass scaffolding, routine refactors, test skeletons, template assembly. Sure, humans used to do all of that. But let’s be honest, a huge portion of it was never truly scarce value. It only looked important because nobody had a good enough way to automate it at scale, so over time people wrapped it in the language of craft and professional pride.
This is exactly where the old guard keeps screwing it up. They throw “fundamentals,” “production method,” and “actual value” into the same pot and stir it into soup. So the second AI devalues a certain way of producing software, they act like the entire profession has been insulted. But those are not the same thing. Being able to handwrite mountains of boilerplate does not mean you can model systems well. Memorizing endless API trivia does not mean you have sound judgment. Typing fast does not mean you can find the real root cause of a production incident. AI compresses implementation cost, not responsibility. What it weakens is the scarcity of low-leverage repetitive labor, not the value of high-leverage cognitive ability.
The real question was never “do fundamentals matter.” The real question is “which fundamentals are still worth keeping at the center.” If someone’s so-called fundamentals are mostly syntax recall, library memorization, hand-rolled scaffolding, and repeatedly troubleshooting routine issues that models and tools can now cover halfway decently, then the marginal value of that foundation is dropping fast. That does not mean it is useless. It means it is no longer worthy of being treated as the core source of professional pride. Meanwhile, the abilities that actually determine the ceiling of the outcome become even more important once AI enters the workflow: abstraction and modeling, architecture tradeoffs, boundary judgment, debugging strategy, risk awareness, performance tradeoffs, security constraints, maintainability, cross-system integration, and most importantly, knowing what to delegate to the tool and when you absolutely need to take over yourself.
To put it even more bluntly, what is valuable in the AI era is not “can I personally carry every brick by hand,” but “do I know how this building should be designed, which parts can be handed to machines, which parts need obsessive supervision, and who is responsible if the whole thing collapses.” A lot of development work used to be judged by manual density. Increasingly, it is judged by judgment density. The moat used to be “can I write it.” Now the moat is much more “do I know what should be written, why it should be written that way, how to verify it afterward, and how to clean up the mess when reality punches back.” That shift is the real story.
That is why I have always thought a lot of anti-AI outrage is not really about AI being useless. It is about AI exposing the fact that some old status markers are no longer as sacred as people wanted them to be. When “I can write it all by hand,” “I remember everything,” and “I do not need tools” stop being naturally scarce signals, some people instinctively misread the devaluation of a production method as the negation of their personal worth. But the market has never respected effort for its own sake. It respects whether your accumulated skill can reliably turn into results. You can spend ten years cultivating some divine manual coding technique, but if all it does is make you more attached to repetitive labor instead of making you better at defining problems, structuring solutions, and controlling risk, then congratulations, you mastered the wrong thing.
Of course, this does not mean AI is already powerful enough to replace everything. Truly infrastructure-level, research-level, high-complexity work still depends heavily on top-tier people. Compiler optimization, database kernels, operating systems, complex concurrent systems, graphics drivers, chip toolchains, formal verification, none of that is something you bluff your way through with a few prompts and a smug grin. The barrier there is not “can you produce code.” The barrier is “do you have the depth of theory, experience, and constraint-awareness to touch the parts that explode the second you get them wrong.” But here is the catch: most developers do not work at that level day to day. For a huge amount of engineering work with clear requirements, mature stacks, and relatively standard business logic, AI is already strong enough to force the industry to re-evaluate what abilities are actually worth paying for.
And this is exactly why I get annoyed when people love to whip out “low-level fundamentals” as a cudgel. It is not that fundamentals do not matter. It is that for a lot of people, “fundamentals” really just means “I suffered through this when I was younger, so you should too.” That is not professionalism. That is historical path dependence dressed up as a moral argument. People who are actually good do not chain their value to some aging form of labor. They pull AI into their workflow immediately, automate the hell out of whatever can be automated, and move their energy upward into the harder, more expensive, rarer layer of judgment. Clinging to labor that gets cheaper by the month and calling it dignity is basically the same as hugging an abacus while yelling that digital watches have no soul. Great theatrical energy. Very vintage. Not especially profitable.
At the end of the day, AI has not made learning obsolete. It has forced learning to split into layers again. The knowledge tied to judgment, responsibility, and constraints matters more than ever. The knowledge mainly tied to repetitive implementation labor is being absorbed by tools at accelerating speed. Someone who cannot think and uses AI just becomes a more efficient garbage factory. Someone who can think uses AI to push eighty percent of the work forward with a fraction of the effort, then saves the actually valuable brainpower for the hardest final twenty percent. The gap does not disappear. It just relocates.
So the people who really deserve to be mocked are not the ones using AI. It is the ones who still have not figured out what makes them valuable in the first place. A programmer’s value has never come from personally typing every line of code. It comes from turning vague requirements into reliable systems, breaking hard problems into executable paths, and preserving the ability to judge, verify, and take responsibility even as the tools get stronger. AI is not changing professionalism itself. It is changing the center of gravity of professionalism. If your sense of professional dignity is still tied to “I personally typed a few thousand extra lines,” then you have parked yourself in the exact spot most vulnerable to devaluation.
So if someone still blows up on reflex every time they see AI-assisted coding, the real question they should be asking is probably not “how can you not write it by hand,” but “if this repetitive labor is no longer scarce, what exactly do I still have that cannot be replaced.” It is an uncomfortable question, but a real one. Because what AI is actually bringing is not the end of the programming profession. It is a brutal but necessary repricing.