AI coding works – and that’s exactly the problem

AI coding tools aren’t just shiny new gadgets anymore. They work. They ship real features. They fix real bugs. And that’s exactly why they may end up reshaping software careers far more deeply than most people expect.

It’s tempting to think of AI as just another productivity boost, like a better IDE or a faster compiler. But as models move from autocomplete helpers to agentic systems that can plan, write, and refactor large chunks of code on their own, we’re drifting away from a simple “new tool” story and into something closer to the industrialization of software.

From party trick to serious coder

Back in 2022, tools like ChatGPT and Midjourney felt like novelties. They could write haikus, answer basic questions, and generate weird six-fingered images. Many developers looked at their code output and dismissed it as toy-level or outright garbage.

That changed fast. Each new generation of models got better at real work: writing functions, fixing bugs, scaffolding services, and even handling multi-file refactors with the help of agentic workflows. Industry veterans with 20–30 years of experience now openly admit they’re using AI to do meaningful day-to-day engineering.

Benchmarks back this up. Model evaluations show a steep climb in what AI can autonomously handle. Earlier models could only solve tasks that might take a human expert a few seconds. Newer frontier models can now complete tasks that would take an expert hours to do, end-to-end, with minimal supervision.

Whether or not you believe current large language models can ever become full AGI almost doesn’t matter. You don’t need AGI to disrupt a profession. Electric streetlights didn’t need general intelligence to replace lamplighters; they just needed to work reliably. The same logic applies to AI that can take over large chunks of software development.

Are AI coding models really plateauing?

There’s a popular argument online that current models are already hitting a ceiling. People point out that they still fail on basic reasoning tasks, hallucinate, or get tripped up by tricky edge cases. Some papers even try to formalize limits of current architectures.

But showing that a system has a theoretical limit is not the same as showing we’re anywhere near that limit in practice. Technological progress often follows an S-curve: slow at first, then a steep climb, then a plateau. From inside that curve, it’s hard to know whether you’re nearing the top or just entering the steep part.

Reasoning benchmarks tell a similar story. Yes, models still struggle. But each new generation is noticeably better than the last. The gap between “can’t reason” and “can reason well enough for most practical tasks” might be smaller than it looks, especially once you add tools, memory, and agentic planning on top.

Even if today’s models aren’t perfect, they’re already good enough to be dangerous to the current structure of software careers.

AI as a new floor under the career ladder

To understand the impact on jobs, imagine the typical software career ladder as a series of rungs: intern, junior, mid-level, senior, staff, and so on. Traditionally, you climb that ladder by starting with small, low-risk tasks: fixing minor bugs, writing simple features, cleaning up code, and learning from senior reviews.

Now imagine AI sets a new “floor” on that ladder. Anything below that floor becomes economically unattractive to hire for, because a senior engineer plus AI can cover it more cheaply and more reliably.

We’re already seeing early signs of this. Reports from Stanford and industry talent surveys show pressure building on entry-level roles. It’s not only AI driving this, but AI is clearly part of the story. If a tool like Claude, GPT-4, or similar models can do much of what an intern or very junior engineer would do—fixing small bugs, drafting features, writing tests—companies have less incentive to open those junior positions.

That creates a nasty feedback loop:

• Juniors get fewer opportunities to enter the field.
• Senior engineers rely more on AI to handle low-level work.
• The path to becoming a senior (by doing that low-level work) gets weaker or disappears.

We’ve seen this before in other domains. It’s hard to find a COBOL expert today not because the skill never existed, but because the pipeline to grow new experts dried up. AI risks doing something similar to broad swaths of software development, only faster.

Productivity gains don’t automatically help workers

There’s another common story: “AI will 5x your productivity, so you’ll be 5x more valuable.” In reality, if everyone has access to the same tools, your relative advantage disappears.

If every developer can subscribe to Claude, ChatGPT, or Gemini, then 5x productivity quickly becomes the new baseline expectation. Unless salaries, time off, or working conditions improve proportionally, the main winners are employers and consumers, not individual workers.

We’ve seen this dynamic in other tech shifts. Better tools raise the bar for what’s considered “normal output,” but they rarely come with a matching raise or reduced hours. Instead, you’re expected to do more in the same time.

AI coding tools are no different. They genuinely remove friction and can make some tasks less painful. But once they’re widely adopted, they mostly translate into higher expectations, not more free time.

This isn’t just a new tool – it’s industrialization

Comparing AI coding to swapping a shovel for an excavator sounds comforting: same job, just faster. But that analogy is too gentle.

A better comparison is a machine that can build an entire house end-to-end. Version 1 excavates and pours the foundation. Version 2 also frames the structure. Future versions do drywall, plumbing, electrical, and painting. Humans are still in the loop, but their role shifts from hands-on builders to overseers of a highly automated pipeline.

That’s closer to what agentic coding looks like. We’re not just making individual steps faster. We’re automating more and more of the entire software creation process—from planning and scaffolding to implementation and refactoring.

History gives us a hint of what happens next. Take shoemaking:

• Handcrafted shoes were replaced by factory production over several decades.
• Consumers benefited from cheaper, standardized footwear.
• Artisanal shoemakers still exist, but they’re rare and serve a niche market.

Software could follow a similar path. There will always be room for specialists, but the bulk of day-to-day coding may shift into something more like supervising and shaping automated systems rather than writing most of the code directly.

Fewer roles, more competition at the top

If AI lets one engineer do the work of five, companies have two basic options:

• Keep the same headcount and build more.
• Reduce headcount and try to build the same (or more) with fewer people.

Recent layoffs across tech and gaming suggest many companies are leaning toward the second option. Surveys from the game industry show a large share of developers have been laid off in just the last couple of years, even as the industry remains highly profitable. Broader software reports show similar trends.

If organizations decide they can run with fewer engineers, then the number of “AI orchestrator” roles—people who design systems, guide agents, and sign off on results—will be limited. That intensifies competition, especially among mid-level and senior engineers.

Those already higher on the ladder have a built-in advantage: experience, domain knowledge, and organizational trust. They’re more likely to secure those orchestrator roles. People earlier in their careers, or those whose strengths don’t map neatly onto this new style of work, are more likely to be squeezed.

The speed of change is the real danger

Technological transitions are survivable when they’re slow. If a profession fades over 30–40 years, most workers can finish their careers, and younger people can choose different paths. That’s roughly how long it took shoemaking to fully industrialize.

But some industries collapsed much faster. Print newspapers took a huge hit in just over a decade. Travel agents went from common to niche in even less time.

AI is moving closer to the “fast collapse” end of the spectrum. Model capabilities are improving rapidly, adoption is accelerating, and companies are under constant pressure to cut costs and increase output. If entire categories of work are automated away in 5–10 years instead of 30, many mid-career professionals simply won’t have the time, money, or flexibility to retrain.

This is especially harsh for people who’ve already invested years into a specialized path—say, a graphics programmer who combines deep math, engine knowledge, and close collaboration with artists. Even these “safe” niches are now seeing credible AI challenges, from procedural content generation to Nvidia’s own AI-heavy graphics pipelines.

Democratization or just more platform dependence?

One of the most popular narratives around AI is “democratization of creation.” Anyone with an idea can now make a game, a film, a comic, or an app without needing a full team or advanced skills. On paper, that’s exciting.

But there are two big catches:

1. Access isn’t ownership

Using hosted AI models doesn’t mean you control them. Most people will rely on a small number of large providers for models, hosting, and tooling. That concentration creates the same pattern we’ve seen over and over in tech:

• Start out generous and developer-friendly.
• Attract massive dependence.
• Gradually lock in users and optimize for extraction—higher prices, worse terms, more ads, less control.

We’ve watched this “platform shitification” happen with search, social media, app stores, and more. There’s no reason to assume AI platforms will be different.

2. Creation is easy, attention is not

Even if AI makes it trivial to create games, shows, or apps, there’s still a hard limit: human attention. We all compete for the same finite number of hours in a day.

As creation gets cheaper, the internet fills with even more content. Discovery and curation become the real choke points. Getting featured on Steam, Netflix, the App Store, or YouTube becomes even more critical—and those gates are controlled by a handful of platforms and algorithms.

So yes, AI may let more people create. But it also makes it easier for big players with more resources to iterate faster, copy what works, and dominate distribution. Think “Amazon Basics for apps and games”: see what’s popular, then spin up a similar product quickly at scale.

Some individuals will absolutely win in this environment. A few solo creators will ship breakout hits thanks to AI. But many existing professionals may find that their hard-won technical or artistic advantages no longer translate into stable income.

If you want to lean into the upside, it’s worth learning how to build AI-driven workflows and systems yourself. For example, you can use tools like Claude Code to assemble your own AI “team” for marketing, content, or product experiments without heavy engineering, as shown in guides like how to build an AI marketing team with Claude Code or 32 Claude Code tricks to build faster, smarter AI workflows.

The new job: AI orchestrator (and why it might suck)

Let’s assume the optimistic scenario: the market grows, new roles appear, and you manage to land one of those “AI orchestrator” jobs. What does that actually look like?

For many developers, the joy of the job comes from problem solving: designing systems, writing clean code, debugging tricky issues, and gradually shaping a codebase with your own hands. AI-assisted development changes that balance.

Instead of writing most of the code yourself, you’re:

• Prompting and steering AI agents.
• Reviewing large volumes of AI-generated pull requests.
• Trying to ensure consistency and safety across code you didn’t personally write.

Early reports from teams using AI coding agents show a new bottleneck emerging: verification. One engineer with strong AI tooling can generate more code than a whole team can comfortably review. Code reviewers and maintainers become overloaded, and the quality of review drops.

Worse, the more you rely on AI to write code, the less you practice writing it yourself. Over time, your ability to deeply understand and reason about the system may erode, even as you’re still nominally responsible for its behavior.

That leads to an uncomfortable question: if AI is writing most of the code, and your job is mostly to sign off on it without truly grokking every detail, what exactly are you accountable for? At some point, the system starts to feel like a black box you’re babysitting rather than a codebase you own.

Winners, losers, and uncomfortable uncertainty

It’s entirely possible to be excited about what AI enables and still be worried about its impact on workers. Both can be true:

• AI will absolutely make it easier and faster to build software, games, and media.
• AI will also disrupt career paths, compress wages, and make some roles vanish.

People with deep experience, strong networks, and flexibility may come out ahead. They can adapt, move into orchestrator roles, or leverage AI to spin up their own products and businesses. But many others—especially juniors, specialists in narrow areas, or those already mid-career with heavy life commitments—may find the floor dropping out from under them.

None of this means AI progress should or will stop. It does mean we need to talk honestly about the transition while we still have time to influence it: how we train new developers, how we value human expertise, how we regulate high-stakes automation, and how we support people whose careers are disrupted through no real fault of their own.

Agentic coding is already here in early form, and it’s undeniably powerful. In the short term, it can feel amazing to spin up complex systems by just describing the architecture and letting the AI fill in the details. But further out, the picture is much murkier. The job many of us trained for may not be the job that exists in ten years.

AI coding works. That’s the opportunity—and the problem.