Software Engineering Is Becoming Plan and Review — Louis Knight-Webb, Vibe Kanban
As AI handles more of the coding, the role of a software engineer is shifting from writing code to planning and reviewing the work of AI agents. This talk explores the implications of this shift, the new workflows it demands, and the tools required to manage them effectively.
The Core Thesis: AI is Shifting Work to Planning and Review
The fundamental nature of a software engineer’s job is changing. Historically, the work was a mix of planning, writing code, and reviewing code, with the bulk of the time spent on writing. With the advent of powerful AI tools like GitHub Copilot, ChatGPT, and Claude, the “writing code” portion of the job is shrinking dramatically.
This time isn’t simply freed up; it’s displaced. The time previously spent on implementation has moved into the planning and reviewing phases. While AI acts as an accelerant, making developers more productive overall, the core human activities are becoming managerial: defining the work to be done and verifying the work that the AI has completed.
Spending 5 minutes of planning saves you 30 minutes of reviewing AI-generated code.
Two Approaches to AI-Assisted Development
There are two primary modes of interacting with coding agents, each with its own trade-offs:
-
The Plan-Based Approach:
- Process: Involves significant upfront investment in creating a comprehensive plan, specification document, or markdown file. This can involve using spec frameworks or engaging in an interrogative process where the model asks clarifying questions until all ambiguity is removed.
- Benefits: Leads to higher-quality output from the AI, fewer errors, and significantly less time spent in the review cycle. By eliminating edge cases early, the model is less likely to fail.
- Downside: Requires more time dedicated to planning before any code is generated.
-
The Review-Based (Iterative) Approach:
- Process: Involves giving the AI a high-level, less-detailed prompt (e.g., “add a contact form”) and then iterating with the agent through multiple rounds of review and correction.
- Benefits: Faster to get started; you can “YOLO” an idea into existence quickly.
- Downside: This approach is time-consuming due to the context-switching required to go back and forth with the agent, correcting styles, fixing bugs, and refining the output. From a human-time-value perspective, this is generally less efficient.
A Matrix for Choosing Your Approach
The optimal approach often depends on the type of work being done. A useful mental model is a matrix based on the stack (frontend/backend) and the task type (feature development/maintenance).
- Frontend Feature Development: This work is highly stateful with complex interactions, animations, and styles. It’s nearly impossible to specify everything upfront, making an in-the-loop, review-heavy approach more practical.
- Backend Feature Development: This is more conducive to a plan-heavy approach. It’s possible to use methodologies similar to test-driven development (TDD) to clearly define requirements and expected outcomes.
- Refactoring & Migrations (Frontend & Backend): These tasks are ideal for a plan-heavy strategy. They should be almost entirely automated and test-driven, requiring minimal human intervention during the code generation loop.
The Expanding Time Horizon of AI Agents
As AI models and their tooling become more sophisticated, the duration of a single agent “run” is increasing.
- Past: GitHub Copilot completed a line of code in seconds.
- Present: Tools like Cursor or Claude Code can generate entire files, running for 30 seconds to a few minutes. Current advanced agents can run for 5-10 minutes as they incorporate steps like running type checkers or tests.
- Future: The frontier involves agents that can perform their own QA by running the project, clicking through the UI (e.g., with Playwright), and identifying their own bugs. These end-to-end tasks will take significantly longer.
This creates a new challenge: what happens when the average agent run time crosses the 5-minute threshold? A developer can’t just sit and watch logs for 20 minutes. This necessitates a behavioral shift from single-tasking to parallelism—managing multiple agent tasks simultaneously.
The Need for New Interfaces and a Founder’s Farewell
Existing developer tools are not designed for this new paradigm of managing multiple, long-running streams of AI-driven work. The ideal tool needs to be built around “focus maxing”—getting the most out of human attention by batching tasks and avoiding constant context switching.
This tool should:
- Help you plan and write tasks effectively.
- Facilitate QA and code review.
- Embrace the asynchronous nature of long-running agents.
- Shepherd changes through the entire deployment pipeline, from PR to production.
The speaker, Louie, revealed that his company, Vibe Kanban, was built to solve this problem by allowing developers to parallelize coding agents. In a surprising turn, he announced he was shutting down the company. He cited the difficulty of monetizing in a market where value is captured by those reselling LLM tokens to large enterprises. Vibe Kanban, which focused on individual developers and startups, couldn’t find a sustainable business model. The project will, however, continue as a non-commercial entity.