Software Engineering Is Becoming Plan and Review — Louis Knight-Webb, Vibe Kanban

As AI coding agents become more capable, software engineers will spend increasingly less time writing code and more time planning and reviewing AI-generated ...

By Sean Weldon

Abstract

The evolution of AI-powered coding assistants has fundamentally altered the temporal and cognitive demands of software engineering work. This analysis examines the transition from code-writing to planning and review activities as AI agents execute for progressively longer durations. Through empirical observation of tools ranging from GitHub Copilot (seconds) to Claude Code (5-10 minutes), a critical threshold emerges at approximately five minutes of agent execution time, beyond which engineers must adopt parallel work management strategies. The research identifies two primary interaction paradigms—plan-based and review-based approaches—and demonstrates that domain-specific characteristics (front-end versus back-end development) necessitate different agent collaboration patterns. The findings suggest that future software engineering productivity depends less on code generation speed and more on effective orchestration of multiple concurrent AI work streams, requiring novel tooling and mental models unfamiliar to traditional software development practices.

1. Introduction

The rapid advancement of AI coding assistants has precipitated a fundamental reorganization of software engineering labor. Tools such as GitHub Copilot, ChatGPT, Cursor, and Claude Code have progressively automated code generation tasks, yet the time previously allocated to writing code has not been eliminated but rather redistributed. This redistribution represents a qualitative shift in the nature of software engineering work, transforming practitioners from code authors into planners and reviewers of AI-generated artifacts.

AI coding agents are autonomous or semi-autonomous systems that generate, modify, and test source code based on natural language specifications or existing codebases. As these agents have evolved, their execution duration has extended from milliseconds to minutes, crossing critical thresholds that necessitate behavioral adaptation from human collaborators. This analysis examines the implications of this temporal expansion, identifying a pivotal transition point at approximately five minutes of continuous agent execution.

The central thesis posits that effective utilization of AI coding agents requires engineers to develop new competencies in parallel work stream management, strategic planning, and asynchronous review—skills traditionally outside the core software development discipline. Furthermore, the analysis demonstrates that optimal interaction patterns vary substantially across development domains, with front-end feature work requiring iterative in-the-loop collaboration while back-end and migration tasks benefit from comprehensive upfront specification.

2. Background and Related Work

2.1 Evolution of AI Coding Assistance

The trajectory of AI coding tools reflects increasing autonomy and execution duration. GitHub Copilot, introduced as an autocomplete mechanism, operates at sub-second latency to complete individual lines or small code blocks. Cursor extended this capability to file-level generation, typically completing operations within 30 seconds. Claude Code and similar contemporary agents now execute for 1-10 minutes, performing not only code generation but also type checking, testing, and quality assurance operations.

This temporal expansion correlates with increased task complexity. Early tools addressed syntactic completion, while current agents attempt semantic understanding of requirements, architectural consistency, and functional correctness. The integration of Model Context Protocol (MCP) tools, such as Playwright MCP for automated browser interaction, further extends execution time by an order of magnitude while enabling capabilities previously requiring human intervention, particularly in automated quality assurance of front-end implementations.

2.2 Work Distribution Transformation

Traditional software engineering work can be decomposed into three primary activities: planning (requirements analysis, architectural design, specification writing), implementation (code writing), and review (testing, code review, quality assurance). Historically, the majority of engineering time was allocated to implementation, with planning and review occupying minority portions of the work cycle. The introduction of AI coding agents has inverted this distribution. Empirical observations suggest that for every 30 minutes previously spent coding, approximately 20 minutes are displaced by agent automation, with this reclaimed time necessarily reallocating to planning and review activities rather than representing net productivity gains.

3. Core Analysis

3.1 Interaction Paradigms: Plan-Based versus Review-Based Approaches

Two distinct interaction paradigms have emerged for collaborating with AI coding agents. The plan-based approach emphasizes comprehensive upfront specification, typically instantiated as detailed markdown documents that exhaustively describe requirements, edge cases, architectural constraints, and acceptance criteria. Practitioners employing this method engage in iterative interrogation of language models, posing questions and refining specifications until all ambiguities are resolved before agent execution begins. This approach minimizes subsequent review cycles, as the agent receives sufficient context to generate correct implementations with fewer iterations.

In contrast, the review-based approach minimizes initial planning investment, providing agents with minimal specifications and relying on multiple correction cycles to converge on acceptable implementations. While this method reduces upfront cognitive load, it incurs substantial costs in human-agent context switching. The cognitive expense of reviewing partially correct implementations, identifying deficiencies, articulating corrections, and re-reviewing subsequent attempts proves considerably higher than the planning investment avoided.

Quantitative analysis of these approaches reveals a compelling efficiency differential. The plan-based method demonstrates that five minutes of additional planning investment yields approximately 30 minutes of review time savings. This 6:1 return on planning investment stems from the reduction in correction cycles and the elimination of context-switching overhead. Consequently, when optimizing for human time efficiency—the primary constraint in software engineering work—the plan-based approach demonstrates clear superiority for tasks amenable to comprehensive specification.

3.2 Domain-Specific Interaction Patterns

The optimal interaction paradigm varies substantially across software engineering domains. Front-end feature development presents unique challenges that resist comprehensive upfront specification. The inherently stateful nature of user interfaces, coupled with complex interactions involving animations, styling, and responsive behaviors, creates a specification space too large to exhaustively document. Furthermore, subjective aesthetic judgments and emergent interaction patterns only become apparent through direct observation of implementations. Consequently, front-end work necessitates an in-the-loop collaboration pattern where engineers remain actively engaged with agents throughout execution, providing real-time feedback on visual and interactive elements.

Back-end feature development exhibits markedly different characteristics. Business logic, data transformations, and API contracts can be precisely specified through type signatures, input-output examples, and behavioral descriptions. This domain proves highly amenable to test-driven development methodologies, where comprehensive test suites serve as executable specifications. Back-end work therefore benefits maximally from plan-heavy approaches, with agents executing autonomously against well-defined acceptance criteria.

Refactoring and migration work represents the extreme case of specification clarity. These tasks possess objectively verifiable correctness criteria: the refactored or migrated system must exhibit identical behavior to the original implementation. This characteristic enables entirely test-driven approaches with no in-the-loop human interaction required during agent execution. Comprehensive test coverage provides complete specification, allowing agents to operate autonomously with high confidence in correctness.

3.3 Temporal Thresholds and Behavioral Adaptation

Agent execution duration has emerged as a critical factor determining optimal human collaboration strategies. A threshold exists at approximately five minutes of continuous agent execution time, beyond which human behavioral patterns must fundamentally change. Below this threshold, engineers can passively monitor agent progress through log observation or engage in brief, low-cost context switches to other tasks. The cognitive overhead of these activities remains manageable, and engineers can maintain sufficient context to immediately review completed work.

Beyond the five-minute threshold, passive monitoring becomes untenable. The opportunity cost of idle human time during extended agent execution necessitates parallel work strategies. This transition point has been empirically observed with Claude Code's evolution from 1-2 minute execution times to current 5-10 minute durations, particularly when incorporating automated quality assurance tools like Playwright MCP that extend execution by an order of magnitude.

3.4 Parallelism and Multi-Stream Work Management

The extension of agent execution beyond critical temporal thresholds necessitates parallel work stream management, a capability historically outside the core competency of most software engineers. The terminal maxing pattern has emerged as a response to this requirement: engineers initiate multiple concurrent agent executions across different tasks, ensuring that completed work awaits review whenever the engineer completes their current review cycle. This approach eliminates idle human time while maintaining continuous agent productivity.

However, parallel execution introduces substantial cognitive complexity. Managing multiple concurrent work streams requires tracking distinct contexts, specifications, and review criteria across simultaneous tasks. The focus maxing concept addresses this challenge by minimizing context-switching frequency between agent streams. Rather than continuously cycling through all active agents, engineers complete full review cycles on individual work streams before transitioning to the next, thereby preserving cognitive capacity and reducing the mental overhead associated with context reconstruction.

4. Technical Insights

4.1 Tool Requirements for Parallel Agent Management

Effective parallel agent management requires tooling capabilities that extend beyond current software development environments. Essential requirements include native support for managing multiple concurrent work streams with distinct contexts, Git work trees, and dependency environments. The system must minimize human context-switching overhead through intelligent work presentation and prioritization mechanisms.

Task planning and specification writing capabilities must be integrated directly into the workflow, enabling rapid iteration on specifications before agent execution. Quality assurance and code review functionality should operate as first-class workflow components rather than external processes. Change shepherding—the continuous monitoring of GitHub pull requests, automated response to reviewer comments, and management of deployment pipelines—represents an emerging requirement as agents assume responsibility for the complete feature delivery lifecycle rather than merely code generation.

4.2 Implementation Considerations

The Vibe Kanban implementation provides concrete insights into practical parallel agent management. The system supports eight popular coding agents including Codex and Claude Code, creating isolated Git work trees and executing setup scripts to install dependencies before agent execution. Live preview functionality compiles changes through Cloudflare CDN infrastructure, enabling real-time observation of front-end modifications. GitHub pull request workflows integrate with live preview and inline commenting capabilities, replicating familiar code review patterns while accommodating agent-generated work.

4.3 Market and Sustainability Constraints

The Vibe Kanban case study illuminates critical market dynamics in the AI coding tool ecosystem. Despite achieving 30,000 monthly active users and 25,000 GitHub stars, the platform proved economically unsustainable. Operating as a UI layer for existing agents rather than a proprietary coding agent created an unfavorable value capture dynamic: users spent approximately $30 with Vibe Kanban to enable $3,000 in spending with underlying agent providers. This 1:100 value capture ratio proved insufficient for sustainable business operations.

Current market conditions support only two viable business models: enterprise sales and token reselling. Tools positioned as infrastructure layers for existing agents face structural disadvantages in value capture, regardless of user adoption metrics. The user base composition—primarily individuals, startups, and smaller companies—further constrained monetization options, as enterprise pivot would have required fundamental product and go-to-market restructuring.

5. Discussion

The transformation of software engineering work from implementation to planning and review represents a fundamental shift in professional practice rather than mere incremental productivity improvement. This transition necessitates the development of new cognitive skills and work patterns that differ substantially from traditional software development. The ability to comprehensively specify requirements, manage multiple concurrent work streams, and efficiently review AI-generated artifacts becomes as critical as coding proficiency itself.

The domain-specific variation in optimal interaction patterns suggests that no single collaboration paradigm will universally optimize human-agent cooperation. Front-end development, back-end development, and refactoring work require fundamentally different approaches, implying that effective tooling must support multiple interaction modalities rather than enforcing uniform workflows. This heterogeneity challenges the development of standardized best practices and suggests that engineering education must incorporate domain-specific agent collaboration strategies.

The temporal threshold phenomenon—the critical transition at five minutes of agent execution—represents a predictable scaling challenge as agents assume increasingly complex tasks. As agent capabilities expand to encompass full feature implementation, comprehensive testing, and automated quality assurance, execution times will continue to extend. This trend will intensify the necessity for parallel work management capabilities and may ultimately require organizational restructuring to accommodate asynchronous, multi-stream development workflows.

6. Conclusion

This analysis demonstrates that the evolution of AI coding agents has fundamentally restructured software engineering labor, shifting the primary focus from code implementation to planning and review activities. The emergence of a critical temporal threshold at approximately five minutes of agent execution necessitates parallel work management strategies and novel tooling capabilities. Domain-specific characteristics—particularly the distinction between front-end and back-end development—require different interaction paradigms, with plan-based approaches demonstrating clear efficiency advantages for specifiable tasks.

The practical implications for software engineering practice are substantial. Organizations must invest in developing engineer competencies in specification writing, parallel work stream management, and efficient asynchronous review. Tooling ecosystems must evolve to support these workflows through integrated planning, multi-stream management, and change shepherding capabilities. The market dynamics surrounding AI coding tools suggest that sustainable business models remain constrained to enterprise sales and token reselling, creating challenges for infrastructure layer innovations regardless of user adoption.

Future research should investigate optimal training methodologies for parallel work stream management, quantitative analysis of plan-based versus review-based efficiency across diverse task types, and organizational structures that maximize productivity in asynchronous, agent-mediated development workflows. As agent execution times continue to extend and capabilities expand, the software engineering profession will increasingly resemble project management and quality assurance disciplines, requiring corresponding evolution in educational curricula and professional development frameworks.

Sources

About the Author

Sean Weldon is an AI engineer and systems architect specializing in autonomous systems, agentic workflows, and applied machine learning. He builds production AI systems that automate complex business operations.

LinkedIn | Website | GitHub