A year ago I figured I'd struggle to find anything fresh to say about programming twelve months on. The usual rhythm — a framework debuts, a language gets buried, the discourse churns, and nothing actually moves the floor — felt locked in.
What moved instead was the layer between intent and outcome. LLMs crossed a line where typing the code — converting what you want into something the compiler will tolerate — stopped being the expensive part. That rewrites the job. Not in the melodramatic way your feed is telling you, but it rewrites it.
The title was always a little off
"Coder" was always a shaky label. Code was a dialect we picked up so that computers could act on human intent, and the arc of software engineering has been a slow dissolving of that translation gap. COBOL, SQL, Python, Ruby — every step pulled the surface closer to natural language. LLMs are the next step on that line. A longer step than most of what came before.
The point was never the lines. It was the outcome. We only needed a person at a keyboard because nothing else could get us there.
That bottleneck is disappearing. Coding as a job is fading. Software engineering isn't. Fewer keystrokes, more judgement. Deciding what to build, for whom, under which constraints, and when to tell someone no.
Jargon to discount on sight
If you've spent any time on LinkedIn lately, you've seen old concepts dressed up in new suits. Most of it should be waved off. A short field guide to what to discount:
Spec-driven development. Real idea. Not new — it's a descendant of model-driven development, which Martin Fowler was writing about twenty years ago. Anyone who's run Agile in a mid-sized shop has been working from acceptance criteria the entire decade. What actually changed is that the machine can do the execution while a human writes the spec and signs off on the output. That's the real delta. The packaging isn't.
Disposable code. The framing says AI made code disposable. Code was always disposable. Most of what you wrote in 2018 has been deleted, rewritten, or replaced. AI just shortens the loop and forces the disposability into view. Stop wrapping your identity around the lines you once typed.
Product-minded engineers. Engineers participating from ideation to launch is how every healthy product team has always operated. The "full-cycle developer" rebrand is marketing, not a new role. And asking one person to absorb design, research, PM, and analytics on top of their engineering work is a burnout pattern no matter what label you glue on it.
The pattern recurs: genuine shifts are underway, but the naming committee keeps claiming victory over things that were already moving.
Every team gets its AI holdout
2026 is going to be uncomfortable for engineering teams. LLMs have left the novelty stage and moved into "this is how work happens now." That means AI stops being an R&D dalliance and shows up as a line item in the quarterly plan.
Expect at least one engineer on every team to push back. The reasons vary — worry about being replaced, fear of skill atrophy, a purist refusal to commit code they didn't type, sometimes just pride. Some of those concerns are legitimate. All of them are corrosive when leadership refuses to take a position.
"You can use AI if you want" isn't a decision. It's a shrug. Teams that absorbed Agile well had ceremonies, definitions of done, and review gates. Teams absorbing AI well need the same scaffolding — which tools, for which tasks, with which verification before a PR lands. Without that, the loudest sceptic sets the tempo and the whole team slows down.
Shorter cycles, wider lanes
Two shifts that go together:
PMs and designers start owning more of the pipeline. A designer with a working design system can open a frontend PR and hand an engineer the polishing pass. A PM with a spec tool can turn a fuzzy idea into an estimable story without queueing up for a standup. That rebalances who touches which step.
Two-week sprints age fast. When idea-to-PR collapses, the ceremony wrapped around idea-to-PR starts to feel like overhead. My bet is that Kanban becomes the default for most teams by mid-year. Pick something, do it, ship it. No retrospective on the missed sprint goal, because there is no sprint.
The knock-on: inflating estimates to buy yourself breathing room gets harder. Either you move faster or you look slow, measured against the team that picked up the tools.
Not less work — more bets in parallel
The worst-read piece of AI-at-work is the "automation gives you your time back" line. That isn't the actual dynamic. What's actually happening is that experiments that used to be expensive are now cheap, so you run more of them.
Prioritisation stops being a roomful of people haggling. You don't spend a quarter deciding between two features — you ship eight and let the data choose. Teams that treat AI as "kick back while the machine handles it" have misread the moment. The machine works, and so do you. Just on ten things in parallel instead of two.
Tests get their moment back
I've watched teams undersell automated testing for years. Writing them was the chore nobody volunteered for. A red test was treated as a blocker, not a safety net.
That story inverts the moment most of the code in a PR was produced by a model. Tests stop being a tax — they become the last human-in-the-loop. Not because humans write them (the model writes plenty too), but because someone still has to confirm that the test is actually checking the thing that matters. That's the new bargain: we trust the generation because we trust the verification.
If your test pyramid has been left to rot, 2026 is the year to repair it. Regressions in AI-authored code are more expensive, not less.
The identity question is the real one
All of the above is mechanics. This part is harder.
When you've spent years building an identity around writing code, and the typing shrinks to maybe a tenth of your day, what's left? Some engineers will coast through it without ever confronting the question. Most will hit a wall. Leadership that doesn't plan for the wall is going to lose people it didn't need to lose.
The frame I've settled on: we were never just coders. The editor was always the tool. The thing we were actually doing — the thing that still needs doing — was solving real problems for people who couldn't get there without us. Nothing about 2026 changes that job. It only changes the shape of the day.
Carry that with you.