By the end of this year, there is no excuse for a developer not to be able to do a whole scrum team’s worth of points per sprint.” – Byron McClain

 

Why waterfall thinking suddenly makes sense again

The waterfall methodology didn’t fail because planning was bad; it failed because coding took so long that requirements went stale. When you waited 6 months to see results, the world had already changed. Your business learned something new. Your carefully crafted specs became obsolete before the first deployment.

But if AI can code your comprehensive specs in a day? Suddenly, front-loaded planning isn’t a liability anymore; it’s the optimal strategy.

Byron puts it this way: “Back in the day, waterfall was a big deal. You would spend a lot of time creating the product requirements document, and it took a long time. That’s why agile happened: you could start iterating tiny little chunks so people could see it and make changes along the way. But now, coding can happen almost instantaneously. What happens to the cycle? Well, now the risk profile completely changes.”

AI agents are context-consuming machines

Feed them a small set of requirements (agile-style), and you will incur context loss and constant manual work to maintain architectural coherence.

But if you feed your AI agent comprehensive upfront specs (waterfall-style), it will consistently execute from start to finish.

“You’re gonna have to spend more time up front,” says Byron. “You need to get really, really good context of what you want to build and then decompose that into tasks. When you do that, the coding aspect will be super short, and we’re going to reach a point where it’s instantaneous.”

Following this thought process, you could spend three days on discovery, have AI code within a single day, and still iterate faster than traditional agile sprints ever allowed. The rapid feedback loop isn’t lost; it’s just moved.

You’re not going back to 18-month waterfall death marches. You’re front-loading your process with planning and intensive criteria, then executing and iterating at speeds agile never allowed.

The proof is in the execution

Byron worked under the same criteria he used when transferring a legacy video game from Microsoft to Mac. He and Claude spent significant time upfront understanding the entire 900,000-line codebase, generating a detailed 14-phase plan with specific tasks. Only then did any code get written, and he did it all within 4 days.

Some will argue that this is premature, that AI agents aren’t reliable enough yet, or that we’re relying too heavily on a single exceptional example. Which is fair. But even if Byron’s 4-day port becomes a 2-week port for most teams, that’s still a 4- to 5x productivity increase, and that directional shift remains true even if the magnitude varies.

So here’s the reality: for AI agents, agile’s piecemeal iteration becomes a handicap. You’re optimizing for a constraint (slow coding) that no longer exists, while ignoring the new constraint AI introduces (agents that need comprehensive context to excel).

This doesn’t mean agile principles are dead; human-in-the-loop and feedback remain very important. What it means is that the cadence and approach need to shift.

The role collapse is coming

As if the resurgence of waterfall didn’t already throw us, here’s where it gets uncomfortable for many organizations and employees: a role change is on the horizon.

“The titles and job roles are gonna collapse,” Byron predicts. “Instead of having a BA, a developer, and a QA engineer, you’re gonna just have a solution engineer.”

This doesn’t mean specialization will disappear; complex domains will still require deep expertise. But the walls between specific tech roles are coming down. A BA who can’t understand the development or technical context will struggle, just as a developer who can only write code will find their skills commoditized.

This isn’t a layoff narrative. It’s a skills evolution.

The best BAs will become solution architects. The best developers will become technical strategists. The best QA engineers will become validation specialists who design automated testing frameworks rather than manually click through interfaces. The work isn’t disappearing, it’s elevating.

Byron predicts that the future belongs to “solutionists,” or people who can:

• Sit with the business and extract precise requirements.
• Break down complex problems into clear, executable tasks.
• Frame problems in ways that AI agents can understand and execute.
• Put on the QA hat to validate outputs.
• Revise based on business feedback.

The coding part? That’s becoming the easy part. It’s everything else that needs to catch up.

The companies that will win using AI coding agents

The organizations that thrive won’t be the ones that get the best AI tools first (everyone will have access to similar tools). They’ll be the ones who reimagine their entire SDLC around the new constraint of human understanding, not machine execution.

That means flipping your resources with more time in discovery and less in development. It means tighter spec discipline but looser code reviews, because the code quality problem largely solves itself when you give AI agents explicit directions.

It means building cross-functional “solution engineers” instead of maintaining siloed specialists who hand off work at each stage. Your QA approaches need to scale with code output, not linearly with headcount.

The shift isn’t about implementing new tools. It’s about restructuring everything that happens before and after the code gets written.

We’re not all ready, but it’s happening anyway

Our customers are already saying it: “We don’t want to get rid of people. We want to do more.”

That’s the transition path. Companies won’t or don’t need to downsize their engineering teams. They will be able to significantly increase their output and tackle ambitious projects they previously couldn’t justify.

But this will only work if they fix the SDLC first.

Agile and sprint planning were designed for a process where coding was the bottleneck… and right now that world has just imploded.