Hartley Brody

It seems now that the transition to AI-driven software development is inevitable. The cat is out of the bag, since the productivity improvements are just too important.

So what is a software engineer to do? This article from antirez sums it up nicely

Whatever you believe about what the Right Thing should be, you can’t control it by refusing what is happening right now. Skipping AI is not going to help you or your career. Think about it. Test these new tools, with care, with weeks of work, not in a five minutes test where you can just reinforce your own beliefs. Find a way to multiply yourself, and if it does not work for you, try again every few months.

Testing the new tools for a few weeks – and trying new things every few months – seems like it will be essential for anyone who wants to survive this massive industry transition. Riding the wave instead of getting crushed beneath it. 🏄‍♂️🌊

From my own experience over the past year, testing things out myself, it seems like there will be stages of transition from the old way of working – hand written code, crafted with love – to whatever this brave new world will be.

Stage 1: Chat UI

Describing issues you’re having in a chat pane (ie desktop or web UI for chatGPT), then copy/pasting the generated code into your editor w lots of manual edits.

You turn to the AI when you’re stuck or need help coming up with something. You need to manually provide lots of context and copy/paste code into and out of chat pane, so it still feels tedious and you only net a 5-10% improvement in productivity. Sometimes you get the sense it would have been faster to just do it yourself, without the AI.

Stage 2: AI in the Editor

Prompting AI in a file within your editor (ie cursor) where it has more context. Making light edits and accepting tab completions.

The AI helps when you get stuck, and it can also write novel code mostly correctly, with minimal manual edits needed. 10-25% improvement in productivity. You probably need to start paying $20/mo to avoid hitting limits.

Stage 3: Coding Agent in the Editor

You start prompting a coding agent to make changes that involve edits to multiple files. You then review those changes in your editor and do manual cleanup before committing and creating a PR.

You and the agent are working together in tandem. The coding agent stops to ask you for permission before running commands in its shell, which you manually review before approving. While you might click away for a minute or two as it works, you have to come back regularly to help it out.

You might also use “plan” mode to have the agent write a brief tech spec for you to sign off before it begins working. You’re no longer really “getting stuck” since the agent is coming up with the designs itself.

The agent is writing about 80% of the code correctly on the first pass in a few minutes, and then you go in and clean things up over the course of a few hours, to reach a finished PR that you feel good about putting your name on.

Your productivity is now nearly double what it was, when you weren’t assisted by AI. You still feel like a craftsman that’s not only responsible for the code functioning correctly, but also being “high quality.” You ice the cake that the AI bakes for you.

Stage 4: Coding Agent Under Supervision

Instead of primarily working out of an editor, you shift your primary UI to be whatever the coding agent provides (ie claude code, opencode). This means that the bulk of your development time shifts from “writing code” to instead “reading diffs + writing natural language corrections.”

You add a large collection of trusted commands the agent can run without consulting you, or maybe you even let it run “dangerously” with no permission prompts – make sure you’re using a sandbox!

You let the coding agent make multiple commits as you provide additional prompts to steer it. You review the final diff before letting the agent create the PR on your behalf. To the extent that there are any style changes that need to be made, you add those to an AGENTS.md file or just prompt it with the correction and let it try again.

You start worrying a bit less about “high quality” code – after all, you have tests and linters that perform those verifications, which the agent can use as well. As you feel a bit more hands off, your focus shifts more to throughput and iteration speed.

You’re about 2-3x more productive than you were before your AI-assisted journey began. You’re probably starting to pay $200/mo for access to higher limits from the coding agents, and might even strategically use different models for different sorts of tasks to help creatively manage your token usage.

Stage 5: Coding Agent Under PR Review

At this stage, you’ve started letting the agent use git worktree behind the scenes, so that you can have multiple agents working on multiple PRs at the same time on your development machine.

Alternatively, you’re using “cloud-based coding agents” like Claude Code on the web, where there is no local file system for you to make small corrections at all, you are entirely limited to a prompt-only interface with the agent.

Your primary role is reviewing the agents’ output and offering course corrections, or knowing when it needs to start over.

Now there’s lots of context switching and you can easily overwhelm yourself if you get carried away, ending up with a headache by lunchtime.

A main benefit here is that if you notice a bug or think of an unrelated-but-helpful feature while you’re working on a sprint task, you can simply spawn a new agent with a new git worktree to go off and tackle it. No more bug reports or task writeups that get tossed into a backlog only to languish forever. It costs almost nothing to pay down small tech debt immediately, once you discover it.

The agents might even create the PR for you… which might kick off another agent to review the changes and leave feedback, which you can review and decide if you should have the original coding agent address it.

You are still responsible for the code that ends up in the PRs associated with your name and sprint tasks. If you’re a decent coworker, you’ll still review it yourself and make sure you’re happy with things before asking your colleagues to review it… but some people feel like this is optional.

At this point, it starts to feel like it only takes a day to accomplish what might’ve normally taken a week, so you’re about 5x more productive.

Stage 6: Unsupervised Coding Agents (hypothetical)

The software engineer is no longer the human-in-the-loop who takes responsibility for the code. Instead, that responsibility shifts to business stakeholders, product managers, sales teams and ultimately customers who become the ones who “review” whether the software functions correctly (or at all).

The role of the software engineer essentially dissolves, and is replaced by a “coding agent technician” who manages the orchestration of the coding agents. Dropping feature requests and bug reports into the cage for the agents to chew through, and ensuring that they know to add new tests and run them, so that things don’t break.

Admittedly, I have never worked in an organization that allows this type of environment. But I have heard from friends who describe colleagues running coding agents 24/7, with almost no supervision, so apparently this does happen at some places.

At this level, organizational change is more important than any particular tools, SOTA models or workflows. As I’ve previously written about, it’s hard to imagine this being sustainable for most current organizations, but I imagine that a new generation of companies will embrace this model.

You might end up starting to see companies that sell software, where no one at the company even knows (or cares!) what programming language the application is written in. Application source code becomes as vexing and arcane as bytecode or CPU instructions are today. No one really needs to read, write, or understand it, as long as things seem to work correctly at the surface.

As an HN commenter said on my last article:

I think the “billion dollar single employee plus AI company” is still a ways away, but not actually that far.

Which of these stages are you in? Did I miss any? Will we really end up only being orchestrators for coding agents?

Discuss on HN.