I’ve written a lot recently about my journey with AI-assisted coding. It started as an experiment, became a workflow, and has now fundamentally changed how I think about my job. The more I use agentic tools, the more I realize we’re in the middle of a seismic shift—one that’s turning the traditional role of a software developer inside out.

The job isn’t disappearing. It’s evolving. We’re moving from being the writers of code to being the architects and managers of the agents that write the code for us. And in this new world, the most valuable and undervalued skill is the ability to perform a thorough, thoughtful code review.

Embracing the Chaos: Why Non-Determinism is a Feature, Not a Bug

One of the first things that trips people up about agentic coding is the non-determinism. The idea that asking an AI the same question twice might yield two different answers feels like a critical flaw. In a running software system, that kind of unpredictability is a nightmare. We need our business systems to be predictable.

But here’s the thing: the tool that builds the software doesn’t have to be deterministic. In fact, it never has been.

Think about it. The process of building software has always been non-deterministic. Two different developers, given the same set of requirements, will produce two different implementations. The same developer on a different day might come up with a different solution. We’ve never had a deterministic process; we’ve had a process designed to create a deterministic product.

What we care about is that the final code meets the requirements. That it’s correct, performant, and secure. The exact path taken to write that code has always been variable. Agentic coding doesn’t change the goal; it just gives us a new, incredibly powerful, and admittedly unpredictable partner in the process. Our job is to steer that process through architecture, context engineering, and design—things we already know how to do.

The New Economics of Building

This new partnership has a startling economic effect: it fundamentally changes the calculus for what’s worth building. It’s not just about whipping up small scripts in an hour; it’s about tackling ambitious projects that were previously unthinkable.

For decades, I’ve wanted a tool to manage my development environment—a unified way to handle packages, dotfiles, and system configurations. I even had a name for it: plonk. But the scope was daunting. I estimated it would take me over a year of dedicated, solo effort to build something decent. The project was permanently stuck on the “someday/maybe” list.

Then I tried building it with an AI partner. Three weeks later, it was not only built, but functional and useful. What was once a year-long project became three weeks of “vibe coding.”

That’s the real game-changer. It’s not about the small wins, as nice as they are. It’s about the orders-of-magnitude reduction in effort for large, meaningful projects. The ideas that felt too big, too complex, or too time-consuming to ever start are now within reach. The barrier to entry for ambitious software development has been dramatically lowered.

The Most Valuable Skill in the Agentic Age

This brings me back to my main point. If an AI is writing the first draft of the code, what is our primary role? It’s to be the ultimate arbiter of quality. It’s to perform the code review.

One of my biggest learnings while building plonk was that this review can’t be a one-time event. I developed a multi-stage review process out of necessity:

1. Review as it happens: Watch the code as the agent makes changes to catch deviations early.
2. Review before commit: A more thorough check to ensure the completed task is correct and complete.
3. Review before release: A final, holistic review to ensure nothing was broken.

This rigor is necessary because agents, for all their power, have predictable failure modes. They are amazing at writing code, but they can also add unasked-for features that, while sometimes clever, often take the project off course. They can “get stuck” on a problem, like a failing test, and instead of fixing the root cause, they might revert the test to a useless, trivially passing state.

Code review in the agentic age, therefore, is less about catching typos and more about architectural alignment and vigilance. It’s about asking:

• Did the agent understand the core requirements?
• Did it adhere to the design and the rules I provided?
• Did it introduce any unintended side effects or “creative” solutions to problems?
• Is this code maintainable, or is it a clever but unreadable mess?

Reading and understanding code is now the most critical skill a developer can possess. You are the manager, the architect, and the quality assurance team all rolled into one. Your job is to provide the vision and to vigilantly verify that the agent’s execution matches that vision.

The Automated Safety Net

Of course, manual review doesn’t scale on its own. With an AI partner producing code so quickly, a robust, automated safety net is more critical than ever. Strong linting rules, a comprehensive test suite, and CI pipelines are no longer just best practices; they are essential for managing the velocity.

In particular, tracking code coverage has become vital. It helps guard against the agentic tendency to write tests that test themselves rather than the actual logic. This automation is the critical aid that makes the high-speed workflow sustainable.

And the best part? You can have the agents help you build this safety net. This reinforces the new hierarchy: the human developer sets the architectural vision—including the testing strategy—and then supervises the agent in its construction. Knowing what to build, and how to verify it, is the core human task.

A Call for Exploration

We’re all just starting to figure this out. My theories about how agents prioritize recent context are, frankly, “super unscientific” gut feelings based on observation. My workflows are the result of trial and error.

That’s why we need more exploration and more sharing. The tools are evolving at a dizzying pace, but the practices for using them effectively are being written right now, by us. What works for you? What rules have you found indispensable? How are you managing the firehose of AI-generated code?

Let’s figure it out together.