Claude Code is doing to programming what the spreadsheet did to accounting

A morning in 2026

This morning, Claude Code refactored a 400-line TypeScript service for me in 90 seconds. Two years ago that would have been a Saturday afternoon. I'm shipping faster than at any point in my career, and I'm more unsettled about the industry than I've ever been.

Here's the comfortable line you hear at every conference: "AI is a tool, it augments engineers, it won't replace them." That's true in the same way "the tractor is a tool, it won't replace farmers" was true. Farmers didn't disappear. There are just 60x fewer of them now.

The pattern we keep pretending is new

Every few generations, a tool arrives that doesn't just make existing workers faster — it changes what "work" even means for that field. A short and incomplete history:

The steel plow (1830s). Before John Deere's plow, an acre of Iowa sod took a man and a team of oxen a full day to break. After, the same acre took an afternoon. US farm labour in 1830: around 70% of the workforce. US farm labour in 2024: about 1%. Total farm output: higher than ever. The farms didn't disappear — the people mostly did.

The spreadsheet (1979-1985). When VisiCalc and then Lotus 1-2-3 landed, the immediate prediction was that accountants were toast. What actually happened: the role called "bookkeeper" — someone whose whole job was running ledger arithmetic — mostly died. Accountants went strategic, because crunching numbers stopped being the hard part. The title survived; the actual job is unrecognisable from what it was in 1975.

The ATM (1970s-90s). The favourite economist counterexample: ATMs came in, and the number of bank tellers went up for two decades. The reason was boring — automation made each branch cheaper to operate, so banks opened more branches, so they hired more tellers. The pattern broke around 2008. Now US teller employment is declining fast. The delayed kill is still a kill.

The motor car (1900-1930). At the turn of the century, the US economy employed hundreds of thousands of people in horse-adjacent work: blacksmiths, stable hands, coachmen, farriers, harness makers. Within thirty years, most of those jobs were gone. An entirely new stack showed up in their place — mechanics, drivers, petrol station attendants, insurance adjusters, an auto-parts supply chain. Net jobs: up. Specific jobs: gone forever.

There's a common shape to all of these:

• A specific sub-skill gets automated (ploughing, arithmetic, cash-dispensing, horsemanship)
• Immediate displacement is smaller than predicted — the tool needs humans, at first
• The second-order effects are larger than predicted — entire categories of work get redrawn
• The people who thrive aren't the ones who fought the tool; they're the ones who figured out what the tool was actually good at and repositioned early
• The people stranded are usually young entrants who counted on the old ladder being there

What I'm seeing in my own workflow

I've been building an agent-powered platform for the last several months, mostly with Claude Code as my co-pilot and occasional driver. A few honest observations:

Boilerplate is gone. CRUD routes, test scaffolds, migration files, type definitions — the work that used to take a junior engineer half a day now takes me 90 seconds plus a code review. I haven't opened Stack Overflow in weeks.

Context-switching is nearly free. Agents hold context I can't. I can jump between a frontend bug, a database migration, and a prompt-engineering task without the 20-minute warm-up tax I used to pay each switch.

Senior work is amplified. Junior work is squeezed. This is the uncomfortable one. The work I can now do in a day would have needed two juniors a week to get wrong first, then me a day to fix. I'm doing more of the actual senior thinking, and I'm doing it without handing off the junior pieces to anyone.

The meta-skill has shifted. A year ago, the valuable thing was "I can write this code." Today, the valuable thing is "I can specify what the agent should write, validate its output fast, and catch the failure modes it introduces at scale." That's not a syntax skill. It's closer to what a senior engineer or a tech lead does anyway — which is why juniors are getting squeezed hardest.

The numbers so far

Data lags lived experience, but the early signal isn't subtle:

• Stack Overflow's 2024 Developer Survey: over 76% of developers now use AI tools at work regularly. In 2022 it was under 50%.
• Indeed's data: US software developer job postings peaked in Q2 2022 and are down roughly 30% from that peak. Some of that is macro — rate hikes, the post-ZIRP hangover. Some of it isn't.
• Junior roles are the tell: entry-level SWE postings fell harder than senior. "Two years of experience" is now the floor for a lot of postings that used to say "fresh grad welcome."
• The other side of the ledger: AI infrastructure, ML engineering, and AI safety / evaluation roles are up several-fold over the same period. The work didn't disappear; it migrated.

This is the spreadsheet pattern in fast-forward. The bookkeepers are the junior developers whose job was "write the straightforward code from the spec." That job is being hollowed out in real time.

What's actually going away

If you pressed me honestly — here's what I think is at serious risk over the next 3-5 years:

• Pure "code producer" roles. Take a spec, write the code. The thing Claude is already doing in a pair-programming chat window.
• Bootcamp-to-job as a path for generic web development. The ladder was always shaky; the bottom few rungs are now structurally weaker.
• Parts of traditional QA. Regression tests and happy-path coverage are trivially automatable now.
• A lot of internal tools work. The "build me a CRUD dashboard for this DB" project is now a prompt.
• Simple coding interviews as a hiring filter. If the job the interview simulates can be done by an agent in thirty seconds, the interview tells you nothing useful about the candidate.

What emerges

And what I'd be betting on, if I were early-career today:

• Agent orchestration. Someone has to design the prompt scaffolding, the tool APIs, the evaluation harness, the guardrails. That someone is in extreme demand right now. It's most of my day.
• Evaluation and red-teaming. The bottleneck on shipping AI features isn't generating code — it's knowing whether the generated code is actually correct. People who can design good evals are rarer than people who can write Python.
• Domain expertise + AI fluency. The engineer who understands AdTech attribution and can direct an agent to implement it will eat the lunch of the engineer who only knows Python. Same for medicine, law, finance, manufacturing.
• Systems thinking at a higher level. When writing code is cheap, choosing what to write becomes the bottleneck. Architecture, product-engineering hybrid roles, and senior-IC positions compound.
• Managing humans who manage agents. The skill is barely named yet. It'll be a major 2027 job category.

The uncomfortable aggregate

Historically, technology waves net-create jobs. The 21st century employs more people than any previous century. That's the comfortable view and it's largely correct.

The uncomfortable view, also correct: aggregates hide individuals. A displaced farm hand in 1890 didn't much care that his grandson would eventually become a radio engineer. He cared that his specific job was gone and his kids had to move to a city to survive. The transition takes a generation. Some workers make it; some don't.

So when someone says "AI will create more jobs than it destroys" — they're probably right in aggregate, and they're dodging the hard question. Which is: what happens to the specific people whose specific jobs vanish before the new roles are built and accessible?

That's a policy question as much as a technology one. Historically the answer has involved a lot of pain, a lot of retraining, and a lot of luck. There's no reason to expect this round to be gentler unless we make it so.

My honest bet

If I'm right about the pattern:

• The title "software engineer" survives the decade.
• The actual day-to-day work looks nothing like it did in 2022. You won't spend your time writing syntax; you'll spend it defining specifications, directing agents, and validating output.
• Entry gets harder. Seniority becomes leverage. The "sketch your career in 20-year arcs" advice applies more than ever.
• The companies that win will be the ones that figured out how to give agents the right context, hand them the right tools, and keep humans in the loop where it matters. Not the ones that fired their engineers.

That last point is where I'd press. Most of the AI-replaces-humans narrative comes from people who haven't shipped serious software with an agent. The agent is astonishing and also will confidently delete your database schema if you're not watching. The human doesn't get removed from the loop; they get promoted to a different job inside it.

And me?

I'm building with these tools every day. I can ship more of my own ideas in a quarter than I used to in a year. That's genuinely wonderful, and I don't want to pretend otherwise.

I'm also clear-eyed that the ladder I climbed — junior engineer → senior engineer → whatever-I-am-now — won't look the same for someone starting today. Pretending otherwise would be dishonest.

The honest answer is: this is the biggest change in the software industry in my lifetime, and anyone telling you they know exactly how it plays out is selling something. What I can tell you is the direction I'm betting on — get good at directing agents, double down on judgement and taste, find a domain where your expertise compounds, and ship real things.

The steel plow didn't destroy farming. It destroyed a specific way of being a farmer. Claude Code is doing exactly the same thing to our field — and the farmers who adapted earliest were the ones who kept their land.