The Developer Becomes the Driver
My three-pane, agent-driven workflow—and why judgment, design taste, problem solving, and writing matter more when code gets cheaper.
A coding session no longer begins with me opening an editor and deciding which file to type in first. My default workspace lives in Herdr (opens in a new tab), split into three panes: Pi (opens in a new tab) in one, Lazygit (opens in a new tab) in another, and a development server running in the third.
At a glance, it looks like a terminal setup. In practice, it is a diagram of how my role as a developer is changing.
The agent handles much of the implementation. I set the direction, provide context, challenge decisions, inspect the diff, and judge what appears in the browser. I may be writing less syntax by hand, but I am not doing less engineering. I am spending more time on the parts of the work that determine whether the code should exist in the first place.
The three-pane loop
The first pane is Pi (opens in a new tab), my coding-agent harness. This is where I describe the outcome I want, point the agent toward relevant context, and establish constraints. Pi (opens in a new tab) can read across the codebase, make coordinated edits, run commands, and validate its own work. The value is not that it can autocomplete a function. The value is that it can carry an implementation thread across multiple files without requiring me to manually translate every decision into syntax.
The second pane is Lazygit (opens in a new tab). It keeps the agent’s work legible. I can see the footprint of a change immediately: which files moved, what was generated, what was deleted, and whether an unrelated part of the system was touched. Git becomes more than version control here. It is the review surface and the checkpoint system for the conversation.
The third pane runs the development server. That pane keeps the browser honest. A type checker can tell me that a component is valid; it cannot tell me that a heading feels oversized, an interaction is hesitant, or a responsive layout loses its rhythm at 390 pixels. The running product is the source of truth.
Together, the panes create a tight loop: intent, implementation, observation, review. I can move through that loop without constantly rearranging tools or losing the thread of the product decision.
The job is moving up a level
For a long time, a large part of software development was the labor of translating a known decision into code. Agents are compressing that distance. Once the implementation becomes cheaper and faster, the scarce skill moves upstream: deciding what deserves to be built, defining what good looks like, and recognizing when a technically correct result is still the wrong product.
That makes the developer’s role feel more product-managerial, but not in the meeting-heavy sense of the title. The agent driver is closer to a hands-on product director: close enough to the system to understand its constraints, close enough to the interface to notice weak decisions, and responsible for turning an ambiguous goal into a sequence of verifiable changes.
The work shifts from “How do I write this?” toward better questions: “What problem are we solving?”, “What must remain unchanged?”, “What is the smallest coherent version?”, and “How will we know this is actually better?”
Agents amplify judgment
A capable coding agent can produce plausible code at extraordinary speed. Plausible is not the same as appropriate. It can faithfully solve the wrong problem, extend a weak abstraction, or polish an interaction that should have been removed.
Agents are powerful because they amplify direction. That is also what makes weak direction dangerous. More implementation throughput means a vague idea can become a large diff before anyone asks whether the premise was sound.
The driver has to supply the judgment the agent cannot infer from a repository alone. Is this interaction consistent with the rest of the product? Does the visual hierarchy communicate the right thing? Is this abstraction earning its complexity? What happens when the network is slow, the content is long, or the screen is narrow? The agent can help investigate every one of these questions, but someone still has to know they are worth asking.
Writing is becoming a technical skill
In an agent-driven workflow, writing is part of the interface. A prompt is not a magic incantation; it is a compact product specification. Vague writing transfers ambiguity into the implementation. Precise writing gives the agent a useful model of the outcome, the constraints, and the evidence required to call the task complete.
Before I ask an agent to change a system, I try to answer questions like these:
- What user or product problem should this change resolve?
- Which existing behaviors and constraints must remain intact?
- What is the smallest change that solves the whole problem?
- What are the likely failure modes and edge cases?
- How should it behave with a keyboard, on a phone, and on a wide screen?
- What checks, builds, screenshots, or runtime observations prove it works?
These are not merely better prompts. They are better engineering habits. The agent makes the cost of acting on clear thinking much lower, but it does not remove the need for clear thinking.
My operating loop
My workflow is deliberately simple:
- Define the outcome in product terms before discussing files.
- Give Pi (opens in a new tab) the relevant context, constraints, and definition of done.
- Let the agent inspect the repository and propose or implement the smallest coherent change.
- Keep the development server running and evaluate the actual experience, not only the code.
- Use Lazygit (opens in a new tab) to review the complete footprint and catch accidental scope.
- Ask follow-up questions based on evidence: the diff, the build, the browser, and the interaction.
- Commit a clean checkpoint, then begin the next loop.
The speed comes from keeping implementation, feedback, and review adjacent. The quality comes from refusing to confuse a completed diff with a completed product decision.
The skills that compound
If agents take on more of the coding labor, the developers who fare best will not simply be the people who generate the most code. They will be the people whose judgment improves what gets generated.
- Problem solving — the ability to reduce ambiguity, find the real constraint, and frame a tractable sequence of work.
- A keen eye for design — not decoration, but sensitivity to hierarchy, interaction, clarity, pacing, and the details that shape trust.
- Strong writing — the ability to communicate intent, constraints, tradeoffs, and feedback without leaving the important parts implicit.
- Technical judgment — enough understanding of architecture, security, performance, and maintainability to recognize when fast code creates slow problems.
These skills have always mattered. Agent-driven development makes them more visible because the mechanical part of implementation is no longer the dominant bottleneck.
This is not developerless development
Saying that agents take care of the coding can sound like saying developers are disappearing. I think the opposite is more accurate: the developer’s area of responsibility is expanding.
Deep technical knowledge still matters. You need it to review architecture, investigate failures, identify unsafe assumptions, and know when an agent’s confidence is not deserved. But technical knowledge now sits beside product sense, communication, and taste rather than standing in for them.
One person can carry a larger surface area of a product than before. That leverage is real, but only when judgment keeps pace with output. Otherwise, agents simply help us create inconsistency faster.
The future belongs to good drivers
I do not think developers are going away. I think the role is broadening into a hybrid of product manager, design critic, systems thinker, editor, and technical lead. The best developers will remain close to the code while spending less of their energy typing every line of it.
Their advantage will be knowing what to ask, what to notice, what to reject, and what to refine. They will create the conditions for an agent to do excellent work, then take responsibility for the result.
The future is not software without developers. It is software shaped by developers who know how to direct machines without surrendering judgment.
Comments
Sign in to write a comment.
Loading