What AI coding costs you
tomwojcik.com
tomwojcik.com
I remain because I remain hopeful the pendulum will swing the other way someday.
I've found that I reach for Copilot most often when working on frontend javascript code. Will the incentive to improve the frontend libraries, browser standards, etc vanish now that LLMs let us avoid some of this pain?
This could even happen through accidental evolution - a framework that is easier on an LLMs context window results in more successful projects, which results in more training data, which results in LLMs being even better at it.
I believe and hope eventually we'll come around to valuing people who have put in the work - not just to understand and review output but to make choices themselves and keep their knowledge and judgement sharp - when we fully realize the cost of not doing so.
Of course, having learned a few languages, understanding data types, knowing to prompt it for idiomatic code and check against best practices, etc is vital to being able to do that. The basic skills need to be developed even if not everyone gets the same value out of being able to write code.
Yeah nicely said.
(Big fan of SQLAlchemy)
I describe what I want roughly on the level I could still code it by hand, to the level of telling Claude to create specific methods, functions and classes (And reminding it to use them, because models love pointless repetition)
Is it faster? Sure, being this specific has the added benefit of greatly reduced hallucinations (Still, depends on the model, Gemini is still more prone to want to do more things, even when uncalled for)
I also don't need to fine comb everything, Logic and interaction I'll check, but basic everyday stuff is usually already pretty well explained in the repo and the model usually picks up on it
If I don't solve math problems I won't understand how to solve them, no matter how many times I see videos of people solving similar problems. This is what LLM usage early on will ultimately lead to, and anyone who will claim "oh, by the time I'll be senior the LLM's will be much better than me" only proves my point.
Did I ever feel joy from trying to figure out the api of an obscure plotting library? No. And thankfully I never have to do it again.
But I'm gonna say I've always seen "[retail software] is just a tool" as an odd statement. I've heard it a lot over the last 20 years. "Just" a tool. Why always phrased like that? How can we be overthinking the role of a tool while you're in the middle of a multi-page essay about how it causes cognitive decline?
Nobody frets about the effect of a screwdriver on some IT rando's ability to do other computer stuff if on occasion they're screwing something into a rack. Seems odd to be so consistent about privileging the concept of a "tool" when you're saying that tool is on its way to thought.
>I’m addicted to prompting, I get high from it
yikes, but I did appreciate this honesty. Though, again: "this hash pipe is just a tool" did not appear after this statement
Also - isn't addiction behavioral, as opposed to strictly neurological? Maybe you should do a follow-up on the behavioral effects of a situation like "There’s no spark in you anymore." If you found a new identity that wasn't "I'm a prompt addict," what would it be?
It hit the front page here a few weeks ago, but I don’t think most people took it seriously and got hung up on the $1000/day in tokens part.
I am convinced that approach is the future of nearly all software development. It’s basically about how if you’re willing to spend enough tokens, these current models can already complete any software task. With the right framework in place, you don’t need to think about the code at all, only the results.
I really don’t like that the industry is heading this way, but the more I consider that approach, the more I’m convinced it is inevitable.
Open source, hobbyist and personal projects will probably remain the last bastions of “human in the loop” and human-written code, and I suspect these circles will retract into smaller, tighter circles.
AI can write the code, but not tell you what code you want it to write. In other words, how long are your specs? Either the LLM decides "whatever" or you have massive amounts of documentation to coordinate.
We still need to decide what to build, and some of the how. That is not automate-able, yet everyone seems to gloss over that bit.
Imagine you were working with a very talented software shop. You might tell them your preferences sometimes and some things you want changed, but otherwise they mostly just build the right things the right way. And unlike a real software shop, the LLM system can implement changes incredibly fast.
Here's some of the literature I dug up when looking at what is the potential risk to cognition when you don't enjoy what you are doing.
Working memory is "gated"; you selectively process information relevant to a goal - or why you need to turn the radio off to reverse a car. (Numerous papers take it as a given, can't find a specific one developing the exact model of gating)
On working memory and trainability: https://www.nature.com/articles/nrn.2016.43 Working memory is (potentially) dopamine responsive, and expanded by use/training.
On building mental models, writing something down activates more of your brain than typing (cognitive offloading): https://www.scientificamerican.com/article/why-writing-by-ha...
I would argue that typing is better than just reading, and programming requires some extra elements - as you cut and paste to rearrange, run tests, iterate, spatially navigate to where various areas of your code is; so is likely closer to the findings around handwriting than the study. But I don't have specific studies on that.
On reward ($) as a proxy for enjoyment/flow state; and motivation; these two used similar basic designs to experiments https://www.nature.com/articles/s41598-025-09949-1
"Participants performed a delayed-estimation orientation working memory (WM) task with reward cues indicating reward levels at the beginning of trials. The results revealed that motivational incentives significantly improved WM performance and increased pupillary dilation during maintenance. These findings provide evidence for the modulation of WM maintenance by reward through enhanced top-down cognitive control processes."
https://www.jneurosci.org/content/39/43/8549 > "During the task, the prospect of reward varied from trial to trial. Participants made faster, more accurate judgements on high-reward trials. Critically, high reward boosted neural coding of the active task rule, and the extent of this increase was associated with improvements in task performance"
You can also infer from their experiments that low reward = less care exercised.
I feel like a lot of these papers aren't really surprising, but they do measure something that many people have probably felt is true but can't prove.
While these papers don't talk about AI or decline in skills specifically, it's reasonable to say you don't get many of the benefits when it is low reward/passive task execution; where you are leaving review comments that are just reprompting a machine - you know it's not a person, so it feels even lower value to engage than a standard code review might.
I think overall, the rule of thumb around when to use AI should be closely linked to how painful / low reward a task is likely to be. Debugging something with a 10 minute build/test loop and a mystery problem that is not easy to control? AI party. Writing a complex but fun set of business rules? Run it on your wetwear while it is still giving you a sugar hit. An "easy" bug you have stuffed up fixing three times in a row? Push through a bit of discomfort and frustration; but fall back to tooling when you have invested reasonable efforts and are starting to feel slightly fatigued.
What resonated most for me was the "Finding Your Threshold" section. Your "Developers need the dopamine hit of creation." is memorable. I have also blogged about this phenomenon at https://www.exploravention.com/blogs/soft_arch_agentic_ai/ but I frame it more as how leaders can help the organization arrive at a healthy and sustainable balance between writing and reviewing code.
It's addictive. You're fast, efficient, you feel like you're in control. All while you're slowly losing grip.
I love how nuanced your takes are. The biggest challenge of this new programming paradigm is not to see how you can use it to its fullest extent. It is to find out what a sustainable pace is, both sort and long term.
It is hard to understate how difficult that is.
Could've outsourced a long time ago to humans, if I wanted to deal with reading code most of the time instead of writing it.
Given all that, I just cannot ignore AI as a development tool. There is no good justification I can give the rest of the company for why we would not incorporate AI tools into our workflows, and this also means I cannot leave it up to individual developers on whether they want to use AI or not.
This pains me a lot: On the one hand, it feels irresponsible to the junior developers and their education to let them outsource thinking; on the other hand, we're not a charity fund but a company that needs to make money. Also, many of us (me included) got into this career for the joy of creating. Nobody anticipated this could stop being part of the deal, but here were are.
And it is. You are going to end up with a wreck of a product and not a single person you can call upon to fix it. It is your choice and you will pay for it.
ookay..
I'm just recognizing that businesses have challenges to deal with besides quality. Being able to generate revenue is just as important as software quality. And seeing how easily consumers switch to a competing product if it has a few more features, you can't neglect time to market if you want to survive as a company.
Many customers are pretty shallow: "meh, the new version looks just like to old one, nothing has changed" even if under the hood the product has significantly improved.
Is there definitive proof of long term productivity gains with no detriment to defects, future velocity, etc?
If so I’d say you’re irresponsible at best to put this much trust in a tool that’s been around for a few months (at the current level). Absolutely encourage experimentation, but there’s a trillion dollar marketing hype machine in overdrive right now. Your job is to remind people of that.
Consider what a job with no joy means for the ongoing mental health of your staff, where the main interaction they have all day is with an AI model that the person has to boss around; with little training on norms. Depression, frustration, nonchalance, isolation, and corner cutting are going to be the likely responses.
So at the same time as you introduce new tooling, introduce the quality controls you would expect for someone utterly checked out of the process, and the human resources policies or prevention to avoid your team speed running Godwin's law because they dont deal with people enough to remember social niceties are important.
Examples off of the top of my head of ways to do this are: - Increased socialisation in the design processes. Mandatory fun sucks, a whiteboard party and collaboration will bring some creativity and shared ownership. - Budget for AI minimal or free periods, where the intent is to do a chunk of work "the hard way"; and have people share what they experienced or learnt - Make people test each other's work (manual testing) or collaborate, otherwise you will have a dysfunctional team who reaches for "yell in all caps to make sure the prompt sticks" as the way people talk to each other/deal with conflict.
The way to justify this to management above you is the cost of staff retention - advertise, interview, hire, pay market rates, equip, train, followed 6 months later by securely off boarding, hardware return, exit interview means you get maybe 4 months productivity out of each person, and pay 2 months salary in all of the early job mistakes or late job not caring, or HR debacle. Do you or your next level up want to spend 30% more time doing this process? Or would you rather focus on generating revenue with a team that works well together and are on board for the long term?
The answer most of the time is "we want to make money, not spend it". So do the math on what staff replacement costs are and then argue for building in enough slack to the process that it costs about half of that to maintain it/train the staff/etc.
Your company is now making a "50% efficiency gain" in the HR funnel, year over year, all by simply... not turning the dial up to 10 on forced AI usage.
Framed like that, sounds a lot better doesn't it?
Having said that: The dichotomy expressed in the threads here is a bit too extreme for my taste. It's not like working with AI is pure Yes-clicking review dread; there is joy to be found in materialising your ideas out of thin air, instead of the Lego-like puzzle solving experience many developers are used to.
And as mentioned in TFA, There's risk in both using it too little and too much. This also applies to employees, of course: If I shielded junior developers from AI tools, they'd end up in their next job utterly unprepared for what may be required from them as the world keeps spinning.
> Framed like that, sounds a lot better doesn't it?
Sure does, but that's not the situation I'm in. I'm trying to figure out the local maximum of keeping my company afloat in a world where AI has kicked the PMF from under our feet to the other end of the playing field, and ensuring my team stays happy, curious, and engaged. And I'm not the only one in this spot, I suppose.
I think that's true for some developers, and not for others. My guess is that one subset of developers has more ideas than they have time/resources to implement, and they enjoy programming because they love seeing the finished product emerge. I think this subset is more likely to go into management, because it's a force multiplier for them. They're the ones getting joy out of seeing AI make their ideas into reality.
But there's another subset who enjoys programming not because they love to see a product emerge, but because they enjoy the process itself: the head-scratching, the getting past "why won't this work" to the moment when the build starts working again or the site comes back up or the UI snaps into place. It's the magic of finding, among all the possible wrong answers, the exact right combination of bits that solve the problem. This subset is not getting any joy from AI: they're seeing AI take away that whole process and turn it into the kind of work their managers and their project owners do. It's made even worse because their managers don't even understand why they're so unhappy. I think managers would do well to consider how they're going to keep these folks happy and engaged and productive, because they're the ones who are going to be fixing the production bugs introduced by their teammates' AI commits. If they've all gone off to retrain as electricians, we're going to have a problem as an industry.
The concern as well is that by forcing the AI onto developers, they eventually throw their hands up and say "well they dont care about code quality anymore, neither should I" and start shipping absolute vibeslop.
It's not that the team isn't functioning, it's that it's a pretty diverse team in terms of experience, which means things just used to take a while to finish.
> The concern as well is that by forcing the AI onto developers, they eventually throw their hands up and say "well they dont care about code quality anymore, neither should I" and start shipping absolute vibeslop.
This is IMHO avoidable by emphasising code reviews and automated tooling; my general policy is still that everyone is responsible for what they push, period. So absolute vibeslop isn't what I'm seeing, rather an efficiency miscalculation on which parts should be written by humans and which by the AI.
I know, from second hand experience, that long before coding LLMs became a thing, engineers would ship slop when it became clear that their superiors cared about deadlines uber alles (i.e. not shipping slop would be the same thing as quitting, but without the paycheck -- slop code is often a form of quiet quitting).
Most people would _prefer_ to be able to "program" their entire business from a spreadsheet. LLMs have enabled them to get involved, and they cannot understand why engineers reject this "help" (it is for the same reason that a pilot would reject a copilot that thinks he knows how to fly because he played a flight simulator or read Jonathan Livingston Seagull; flight simulators are used in training too, but they are not a substitute for actual piloting experience). This refusal and resistance feeds into the mistrust and resentment. We live in a world where managers and administrators do not understand what they are managing and administrating, nor do they think that this is part of their job description. In the worst cases, they believe their job is to extract compliance from their subordinates.
There is a _lot_ of alpha in being part of a company, where authorities understand how the internals of the business (including software and IT!) _actually_ function. (One engineer told me that clueless yet demanding managers are, for all intents and purposes, unwitting saboteurs, and that the best a company can do about this is get him a job interview at a competitor). In some sense, the economy is just a machine for transferring wealth from those who do not know something essential, to those who do know something essential. This can veer uncomfortably close to exploitation. If we want to avoid crossing that line, we need to cultivate an economy where a lack of understanding is not seen as an _opportunity for profit_, but rather _as an opportunity for illumination_.
I’m sure you’re smarter than that, but a lot of leaders aren’t. And that’s based on the past, when they had an established playbook they could choose to follow, not the situation we’re in now where you have to make it up as you go.
The term "vibe coding" is new, but I've described what I do as "jazz coding" for a couple decades.
I've used AI tools in the past for maths I didn't understand or errors I couldn't make sense of, and wrote the bulk myself, but now we have as mentioned, opus/sonnet 4.5- which work great.
As part of this, I had to integrate two new apis- nornally, when I write an API wrapper I end up learning a lot about how the API feels, what leads to what and how it smells, etc. This time? I just asked Claude to read it's docs, then gave suggestions about how I wanted it to be laid out. As a result? I have no idea how these apis feel, their models, etc. If I want to interact with them, I ask Claude how I do a thing with the library it made.
Mind you, the library is good. I looked over everything, it's fairly thin and it's exactly how I would write it, as I suggested it do. But I have no deep understanding, much less an understanding of how it got integrated in.
Like, normally when I integrate something in I learn a bit about the codebase I'm integrating it into. Do that enough times, and I understand the codebase at depth, how things plug in. This time? Nada.
It's.... Deeply uncomfortable, to know so little but still be able to do so much. It doesn't matter if I get it to explain it, that's just information that washes off when I move onto the next thing. The reflexive memory isn't built.
All of which is to say, I agree with the article.
I see no reason to regret that our skills in coding C++/Java/* will decline or athrophy at some point in time. This will mean that we just don't need them anymore.
To me, personally, this shift is really enabling and refreshing. I usually have lot's of ideas but did not neither time nor capacity to play with them. Some of them were just impossible to do as a team of one. Now everything is possible! :)
(Yes, I know the compiler does wild stuff behind the curtain, but unless you're using -Ofast, the assembly is black-box-equivalent to a naive compilation)
"Now, many years and programming languages later, with my coding skills in LSI-11 opcodes totaly athrophied, I do not regret about loosing that skill at all."
But the cognitive capacities you developed reasoning about opcodes almost certainly made it easier for you to learn FORTRAN and its successors.
LSI-11 opcodes, FORTRAN 83, C++, the lambda calculus, etc are all formal languages that we can reason about logically. It's also the case that we can implement machines (hardware or virtual) that can in practice produce the results that match our logical deductions. This is generally what people mean when they say these languages are "deterministic".
It seems obvious to me that it is more cognitively demanding to reason about formal languages like these, to prove to oneself that a given change in the code will produces the outcomes you intend, than it is to prompt for changes in the code and review it.
Product managers can't produce viable programs ready to be deployed in production (yet). But maybe the will able to do it in the future. We don't know how far or close this future is. But I don't think it's not a bad idea in general.
It's fleventy five
If the three good patterns are adhered to, these AI tools can help us become more knowledgeable, productive.
We get to retain our cognitive abilities and the desire to pursue code development as a means to solving hard problems.
Adopting the anti-patterns, on the other hand, could lead to over-reliance on AI, anxiety when the tools go down (this happens! ), the atrophy of ability to debug and the yearning for immediate gratification and quick fixes.
Most insidiously, when code inevitably fails in production on cases the developer should have reasoned about and covered, they have no option but to toss it back to the AI tool, thereby, creating a vicious cycle of anxiety, helplessness and cognitive decay.
1. A survival horde game (like Vampire Survivors and Brotato). At the moment it's very primitive, very derivative (no new ideas) and not much fun. I have no sense of pride over it, but it is much further along than it would be if i'd been writing it from scratch. I expect once I invest in the fun side (gameplay innovations, graphics) i'll feel a greater sense of attachment, and I plan to do all the art assets myself.
2. A MacOS web app for managing dev env processes, works but is ugly. I don't have confidence in AI making a remotely presentable UI, so I'll be doing that part myself.
3. A useful little utility library. The kind of thing that pre-LLM would've been too far out of my expertise to be motivated to try making. I'm steering the design of it quite heavily, but haven't written any code. It seems like it's already capable of doing very useful things, and I oddly feel quite proud of it. But I have a weird sense of unease in that I _think_ it's good, but I don't _know_ it's good.
I think the main thing I'm learning is to make sure there's always something of yourself in whatever you produce with the help of AI, especially if you want to feel a sense of accomplishment. And make sure you have a good testing philosophy if you're planning to be hands-off with the code itself.
Have we really reached the limit of how much we can reliably automate these things via good old metaprogramming and/or generator scripts, without resorting to using unreliable and expensive statistical models via imprecise natural language?
> Refusing to use AI out of principle is as irrational as adopting it out of hype.
I'm not sure about this. For some people, holding consistently to a principle may be as satisfying, or even necessary, as the dopamine hit of creation mentioned in the article.
When to use your mouse, when to use your keyboard, how to locate a file you want to look at in your terminal or IDE, how to find commands you executed last week, etc. It's all lacking. When devs struggle with these fundamentals, I suspect the desire to bypass all this with a singular "just ask the LLM" interface increases.
So when orgs focus on a "devs should use LLMs more to accelerate", I really wish the focus was more "find ways to accelerate", which could more reliably mean "get more proficient with your tools".
I think there's a lot of good that can be gained from formalizing conventions with templating engines (another tool worth learning), rather than relying on stochastic template generation.
This is true *only* in isolation. The pain of going through said depth of detail, is what builds the intuition for the whole system. Once and twice may not be noticeable, but a new habit, and that new habit's corresponding extreme downtime because no one understands the quirks anymore... Despite a few engineers who stake their life on the testing system, tests can't catch all issues. And it's extremely difficult to stop an oil tanker.
I would probably say a shell is "the correct tool for the job" but other than the appeal to authority, or appeal to tradition. There's not a great argument for a shell script over a language you're already comfortable with.
There are hundreds of examples that are easier or faster in python than shell.
Engineers are bad at making tooling, we're even worse making ephemeral tooling we're willing to throw away. Contrasted with other makers, you have machinests who gladly make a one off tool to make a single process easier.
The more 'correct way' than a shell script, is something simple and composable. A large unwieldy shell script that you can't make simple changes in, is terrible design, and it's a mistake to allow that inertia to gain speed.
It's not exactly a complete refutation but something I've been thinking about recently.
We had 1 week sprints and our PO had sometimes trouble to prepare enough work for the next sprint. We had 4 week sprints and we often ended up pulling tickets from the next sprint. There was often a mismatch in pace. (Quite funny, the time we had found a balance, management ordered all teams to have the same sprint lengths. They couldn't deal with all the asynchronous, overlapping sprint starts/ends. They choose to forfeit our productivity for theirs.)
So productivity isn't all about coders, it's also about owners / managers / shareholders supplying work. This kind of work is much about communication with several involved parties and researching usecases and features in a very specific context. LLMs can help with parts of it, but at one point there will be a flood of excessive, unverified generic reports and LLMs that again condense them with all the inaccuracies, that managers/owners may drown in a fuzzy mess of LLM bureaucracy. Nuances and importance will get lost in excess.
We often had rather large stories that simply had a small set of bulletpoints, because we already communicated everything in person and they were just reminders for the most important stuff. The importance here is that this reflected the teams agency how we solve things. An LLM can probably not at all provide that currently, as they are always excessive and try to add "helpful" details. They simply cannot pick up social norms and agreements, and prompting them correctly is in my opinion very hard or too time consuming.
LLM assisted coding or vibe coding is all the hype. But I have the feeling that the big realization sets in once all supporting processes are convoluted with AI noise, the peers that used to collaborate are detached and social conflicts and misunderstandings escalate.
Claude will, when given a task off the beaten track, churn through tokens for a while, then produce a completely incorrect answer. (Most recent anecdote: fixing a barostat in an MD sim)
Specifically: How does Spotify, a music streaming service, improve due to AI agents producing code all night? What is improving or being fixed which needs that much abstract code and problem solving? I am guessing the AI code is just building more messy architecture on top of the messy architecture which is causing so much work to be generated.
IMO, that’s what we should do as software engineers. The idea of letting AI "do the thinking" for you is a bad idea. Sure, it can trivially write a sort function for you. Let it! But you still need to understand how that sort function works. If having the tool was a substitute for understanding the fundamentals, anyone with access to Catia, etc. could design a working airplane.
cognitive debt is a real problem in my domain (embedded software) because AI simply can’t debug the symptom when the reasons for the bug aren’t in code, and a stack trace may not exist. finding the REALLY hard bugs requires in depth systems understanding and the ability to connect things you’ve seen around the codebase together - and the fix usually isn’t adding code, which means the patchwork fixes Claude likes to do only makes things worse.
that said, it’s made writing harnesses and supporting tools WAY easier and faster, and my workflow is better for it. Searching the git history for the why of things is also made way easier; helping me to reason more effectively
If you're working on a personal project or trying to learn something new, by all means write the code yourself. That's still the best way to do it. But your life should not necessarily revolve around work, and sometimes there is nothing wrong wih caring more about the end product than the process.
While it is a spectrum around when you choose to use AI, what seems increasingly common in my experience is some people trying to go "all in", feel frustration and burnout when they are relegated to babysitting an LLM; get angry that it has made a mistake, misinterpretation or simply left something obvious out; then thinking it's user error/they didn't prompt well enough/it is their fault. At the same time, they are increasingly cognitively blind to mistakes at a review stage, so they find out the hard way in production and enter into a cycle of hyper vigilance/distrust/justifiable paranoia.
In those cases, it's a recipe for skills loss and depression over the long term and a vicious cycle.
Apply this directly to fully agentic coding. If you stop writing code and only review AI output, your ability to reason about code atrophies. Slowly, invisibly, but inevitably. You can’t deeply review what you can no longer deeply understand.
I think this argument is flawed. On every team I've worked with we've always had the opinion that junior developers learn a lot about coding by reading and reviewing code written by other people, especially people more senior to them. Reviewing output doesn't weaken your skills, it improves them. Reviewing code in a large codebase forces you to explore and understand the paths that data takes. It pushes you to build an accurate mental model more than writing new code does, because that's usually isolated to a small, encapsulated domain where you only really need to care about the inputs and outputs (hopefully!).
The author is absolutely correct if you take 'review' to be 'click the accept button and move on', but if you're actually reviewing the code that your AI generates, and understanding it, and thinking about how to move forwards and prompt it to build the thing you really want, then AI only really removes the last type-the-code step. All of the architecture and process steps should be coming from you (maybe from a conversation with the AI during the planning step, but still, not just letting the AI do whatever it fancies.)
https://www.npr.org/2025/07/18/g-s1177-78041/what-to-do-when...
For instance I was thinking of AI coding where the developer is writing the application interface, files, design, and the AI in the background is reading them and translating them to the programming language of choice.
This way the developer is writing the whole thing out by hand, it would be as if one is writing fluid pseudo code, but the abstractions would be there, the way they are interacting with each other is there, the human is thinking if the abstractions and when to use them. Whereas the AI is out of the view, simply translating the fluid pseudo code to a rigid programming language.
Perhaps the above isn't really it, but I strongly feel something needs to change in the way we currently work, because it really creates a chasm between the developer and the outputted code not only in terms of the actual implementation but the mental abstractions it's supposed to reflect
This article also slapped me, and has crystallized my jumbled thoughts on the topic. I'm deep into my career as a productive software engineer, yet I'm concerned there is a visible vanishing point of my value. My retirement is also visible, but I'm more concerned about our trade and those of you who have many years ahead.
While adaptation is hard when moving a lightspeed, workflows must adapt, more time on imprinting the generated code into our heads with iterating on trialing, testing, editing, before PRs is prudent.
A larger problem is architectural drift and leak. Those feel like they could become extremely problematic. We’ll need to put more effort into steering agents so their output aligns with architectural goals. The steering will also need to be iteratively refined.
Great article! I’m concerned, but also rallying for us.
I would suggest leaving the keyboard, going outside and getting some real highs. Perhaps also leave behind all your technology and try to experience a non-connected life.
What is the world coming to when folks get a high from prompting a complex algorithm.
Oh well, it probably proves that “human intelligence” isn’t that complex. It seems fairly simple to simulate.
There are two ways to write software: either it obviously has no errors or there are no obvious errors in it.
LLMs tend to generate the latter. Because that’s what’s in the training data: all the code that was rushed to production with a promise it would be fixed later. And humans are notoriously bad at catching these kinds of errors.
It feels bad using tools like this because it turns you into a reverse centaur. You’re there because the tool cannot be held accountable. You’re the last mile delivery driver shipping the code. You didn’t participate in its construction and you take all the responsibility for it.
Only there are studies which demonstrate how small of an impact code review has on code quality. And that after reading a few hundred lines of code in an hour the effect disappears. Current AI processes aren’t equipped to handle this.
Whatever we’re doing it’s heading in the opposite direction of engineering.
Otoh: didn't Socrates say the same about writing? It rots the brain?
I agree that reducing engineers’ careers to code review will lead to burnout (amongst other problems).
But I think the reason we’re headed in this direction is precisely because creating with AI /can/ deliver “the dopamine of creation”.
It doesn’t deliver that hit for everyone - but it does for the half of engineers who are more excited about building new things than the act of coding.
Teams build more and ship faster because it’s so much easier to do that with AI - and it’s fun - and that leads to increased review load.
My principles have nothing to do with whether or not AI is giving me extra productivity though. Even if AI made me 5000x more productive I still wouldn't want to use it out of principle. I think it is a deeply immoral technology that shouldn't exist
I also think that people who research and build AI are deeply immoral people who should be tried for crimes against humanity
Because I have no doubt in my mind that AI is leading us towards crimes against humanity. We are going to be culled the moment we are not useful anymore.
I guess it reminds me of someone switching from a manual labor job to a desk job: you become at risk of physical issues from being more sedentary, but you can exercise after work or even some people have things like standing desks and such to keep active during the job
So there can be real risks but there should be ways to manage them
Even when it's not slop, the verbosity of poorly edited AI-generated content is a micro-agression against readers. The prompter expects readers to read what they couldn't be bothered to properly edit.
Pushing AI-slop code without review, and without explicit warnings is a macro-agression against your colleagues, collaborators, and future agents. You are expecting everybody around you to maintain/ refactor, what you couldn't be botherered to review.
Will the ability to review code (which is important now) become important in the future? Is it necessary to have a pipeline to nurture seniors?
Wouldn't it be more important to define clear requirements, verify that the resulting code operates properly within various guardrails, and clearly communicate the designed value, than to be able to review code?
The mismatch in time horizons between employers and developers will be so vexing.
At any given time, the profit-maximizing strategy for each employer is to have engineers ship features as quickly as possible. For each employee, it is rational to retain and strengthen skills by avoiding some amount of cognitive offloading.
Most insidiously, the temptation of cognitive offloading for the employee aligns with the profit-maximizing strategy of the employer.
And for blogging too, it seems.
I'd like to point out though, that you also learn by AI producing bad outcomes you are responsible for, and building intuition how it might fail through practice... You also might experience more lessons than you would have if you would have coded manually.
I don’t know how I will be able to build intuition for code I don’t write just “understand”
I've read hundreds of books. It may be thousands if you count the multiple series I devoured as a bookish child. I think my understanding of my mother tongue is probably in the top decile of native speakers.
But I haven't ever written a book. I'm not sure I would want to write a book, though I'm reasonably sure it wouldn't be the linguistic skills that would keep me from finishing one if I did.
Not having written any books doesn't keep me from knowing whether a book I'm reading was written well or poorly. I can tell that from my extensive experience reading a variety of books of different quality.
Maybe that's what's coming for computer languages. Maybe people who like reading, interacting with, and understanding computer languages will become highly skilled readers, with the ability to recognize well-written and poorly-written code. Perhaps they'll be the ones guiding the models to improve the code generation, or finding the structural changes that would improve the code for companies making truly important projects.
Or maybe we're just going to end up with incredible amounts of poorly written drivel that works well enough for some niche audience and makes a few bucks for the person who spins it up, and most software won't ever matter on any sort of large scale, just like most books aren't ever read. Maybe there will be some pockets that really care about writing very well and producing excellent things, and they'll hire the people who love bringing that about, and the rest of the people currently developing software will have fun little hobby projects that only their friends and family ever bother to use.
This doesn't seem that different from what has happened with written human language to me.
We only have a couple dozen letters, still it is possible to write new poetry.
Using simple mature tech stacks following best practices makes your product much better.
Developers have a strong desire to reinvent the wheel and it wastes so much time.
Innovative should only be attempted in your product domain if you are trying to make a successful company.
Are developers some kind of special creature? or must they simply learn to deal with the complexity of juggling multiple projects, like every other desk job in 2026.
Yea but for how long? Go back and read any code you wrote a year ago and realize it could have been AI that wrote it.
https://www.sciencedirect.com/science/article/abs/pii/S01602...
Likewise for physical exercise - it took me a year to hit 100kg squat when I started getting into shape 10 years ago. I haven't been very physically active for years but I'd hit 100x5 in a month of starting gym again.
The challenge is that the competitive and economic pressures make this moot.
A person, entering the field via AI driven development, will have none of the qualms about skill, seniority, understanding the codebase, or craftsmanship. Those arguments are handwringing by the previous generation of engineers. Their focus is solely on the outcome and value produced from the input prompt. That aligns closer to how businesses see their codebase: something they have to prompt their engineers to produce in order to generate business value.
Similarly, new AI driven companies focused on delivering value at speed and lower costs will have none of the baggage of the legacy code companies with engineers stuck debating these questions. These new gen companies will be focused on delivering value, doing so at quicker speeds and lower costs, raising the level of competition for existing incumbents.
Will existing businesses be willing to spend money to purchase services from these new gen companies of AI developed products? Seems like it.
There are real problems with these AI developed codebases. They tend to collect baggage and start to feel like a house of cards. A big open question is whether AI models will continue to improve in order to patch all the vibe-holes being generated. Seems like they will improve.
Copied to save you a click:
> I worry about the "brain atrophy" part, as I've felt this too. And not just atrophy, but even moreso I think it's evolving into "complacency". Like there have been multiple times now where I wanted the code to look a certain way, but it kept pulling back to the way it wanted to do things. Like if I had stated certain design goals recently it would adhere to them, but after a few iterations it would forget again and go back to its original approach, or mix the two, or whatever. Eventually it was easier just to quit fighting it and let it do things the way it wanted.
> What I've seen is that after the initial dopamine rush of being able to do things that would have taken much longer manually, a few iterations of this kind of interaction has slowly led to a disillusionment of the whole project, as AI keeps pushing it in a direction I didn't want.
> I think this is especially true if you're trying to experiment with new approaches to things. LLMs are, by definition, biased by what was in their training data. You can shock them out of it momentarily, whish is awesome for a few rounds, but over time the gravitational pull of what's already in their latent space becomes inescapable. (I picture it as working like a giant Sierpinski triangle).
> I want to say the end result is very akin to doom scrolling. Doom tabbing? It's like, yeah I could be more creative with just a tad more effort, but the AI is already running and the bar to seeing what the AI will do next is so low, so....
Currently I am working on a code base that is rapidly evolving for customer fit and is hoped to be around for a while. Going over recent decisions about what abstractions to focus on and what to cut it really seems like LLM tools would have been a waste for any aspect of this work. This is not a situation where some existing process needs to be encoded, and every choice about naming and structure ends up making a big difference as changes trigger refactors.
And this piece focuses on the early adopter point of view. Sure there were problems at first, but then whatsit tool thing version whatever came out and now roses are growing out of the rocks. For a large fraction of what is done with coding that makes sense, but there should always be attention to the rough parts and the gap that forms where capabilities fall off. Even a small amount of modesty can go a long way, but the conversation keeps starting off from every developer, all development, the change is now or else, and I for one am not buying that, especially not with actual money which is what these services will be charging soon in order to pay their trillion dollar debt service.
Output from AGIs used by experienced engineers tends to be vastly different quality than output from these leaders who are too disconnected from the slaughtering.
> Software used to be deterministic
Ah, someone fortunate enough to have never coded a heisenbug or trip over UB of various causes.
I've written plenty of well structured, well thought out mostly-deterministic software, then spent hours or days figuring what oversight summoned the gremlins.
(There is one low priority bug I've occasionally returned to over the last two-three years in case experience and back-burner musing may result in insight. Nope. Use gcc, no bug, use clang, bug, always, regardless of O level, debug level, etc. Everything else, all of it far more complex, works 100% reliably, it's just that one display update that fails.)
(It occurs to me that that is a bad example, because it IS deterministic, but none of us can pinpoint the "determiner".)
Assuming you're not tripping over some hardware defect, it sounds like you're using a gcc hack that llvm doesn't support
for a display update, sounds like memory ordering
Once these bugs were fixed, things became deterministic, but to say that all software is deterministic is to assert some level of programming, build, and operational consistency that is often achievable with great effort.
Re gcc hacks: nope. No gcc'isms anywhere in the code, all warnings enabled, no warnings produced, just one case where a field is not updated in one very specific set of circumstances. Thanks for the suggestion, but that was one of the first things we thought of. There is a slight chance that it is actually a clang/llvm call stack depth bug, but the effort to reproduce that outweighs the impact of the bug, what with one thing and another not relevant here.
UB -> occasional non-determinism.
Almost like someone never ever learned what the core of code development is....
This is why I use zettelkatsen as my own coding AI....long term results are far better than using AI to pretend to code.
What we’re working with -—unfortunately—-are vibes. It really seems as though AI coding will have this effect on people. Morally, it seems like it ought to have this effect on people. We should not be allowed to be at ease without some sort of cost. And if we can luridly suggest that you don’t pay with money all the better.
This allows for the piece to perform its function, even when it doesn’t fully commit to it. A work in the genre can say all sorts of nuanced things about agentic coding, while still keeping the core premise that those who resist or position themselves strategically will be the winners.
That’s possible! It’s entirely possible that we will see some skill atrophy that is broken down by AI usage AND materially impacts outcomes that matter. We for sure do not know whether or not that is the case. I suspect it is because we don’t ask what these predictions cost you, which is nothing.
If we look at the starting point for most people on this stuff, it’s basically last fall. The author points this out, but the necessary conclusion one was draw from this is that we don’t have enough information to tell what the cost will be. It may like moving to programming languages from assembly or moving to assembly from bespoke instructions—-fundamentally very little was lost in those transitions, despite there being a lot of carping about it. It could be like the introduction of the tablet in American schools, where what we lose is nearly everything. We really do not know. It might be prudent to be cautious in this situation, but we ought to respect the fact that this caution might be born out of an old paradigm.
If my ability to write code somehow atrophies because I stop doing it, does that matter if I continue with the architecture and strategy around coding?
The act of writing code by hand seems to be on a trajectory of irrelevance, so as long as I maintain my ability to reason about code (both by continuing to read it and instruct tools to write it), what’s the issue?
Edit to add: the vast majority of the code I’ve worked on in my career was not written by me. A significant portion of it was not written by someone still employed by my employer. I think that’s true for a lot of us, and we all made it work. And we made it work without modern coding assistants helping out. I think we’ll be fine.
It seems like that is the open question. The article suggests that people don't maintain this ability:
"The AI group scored 17% lower on conceptual understanding, debugging, and code reading. The largest gap was in debugging, the exact skill you need to catch what AI gets wrong. One hour of passive AI-assisted work produced measurable skill erosion."
From my own (anecdotal) experience I am seeing a lot more cases of what I call developer bullshit where developers can't even talk about the work they are vibe-coding on in a coherent way. Management doesn't notice this since it's all techno-bable to them and sounds fancy, but other developers do.
The embarrassment is understanding. It feels wrong, because in many ways it is wrong.
The only way I’ve had this feel any better is by using it on a non-critical internal tool. I can confidently say “I didn’t write any of this code because it’s a quality of life tool that only lives on developer manners and is not required at any point in our workflow.”
I also agree with the article that, unless computer science departments maintain some pretty strict discipline, this idea of a seniority collapse could be very real.
Will we need those senior engineers if AI keeps getting better? I don’t know. Maybe one day the AI systems are going to just be trusted to be able to untangle complex architectural problems.
If it wasn’t for leaded gasoline, rudimentary cancer treatment, and a good section of my modern video game catalog. I might be wishing I was born earlier.
Edit: I had an instance once where about once a month another developer would ask me about workplace setup, mentioned it to someone and was told maybe they were the English speaker of the group. Upon further investigation, that seemed to be the case.
I think it's also extremely worth pointing out that when you break down the AI using group by how they actually used AI, those who had the AI both provide code and afterwards provide a summary of the concepts and what it did actually scored among the highest. The same for ones who actually use the AI to ask it questions about the code it generated after it generated that code. Which seems to indicate to me that as long as you're having the AI explain and summarize what it did after each badge of edits. And you're also using it to explore and explain existing code bases. You're not going to see this problem.
I'm so extremely tired of people like you who want to engage in this moral panic completely misinterpreting these studies
Yeah, this is fair. However, I think the same study indicates a way out of this dilemma. I feel like I've actually learned a lot about the languages and libraries I've used that I haven't known before through agent coding just by watching it do things and having explained and summarized things to me and find documentation and so on.
> And to be clear, this isn’t moral panic, it’s a concern that we may end up in a future where people don’t know how systems work anymore and we are dependent on two or three companies and their data center moats to maintain any technology.
I don't think this concern in itself constitutes a moral panic, no. I think it's a reasonable thing to think about and worry about how to avoid. However, I think there are definitely very prominent features of the general discourse and concern around this that do constitute a moral panic:
1. First of all, and most importantly, this issue is very often moralized, around like having done a proper amount of work or suffered enough or whatever to be like justified in getting the results you're getting or participating or being considered a real program or whatever. This moralization has existed in the community for a really long time, treating programmers that work at a higher abstraction level than you as lesser than or whatever, so I would argue this isn't a natural response to these concerns so much as it is an extension of a moralistic attitude to a new topic and it's also not necessary to have in order to have these discussions.
2. The hyperbolic misinterpretation of studies, and the fact that these concerns are being raised as if they are going to be a certain, and huge, consequence when we just have very little evidence so far to that effect.
3. The fact that most of the discussion isn't about how to use these tools in a way that doesn't face these problems or whatever, but instead a sort of binary framing around either you suffer from this problem or you boycott.
4. The way the idea of "cognitive debt" and these other things is used to frame it as anyone using AI has their brains "turned to mush" or whatever, as if it's some kind of like general debilitating cognitive injury inside of just that you're getting rusty at skills because you aren't using them, even using scaremongering terms like skill atrophy, which is then used to preemptively dismiss the thoughts of anyone, the people most concerned about this disagree with.
I also think like... If the argument is that people get good at what they do a lot and to get rusty at what they don't do, I really don't see the argument for why using AI a lot wouldn't make you better at high level architectural decisions spotting possible problems with architectures and approaches before they become a problem organizing your thoughts and tasks, reading a code and spotting issues, etc.
The thing is that using coding agents doesn't actually hide whether an algorithm isn't performant enough from you. It'll either be slow or it won't be.
It doesn't hide if you've come up with a bad architecture, because that will also confuse the agent and make it difficult for it to make future modifications without breaking other things.
It doesn't hide a lack of DRY either because if you've got the same code in multiple places and you want to change how it behaves then you've got to change it in multiple places and they can get out of sync and that will bite you in the ass.
And then there's the fact that with coding agents, there's an obvious and direct reward for using more tests and more advanced testing, better linters, more compiled and typed languages, better CI/CD, better documentation, etc. So people will probably get better at that.
> The act of writing code by hand seems to be on a trajectory of irrelevance
> so as long as I maintain my ability to reason about code (both by continuing to read it and instruct tools to write it), what’s the issue?
Because that’s not how it works. How can we have a discussion about this topic if we don’t have a mutual understanding of how the tools even work?
The code is not replaced by English prompts. The code still exists.
If you can guarantee that it does what you say it does, then all is ok. The core issue since the advent of ChatGPT was always this reliability issue, whether the end result, the code, addresses the change request issued.
It turned out that you need to be an expert programmer to vet the code as well as supervise its evolution, whatever the tool used to write it.
I don’t get paid to write code, and you probably don’t either.
In the context of a software engineer, yes obviously?
> I don’t get paid to write code, and you probably don’t either.
I feel like you're rejecting the premise of the argument. You're talking about becoming a manager, as if that track is somehow relevant to software engineers. I used to be a nurse, I'm not anymore. My skills have definitely atrophied. I would now be a shitty and dangerous nurse. How does that apply to my skills at software engineering? When you stop being a software engineer, it's expected your skills at interacting with code will fall away. But the article you're arguing against isn't written for nurses, and equally isn't written engineering managers.
There may come a day when we, as an industry, decide that simply doing it by hand is more expedient when it comes to resolving urgent production issues. We may not know the pain we are causing ourselves until well into the future when it has become too much to bear without a visit to the proverbial doctor.