Back to Blog
4 min read

We've Seen This Before—And That's What Worries Me

Reflecting on what AI means for American developers, the parallels to manufacturing and outsourcing, and the institutional knowledge we risk losing.

AI Software Development Industry

I’ve been thinking a lot about what AI means for American developers. Not the hype. Not the productivity gains. The thing nobody wants to say out loud: Are we watching the slow erosion of another skilled profession?

I was in tech when outsourcing became the answer to every budget question. “Why pay American rates when we can get it done offshore for a fraction of the cost?” We were told to adapt, to move up the value chain, to become architects and managers instead of coders. Some did. Many didn’t.

But here’s the thing—outsourcing, as disruptive as it was, still required people. AI doesn’t.

The Manufacturing Parallel Nobody’s Talking About

When manufacturing moved overseas, we didn’t just lose jobs. We lost knowledge.

Ask anyone who worked in American manufacturing about tool and die makers. These weren’t assembly line workers—they were highly specialized craftspeople who understood materials, tolerances, and processes at an almost intuitive level. Knowledge built over decades, passed down through apprenticeships, refined through countless iterations on the shop floor.

When the work left, that knowledge left with it. And it didn’t come back. Today, we’re seeing companies struggle to reshore manufacturing partly because that institutional expertise simply doesn’t exist here anymore. You can’t rebuild in five years what took fifty to develop.

I look at software development and I see uncomfortable similarities.

What We Risk Losing

Junior developers aren’t just cheap labor. They’re the pipeline. They’re how senior developers are made. Every mid-level engineer debugging a production issue at 2 AM, every architect who instinctively knows why a design won’t scale—they all started by writing bad code, breaking things, and learning from experience.

If AI handles the “easy” work—the tasks we’d normally give to junior developers—what happens to that pipeline? Where do the next generation of senior engineers come from?

And it’s not just about career ladders. There’s a kind of knowledge that only comes from doing the work yourself:

  • The intuition for when a “simple” change will cascade into complexity
  • The pattern recognition that spots architectural flaws before they become expensive
  • The debugging instincts built from thousands of hours tracing through systems
  • The hard-won understanding of why certain approaches fail in production

Can you develop that intuition by reviewing AI-generated code? Maybe. I’m not sure. And that uncertainty is exactly what concerns me.

This Isn’t a Luddite Argument

I’m not saying AI is bad or that we should resist it. I use AI tools daily. They make me more productive. The technology is genuinely impressive.

But I’ve lived through enough “this time is different” moments to be skeptical of easy reassurances. Every disruption comes with promises that displaced workers will simply move to better jobs. Sometimes that happens. Often it doesn’t.

What I’m asking for is honesty:

  • Honesty that some jobs will disappear, not transform
  • Honesty that “learning to work with AI” isn’t a viable path for everyone
  • Honesty that we might be trading short-term productivity for long-term capability loss

The Question I Keep Coming Back To

With outsourcing, the knowledge still existed—just somewhere else. The expertise was preserved, even if it was no longer American expertise.

With AI, I’m not sure that’s true. If we stop training humans to do certain kinds of work, does that knowledge persist in any meaningful way? Or does it become a black box—something AI can do but no human truly understands?

Manufacturing taught us that some losses are irreversible. Once the knowledge is gone, it’s gone.

I hope I’m wrong about this. I hope the optimists are right and AI simply elevates developers to higher-level work, that new roles emerge that we can’t yet imagine, that the transition is smoother than past disruptions.

But hope isn’t a strategy. And I think we owe it to the next generation of developers to at least have this conversation honestly.


What’s your take? Am I being too pessimistic, or are we not being pessimistic enough?