The headlines aren't wrong. They're incomplete.
Tech laid off 78,557 workers in Q1 2026. Roughly 48% of those cuts were formally attributed to AI. The hiring data matches the narrative: new software engineering job postings are down 15% year-over-year. Companies are telling the market a clean story — models got good, headcount followed.
Sam Altman, whose own company sells those models, hedged the story himself. "There's some AI washing," he said, "where people are blaming AI for layoffs that they would otherwise do." Both things can be true. Productivity did shift. Budgets also contracted. The convenient explanation got picked up because it sounds like inevitability instead of a decision.
What's missing from the coverage is the ceiling. The part of the job AI actually does, the part it does badly, and the delta between a $20/month Claude subscription and a shipped production system. All three matter, and only one is in the headlines.
What $20/month actually buys you
A founder with no engineering background can open Claude Code today and, within a day, ship a working flappy bird clone. A static marketing site. A tic-tac-toe with a leaderboard. A CSV-to-PDF converter. A single-page portfolio with a contact form. For a $20/month subscription, the floor has risen in a way that deserves acknowledgment before we talk about the ceiling.
This is not trivial. A decade ago, those same artifacts required a bootcamp or a freelancer. Now they require a weekend. If your product need ends there — a one-page pitch, a lightweight widget, a demo — the math works. AI shipped it. The headlines are correct about this slice.
The problem is that very few real businesses stop at this slice.
Where the floor ends
The moment your app acquires a real surface area, the economics invert. A CMS-backed marketing site with live blog rendering and image optimization. A Stripe integration with webhooks, idempotency keys, and a refund flow. A multi-tenant dashboard with role-based access. Search. Auth. Migrations. A CRON job that runs nightly and can't silently fail. Any of these, alone, is where the floor ends.
In July 2025, METR ran a controlled study on 16 experienced open-source developers working in their own codebases — repos averaging 22,000 GitHub stars and over a million lines of code. When they were allowed to use AI tools, they took 19% longer to complete tasks than when they weren't. The developers themselves believed AI had sped them up by 20%. The perception gap was 39 percentage points wide.
That's the ceiling made quantitative. And those were engineers with a decade in the codebase they were editing. A non-technical founder working in a codebase they don't fully understand does not get to 19% slower. They get stuck.
The rabbit hole tax
A senior engineer reads a stack trace, recognizes the shape of the bug, and fixes it in twenty minutes. The pattern-match is the skill. It comes from having been in that specific hole before and remembering how the floor feels.
AI does not have that memory. It has a training distribution. When a production bug arrives that falls outside the distribution — a Payload block that renders on the server but breaks on the client because of a lexical node mismatch, a Stripe webhook that fires twice because the retry isn't idempotent, a Next.js page that builds fine locally but times out on Vercel because of a Node runtime mismatch — AI proposes plausible-looking fixes for symptoms, not causes. Every fix opens two more holes.
The public record on this is ugly. One developer burned 24 million tokens in a single day debugging a feature the assistant kept confidently re-implementing wrong. A teardown comparing four AI tools on the same bug measured a 5x variance in tokens to resolution — same bug, same spec, same starting codebase. The variance wasn't in the bug. It was in how far down each tool was willing to go before escalating.
For a non-technical operator, this is not a cost problem. It's a truth problem. They cannot tell whether the tenth "fix" is closer to the answer or further from it. So they ship the next one. And the next. The bill grows. The bug stays.
The productivity bifurcation
The same studies that get quoted for "AI is replacing developers" actually describe a split. Senior engineers using AI as an accelerant on a codebase they already understand report 40–55% more output per sprint at comparable quality. That's real. It's also where the productivity gain lives — in the hands of people who can tell when AI is wrong.
Junior postings down 15%, senior engineers up 40–55%. The market isn't collapsing. It's bifurcating. The middle is getting squeezed because AI replicates middle-tier code generation well. The top is compounding because AI is leverage on expertise it doesn't possess on its own. The bottom is still available, but at flappy-bird complexity.
AI is not killing software development. It's widening the gap between people who can read code and people who can only generate it.
When to bring in developers
Concrete line. If your product touches any of the following, you are past where AI ships alone:
- Payments. Stripe, Adyen, refunds, multi-currency, subscription proration, tax, 3DS flows.
- Auth. Anything with sessions, SSO, role-based access, multi-tenancy, or a regulator watching.
- Data relationships. A real CMS. Joins across tables. Migrations that can't roll back cleanly.
- Uptime as a contract. Systems that cannot 500 during business hours because a human gets paid less when they do.
- Integrations with 3+ external services. Each one is a failure mode AI hasn't seen in your specific combination.
- Anything regulated. Health, finance, public sector, biometrics.
At Codegray we build software for teams past this line. We use AI every day — not as a replacement for the engineer, as an instrument they hold. The difference shows up in the bill and the uptime.
If you're at the ceiling and looking up, talk to us.
A note on the headlines
The "software is dead" quotes come from the same people selling the model subscriptions and announcing the layoffs. That doesn't make them wrong. It makes the incentive visible. The honest version of the headline is: AI raised the floor, moved the ceiling, and made it more expensive to get production wrong. That version doesn't trend. The layoff version does. Both are true; one is being told louder.
Software development is not dead. It's more specialized, more expensive to do badly, and more leveraged at the top. The engineers who understand that are compounding. Everyone else is paying tokens to find out.