Developers Developers Developers Developers
Part 3 of Retcon Reckoning (The Great AI Replacement)
Software has gotten easier to write, but harder to understand.
There can be no doubt that the office chair has become more comfortable. Still eons behind gamer chairs, tho we’re starting to see more of those at startups. And there can be little doubt that during the same period software has gotten easier to write. What was once a an exercise in muscle memory and meticulous attention to syntactic details had come to be turbo autocomplete where tab becomes the most used key on your keyboard, which from a muscle memory point of view is an unambiguous victory, in the same way that not having to remember phone numbers is an unambiguous victory, and which carries, in both cases, the same quiet implication that you would be in very much over your head if the situation ever arose where you needed to remember one.
Regarding what is actually happening no one as yet has a coherent thesis supported by evidence, so everyone constructs one in real time, as the epistemically appropriate response to a situation in which the signal is genuinely contradictory and the stakes are high enough that silence has acquired the specific social weight of holding an antimemetic opinion, an admission the modern online economy has yet to find a way to prosecute but is working on it. So the thought pieces proliferate. The frameworks multiply. The conference panels convene. And over all of it hangs the industry’s dominant retcon: developers weren’t being replaced, they’re being given an opportunity to move up the stack. Being given a better chair, even.
The argument has genuine historical backing. From assembly to C, from C to Python, from on-prem to cloud, from manual memory management to garbage collection, every major transition involved movement to a higher level of abstraction, and in each case the practitioners who adapted found themselves working at a level that was more powerful, if less granular. The stack got taller. (bigger, and more angular) The abstraction was genuinely upward: you retained what you knew and gained a higher vantage. The retcon frames the current moment as the latest iteration of this pattern, which would be a reasonable frame if the pattern were actually repeating, which it is not, certainly not in the way that matters.
The distinction the retcon requires you not to make involves the difference between a higher level of abstraction and a higher level of ambiguity. When a C++ developer moved to Python, they did not report brain fog. (They did report other kinds of trauma, but that’s a story for another day.) When a sysadmin moved to AWS, they did not feel their understanding of networking precariously dissolve. Previous transitions preserved the knowledge of the layer below, automating interaction with that layer without making the layer inaccessible, which is why the developer who moved from C to Python could still reason about memory management when something went wrong at the boundary. The abstraction was upward. What gets reported now differs in kind: engineers losing the ability to hold a codebase in their heads, losing the capacity to reason about the system they are nominally responsible for, losing the thread of what the code is actually doing underneath the layer the agent is operating on.
Brain fog, like Gibson’s famous future, is not evenly distributed. The engineers who report the most acute version of it are not, by and large, the ones who understood the stack most deeply. They are the ones for whom the agentic tools arrived before the underlying knowledge had fully formed, for whom coding had been something the tooling managed, the syntax something the autocomplete supplied, the architecture something the framework handled, and who were, for a remarkable stretch of time, compensated extraordinarily well for their fluency with the interfaces rather than their understanding of what the interfaces were built on. An entire generation for whom software development was, at some meaningful level, a video game that paid exceptionally well and which the agentic tools have now revealed to have been, in part, a video game being played on someone else’s hardware.
Substitution and augmentation are not the same operation, and the difference
shows up in what the person retains when the tool is taken away.
The retcon interprets this as the temporary disorientation of transition, the expected friction of moving to a new level of abstraction, something that will resolve once the new paradigm is fully internalized. The more accurate interpretation is that it is the perception of a capability being abandoned rather than relocated; not moved up the stack but left behind in it, inaccessible not because it has been abstracted but because the tools that were supposed to augment it are instead substituting for it, and substitution and augmentation are not the same operation, and the difference between them only becomes visible at the moment when the layer below needs to be reasoned about and the capacity to do so is no longer there.
The retcon reframes this revelation as elevation. The skill deficit that the tools have exposed becomes the proof that the tools are needed, which is true as far as it goes, and which goes considerably less far than the retcon requires it to. What the tools are actually doing to the population using them has been described with some precision by the researchers studying it: the use of coding agents is actively diminishing the very skills needed to effectively manage the coding agents, which is the cobra effect stated at the level of individual cognition, running in real time, visible in the data, and re-described as progress by an industry that has staked too much on the productivity thesis to afford the alternative interpretation.
Without it, the industry would have to confront what the transition is actually producing, which is not a workforce moving up the stack but a workforce discovering that the stack they thought they were on was shallower than the salary suggested, and that the AI has not so much replaced their skills as revealed the gap between the skills they had and the ones the salary was pricing.
No One Expects The Comfy Chair
The chair got more comfortable. This is what happened between 2010 and 2024 for a significant portion of the people now asking why they are being laid off. The IDE got smarter. The framework handled the architecture. The autocomplete supplied the syntax. The linter caught the errors. The CI/CD pipeline managed the deployment. Each abstraction layer added comfort to the chair, removed one more reason to understand the layer below, and was experienced as progress because the output kept coming and the salary kept arriving and the title kept accumulating and the understanding kept thinning and nobody was measuring the thinning because the output was the metric and the output was fine and the chair even had a tilt lever.
PEBKAC (Problem Exists Between Keyboard And Chair) was the help desk’s sardonic shorthand for user error, the human in the loop as the weakest link, the thing that would be fine if only the person would get out of the way. Agentic tools didn’t change the acronym. They changed which side of the keyboard the problem was on. The Problem Exists Between Keyboard And Chair, and the chair is a big part of the problem, and the chair is the thing being removed, and the person in the chair spent a decade being told they were moving up the stack while the stack was quietly being built around them in a way that made the chair unnecessary. As comfortable as it was.
Part 4: Doing Less With More
The fully footnoted version of this post can be found at antimemetics.blog/developers