I’ll try to disagree with this without calling BS on it :) There’s a lot here I agree with. Software is getting dramatically cheaper to produce. Agents should go horizontal across the SDLC. Humans should move higher up the abstraction ladder. And staring at every line of AI-generated code is definitely not the future. But I think some of the conclusions go too far. “Slop doesn’t accumulate because we now have incredible models that can help us fight it.” I don’t think that’s true. Or at least, not that straightforward. Some code slop may become increasingly cheap to clean up. Architectural drift isn’t. Lost intent isn’t. A hidden dependency isn’t. A security invariant nobody remembered to tell the agent about isn’t. The ugly workaround that exists because of a production incident three years ago isn’t. And developers knowledge slop isn’t!! A model can make ugly code beautiful. It cannot recover organizational knowledge that the system never preserved. Think about this for a sec please That’s why I think better models actually make the surrounding system MORE important, not less. Then there’s the idea of: prompt the what, not the how. Strongly agree with the direction. Humans should increasingly own intent, architecture, standards, values, tradeoffs and goals. But the “how” doesn’t disappear. It moves into the system. Into skills, policies, architectural constraints, organizational memory, evaluations, tools, and the rules by which agents are allowed to act. Please, let’s not over hype people here. It is quite incredible that we can shirt our work from code to this higher abstraction, but it does include the how. Whoever says otherwise, almost feels like they are working on some simple product, maybe some simple CLI tool. And then the part I disagree with most: no PRs, no code review. I can absolutely imagine a future with no PRs. Yes. I cannot imagine a serious software factory with no independent review. Those are very different statements. The PR is an interface. Review is a function. The interface can disappear while the function becomes much more important. An agent can make a change without a human ever looking at the diff. But before that change ships, another independent system should be able to ask: What was the intent? What is the blast radius? How critical is this path? Which organizational assumptions does this touch? What evidence proves the behavior? What does production history tell us? Can this be safely rolled back? Does this change fall inside the factory’s autonomous operating domain? Unless you are building some with no user base. And only then: Does a human actually need to be involved? That’s the distinction I think matters. The future isn’t humans rubber-stamping every PR. But it also isn’t “agents got good enough, so review goes away.” “Agents are sooo good that the generative parts don’t need any adversarial counterparts” and human judgement- we might get there , but not yet. In fact, as agents become better at producing convincing, plausible, production-looking code, independent verification becomes more important. It happens so often that they make really bad mistakes. You are really not fixing agents daily? Because the dangerous failure is no longer obviously bad code. It’s code that looks completely reasonable while being wrong at the system level. And I think the same applies to the idea that bugs becoming cheaper to fix means we can relax process. Sometimes yes. A UI regression with a feature flag, great. Let the factory move fast. But “cost to repair” and “cost of failure” are not the same thing. An authorization bug, corrupted data migration, broken financial calculation or security incident can be cheap to patch and enormously expensive to experience. That’s why I think the right destination is not less control. It’s much more autonomy AND much more control