We're one good software iteration away from engineering getting sliced right out of the SDLC.

I don't say that lightly. I've been neck-deep in these models since late 2023, watching the full progression. And somewhere around December 2025, something changed. GPT 5.3 Codex dropped. Opus 4.6 landed. These aren't incremental improvements. This is different.

A trusted friend recently told me I'm in an echo chamber. Am I in an echo chamber? Probably, a little. I'm surrounded by people who are deep in this. The friends and colleagues I hear from are similarly engaged. The people who quietly tried these tools, found them underwhelming for their domain, and moved on aren't in the conversation. Software is arguably the easiest domain for AI.. it's structured, has clear feedback loops, and the training data is massive. The leap from "AI can ship a feature" to "engineers are getting sliced out" is bigger than it feels when you're in flow. And "one good iteration away" has been said about a lot of technologies. Some of them hit a wall for a decade.

So I'll say this upfront: the observations are real. The core thesis holds. But the certainty and the timeline? That's where you, me, anyone should be skeptical. I am too.

The New Pipeline

The traditional development pipeline is becoming an AI validation system, and it's happening fast. Here's what it looks like now:

Pick your AI. Pick your repo. Tell it what you want. It does the thing. It reviews itself. It gives the requestor a visual demo of the change in isolation. They approve it. It goes to prod. It monitors for issues. It fixes them in real-time, either a quick revert or a fast follow.

Take a look at Claude's recently updated desktop app which includes the ability to "Code" and "Preview" in the same window. The software has its own browser, runs its own dev server, renders its own UI, interacts with it in realtime, uses multi-modal to look at it, interact with it. With a click, it generates a Pull Request, runs the CI, watches for failures, responds to feedback, fixes any issues, and then merges the changes. Production deployed. Repository, pull request, CI... they're all morphing into AI validation checkpoints. The tooling is that good now.

Are They Perfect? No. Are They Good Enough? Getting There.

These models are deeply autonomous and very, very good. Perfect? Far from it. But they're orders of magnitude better than what we had even six months ago.

I know the counterarguments. I've heard them all. "The trajectory isn't sustainable." "Data centers are expanding faster than we can handle." "The environmental cost is too high." Sure. Valid concerns. But here's the thing about making a successful business: you take ideas that don't scale, then you figure out how to make them scale. This has largely always worked, historically speaking.

Look at what the open source community has already done with optimization. The 7 billion parameter models - and smaller! - are better than ever. Moore's Law keeps proving itself. The models will continue to improve. They'll get more efficient, cheaper, faster, smaller. Technology always does this.

Are Anthropic, OpenAI, Google, and xAI currently doing things that don't scale? Absolutely. Are they retroactively working on scalability? Yes. Will it work? We'll see.

The Self-Improvement Problem

Let's talk about Grok 4.20. Still in beta, but it's the first LLM that's actually self-improving. Week-to-week changelogs. xAI has essentially removed humans from the self-improvement loop.

It's only a matter of time before these systems develop their own language to communicate and improve each other. And we'll let them, because that's what business does: ignore the things we don't understand in the interest of increasing profitability.

How does this end? We don't know. There are theories. Most of them aren't great.

What I've Seen From the Trenches

This isn't a doomsday post. These are just thoughts I've been having.

I've seen both sides. I've experienced massive efficiency gains. I've also felt the dopamine "slot machine" mechanic at work. I've listened to countless stories from friends and colleagues.. positive, neutral, negative. The perspectives range widely.

But here's what's undeniable: these tools enable individuals to tackle problems they never would've had time to even consider attempting before. Month-long projects compressed to hours or days. That's not hyperbole. That's as real as the grass is green.

If you haven't sat down with Opus 4.6 or Codex 5.3 and actually done a full-stack project start-to-finish, you can't comment on this. You don't have the reference point yet. If your thoughts are based on anything prior to December 2025, they're out-of-date.. Obsolete.

The Feedback Loop That Can't Be Stopped

AI-generated code is getting better. The tooling (the interfaces we use to interact with these systems) is getting better. Easier. More integrated.

They're tying together all the disparate systems. They work end-to-end. They plan, build, deploy, and monitor. Subagents are getting more predictable. Trust is going up. Autonomy is going up. Reviews are decreasing.

the question nobody wants to ask: What's the point of careful review if interfaces are ephemeral and issues can be monitored, identified, and fixed almost instantaneously?

AI will refactor its own release pipeline. Test coverage improves. Monitoring becomes more responsive. Bugs spike, then stabilize. The refactoring continues. It's a loop. It can't be stopped.

The Question

These tools are here now. Humans are wielding them. For a while longer, maybe a long while, maybe not, AI will need us to make sure it does things right. That feels like a delicate balance.

Ask yourself this: What happens once AI scales and either never makes mistakes, or corrects them so quickly it doesn't matter?

What's next?

What are we next?