I passed a senior engineering interview at an enterprise software company last month, which is funny. A year ago, if you had put a gun to my head and asked me to write a React calculator from scratch, I would have politely asked to borrow a tutorial. I cannot, in any honest sense, code. I can read code. I can argue with code. I have spent twenty years in rooms where the architecture got decided and the failure modes got named, and I have written enough PRDs to plaster the inside of a CNG. But I cannot sit down and produce a clean reducer hook from cold memory the way the engineers I work with can.
The interview, as it turned out, was an interview about system design.
The team wanted to see if I could think about a rate limiter, a queue, a retry policy, an idempotency key. I could. The model in the panel's other tab wrote the actual TypeScript while we talked. I told it where the seams should be, what the failure mode looked like in production, which integer overflow it should not pretend was safe. The senior engineer offered the role at the end of the second hour. He said, more bluntly than anyone on LinkedIn has been willing to say, that the model writes the code now and what they need is somebody who can hear when it is wrong.
By the time a junior engineer masters the grammar of a language, the closures, the generics, the syntax of a promise chain, the actual thinking behind a system has spent thirty years sitting somewhere else in the org entirely.
The popular line I have read on every engineer's blog since February runs along the lines of, sure the LLM writes code, but it writes bad code. Writing good code requires architecture and system design and taste and judgment that only experienced programmers have, so the model is just a fast typist, the argument goes, while the senior engineer remains indispensable. I have come to think that argument is exactly half right, in the way that something true at the sentence level becomes wrong at the paragraph level. The senior engineer is indispensable for reasons that have very little to do with the part of their training that now overlaps with what the model does for free.
The analogy I keep coming back to is one I watched a whole generation around me live through. Bangladeshis my age can pass any English grammar exam the country sets in front of them. We identify subordinate clauses, we conjugate irregular verbs without thinking, and the ones who went on to sit IELTS in air conditioned rooms in Banani scored bands that would have got their grandparents into Cambridge. The schools did that, English-medium and Bangla-medium both, drilling the grammar to a standard that made the resulting generation, on paper, nearly indistinguishable from native speakers. Most of that generation, my friend Tanveer at the front of the crowd, could not order a meal at the airport at twenty without sweating through a polyester shirt. Twelve years of schooling had taught them the syllabus, and nothing in the syllabus had prepared them for an actual line at an actual counter on a Friday afternoon in Dubai.
The reverse case is the one nobody writes about, because it sits in plain sight. I know plenty of Bangladeshis who couldn't pass an O-Level English paper on a third attempt with the answer key open on the desk, and who close commercial deals in English over the phone every week anyway. Some of them run small import businesses out of flats in Old Dhaka, others sell garment lots into Hamburg and Liverpool by reading the room on a video call better than any British Council certificate has ever taught anyone to. They built their working English the way most people build any working language, by failing at it in front of strangers for years. The only score that ever ended up mattering was the one that came back as a confirmed PO from the buyer on a Tuesday afternoon.
Programmers, taken as a generation, are the toppers of the grammar exam. They know the syntax cold, what a closure is, when a generic narrows, why a Promise.all will not behave the way the junior on the team thinks it will. Many of them, asked to design a system a real organisation can run on a Wednesday, build something elegant that nobody can extend, or something extensible that nobody can debug. The architecture skill, the part Fred Brooks named essential complexity in 1986, has always lived in a different muscle from the syntax skill. Steve McConnell said as much in Code Complete in the nineties when he argued that the job was design and the coding was the easy bit afterwards. The profession heard him, nodded, and went on hiring on whiteboard syntax for 25 years.
What changed in 2025 is that the syntax part of the job, the typist part, dropped to zero marginal cost. Andrej Karpathy called the shift Software 2.0 in 2017, early but pointed at the right thing. The model now writes the grammar of the closures correctly, the generics, the reducer hook I cannot produce from cold memory. What it does not yet do well, and this is the engineer's last honest claim, is decide which reducer hook ought to be written in the first place. That part of the job, the part where somebody chooses the shape, has lived outside programming for thirty years. Programmers got paid to do it only because the syntax was bundled with it on the same desk.
I want to be concrete about who already has this deciding skill, because the lazy answer (some wedding planner with a clipboard) is the wrong one. The people I have in mind sit inside the product already. The senior CSM at a B2B vendor I worked with had spent four years watching seven different customer teams break the same platform in seven different ways. She knew which edge cases the engineering org had documented and which ones lived only in her ticketing spreadsheet. Given a model that wrote the TypeScript, she would ship the fix in half the time of the engineer who had never sat with a customer through the broken flow. The implementation architect on the same account had run forty client onboardings and could tell you in the first sales call which two integrations the new prospect was going to fight in week three. He already had the catalogue of failure modes in his head, and he had never written production code. The support lead who closed two hundred tickets a quarter knew exactly which line in the error log meant the auth handshake had stalled, and the exact workaround that bought the customer twelve hours of breathing room before engineering could ship a real patch. Not one of those three writes TypeScript on a Tuesday morning, and any of them, given a model that wrote it for them, would ship better software than the engineer who has never opened a Zendesk queue.
If the model has taken over the typist's seat, the thinking was always being done by someone who, embarrassingly often, was not sitting in the engineering room to begin with.
The engineers I respect will counter, and have countered when I floated this draft, that the model writes syntactically correct code which is still bad code, and only an experienced engineer can tell. I take this seriously. The standard for good code has shifted twice in the fifteen years I have watched. MVC was canonical, then an antipattern. React built around classes was right, then hooks were right. Each shift was led by a small group of engineers with strong taste, and the rest of the profession caught up by reading their blogs three years later. Stewart Brand argued in How Buildings Learn that architecture is a craft you only acquire by reading every building already standing. A model trained on the entire history of that argument will, by 2028, have a better sense of which standard is winning than any engineer who only saw the last decade.
I might be wrong about all of this. What I keep flinching from, at three in the morning, is the possibility that the engineer's taste is a thing you can only build by writing the grammar yourself for ten years first. Handing the grammar to the model might produce a generation of people making decisions with no instinct for what they are deciding about. The risk is real, and it's exactly the risk my generation already ran in English when we let the syllabus do our grammar for us. The ones of us who became fluent did it anyway, by humiliating ourselves in front of strangers for forty years until the conversations started landing. The grammar exam was always the test the country chose to put in front of us, and the work itself was quietly running a different one the whole time. That boy at the burger counter in 1999 could not order a meal in English. He closes deals with buyers in Munich now. I still don't know whether that vindicates my argument or just means he got lucky.