Imagine joining a company today that still ships software the way we did 30 years ago: painful merges of months-old branches, no CI, no automatic deployment, no test automation, releasing once a year after months of manual testing and frantic bug-fixing. You’d call it junk development without hesitation. Paździeż development, for the Polish readers.

And it would be a fair judgment. That kind of team delivers less value, more slowly, at a higher cost than anyone using modern software development practices. The gap is real, measurable and big.

What we sometimes forget is how long it took to close that gap. The modern fast development process didn’t appear overnight — it’s the cumulative result of trends that each took years to adopt: agile, DevOps, the cloud, modern frameworks. Decades of compounding improvements layered on top of each other.

When AI arrived, I assumed it would be just another wave in that sequence. There would be the usual controversy, the community would work out good practices, startups would adopt first, then big tech, then eventually the more traditional corporations — and within a few years, the whole industry would benefit from another step-change in productivity.

Boy, was I wrong.

AI didn’t arrive like a wave. It arrived like a tsunami — and not just one. A series of tsunamis, month after month, quarter after quarter, giving none of us time to rest or fully absorb the last set of new tools before the next one landed.

At first, the disruption arrived in the form of Vibe Coding. It was mostly contained to prototyping, product exploration, and simple applications. What used to take a two-person team two months could suddenly be done in an evening or two. Lower quality, sure — but for a prototype, that didn’t matter.

Now, in 2026, it has finally arrived in big, complex, production-grade, security-sensitive projects too. The new way of building it has a name: agentic engineering.

If your reaction to that is “AI produces low-quality ‘AI slop’ insecure code” — you simply haven’t done your research. You haven’t spent more than a few hours learning how to actually work with these tools, and you haven’t engaged with the patterns the community has already developed for shipping production code with AI. Congratulations: you’re now a junk developer.

Here’s the thing that should make everyone uncomfortable: the gap between frontier and junk used to be 15, maybe 30 years. Now it’s 3, maybe 6 months.

This is a hard and emotional time for many of us. Skills we built over years are losing their value in a blink. More and more teams report 5x to 10x productivity improvements over the span of a few months. And lots of things are breaking along the way:

  • Product and business teams can no longer produce requirements fast enough — which is why forward-deployed engineering is making a comeback.
  • Code reviews became the bottleneck — so we only review critical pieces ourselves and let AI review the rest.
  • Hiring is broken — so we’re reinventing that too.

The good news, if you’re a strong software engineer today: you’re probably going to be a great agentic engineer. The learning curve isn’t flat, but it isn’t a cliff either. What it demands is the thing humans are genuinely bad at — leaving your comfort zone, breaking ingrained habits, and challenging your fundamental understanding of the craft you consider yourself an expert in.

But make no mistake: there is only one way forward. Learn agentic engineering. And start quickly if you haven’t yet. Don’t stay a junk developer. Don’t look at the people lagging behind you to justify your own lagging. Hundreds of thousands of developers are already doing agentic coding or actively learning it right now.

Time to join them.