AI Has Reached an Inflection Point in Software Development

Something shifted in the last couple of months. AI coding tools went from "useful autocomplete" to autonomous systems that can run for days. The gap between what’s possible with AI and without it is now wide enough that ignoring it isn’t neutral—it’s falling behind.

To put it plainly - after 25 years of writing code, I don't see myself writing a single line of code from now onwards.

I’ve been anti-hype on this until now because it wasn’t quite there. That’s changed. This isn’t about demos that look impressive but fall apart in practice. It’s about the day-to-day reality of building software in 2026: the tools have crossed a threshold where they fundamentally change the economics, speed, and accessibility of creating software.

From Autocomplete to Agency

I’ve been using AI as a coding partner since 2024. For most of that time, it looked like back-and-forth review: checking every line, and often turning it off to correct mistakes.

In the last month, I stopped reviewing. I let it run autonomously—sometimes for days. The results are production-ready code.

This won’t be everyone’s experience. You need to know how to set it up and build the right guardrails. If you know what you’re doing, that takes a couple of hours. After that, you’ll never write code by hand again.

What Changed?

The latest models—Claude Opus 4.5 and ChatGPT 5.2—crossed a threshold. They’re now better than humans at most coding tasks.

When AI was ~70% as good as a senior engineer, human review was the bottleneck. You couldn’t leave it unsupervised. Every line needed review before it went to production.

Now it’s around ~120% as good. That doesn’t sound like a huge jump, but it changes the workflow completely. If you don’t need to review code line-by-line, humans stop being the bottleneck. And while it’s only marginally better on quality, it’s about 100x faster.

Crossing that quality threshold makes AI coding agents about 100x more effective in real productivity terms.

Autonomous Agents

Now that you can rely on these tools, the bottleneck isn't code—it's how many features you can spec out.

There’s a way to overcome this too: set high-level objectives and let the AI write its own features.

Here’s what that looks like. A planner invents a feature, then breaks it down into tasks and subtasks. A coding agent picks up one task at a time and executes it. Now you have a system that continuously builds product features it invented on its own.

The results are impressive. From a single one-page plan, I built contrary.markets in two days with no guidance beyond the initial plan. It invented features like leaderboards, achievements, and paper trading—all on its own—then scoped and built them.

Setting Up Your Tech Stack

This requires engineering expertise to set up correctly.

You need a stack that works well with guardrails. The agent needs to test its own work: types are correct, tests are comprehensive, and database migrations work. It needs a web browser to click through the application and take screenshots for feedback.

Feedback is key. Anything the agent can't check isn't worth doing autonomously. If it writes code to send an email but can't verify the email was received, it's flying blind. An engineer's job now is to provide agents with feedback loops and enable them to self-correct.

This Isn't Just About Software

The principles here apply to any digital problem with clear acceptance criteria: analyzing stocks, solving math problems, automating tasks like booking flights. All of this is coming this year.

Creative Pursuits

Where it doesn’t shine is where it can’t get feedback clearly, or at enough volume. It can write a book, but maybe not a good one. It can’t tell if what it wrote actually lands with a human—it can only follow patterns of what worked before.

Given AI intelligence seems to exceed human intelligence in many areas, what makes a human able to write a good book? It can’t just be structure—AI knows how to structure a sentence. It has to be about pulling life experiences into writing so it has emotional impact on the reader.

AI doesn't have these experiences. But it might be able to read about others' experiences online and use that as a basis for compelling stories. Time will tell.

For Companies

Every company will move at breakneck speed this year. They'll build faster and better than ever before. Don't get left behind.

Set your team the objective of integrating AI agents into your process as much as possible. This improves quality and speed at the same time.

Enable them with the right tools. Don't be cheap—buy good laptops and set a high budget for AI agent tokens. Max out Claude and Cursor subscriptions, and budget a couple thousand extra to go over limits.

For Developers

Developers have long been the ones taking other people's jobs. Administrative jobs largely disappeared because developers built systems to automate them. Now it's happening to developers—and many refuse to accept it.

Developers are largely resistant to this change, fearing lost jobs and lost passion for writing code.

Things change. That's life. You can bunker down and hold onto the past, or embrace change and enter the new world.

Those who stay optimistic, embrace change, and learn new skills will always have a job. Those who fight it will become less productive and less hireable.

My advice to developers: become the best at using AI to produce the best outcomes, in the most productive way possible. Do this and you'll become the unicorn everyone wants.

Where This Goes Next

It's taking over software development first, mainly because software developers have the skills to use these agents.

But it will soon come for every job that can be done on a computer. There's nothing special about software that makes it more automatable. It just happened to be first.

Where Does This Leave Humans?

For now, humans are still required to make judgment calls. But more of that will be automated away.

Humans will focus more on high-level direction. They'll also be good at working with other people and building communities.

I don't know exactly what this means for us. My belief is that, although there might be short-term pain, the productivity boost will make us more prosperous in the end.

The "lump of labor fallacy" has been disproven many times. When a new technology comes along—like the sewing machine—there's a dip in jobs at first. But the price of clothes drops, demand goes up, and more jobs are created operating sewing machines than were lost doing it by hand.

I’m thankful for this technology. I’ve been writing software for 25 years and loved every minute of it. But writing software by hand was becoming mentally taxing and tiring. I’ve found a new passion for software. I can have an idea, build it and see the results in a matter of minutes.

I hope everyone else finds the same joy in this as I am right now.