Optimizing Development Cost in the AI Era: Shifting Scope Discipline
This article discusses how AI-assisted code generation changes the cost dynamics of software development, particularly for small feature requests. It argues that the expense has shifted from initial code writing to understanding, reviewing, and owning the code. The core system design implication is a re-evaluation of scope discipline and the role of rapid prototyping using AI as a 'price check' for feature implementation.
Read original on GitHub EngineeringThe Shifting Cost Landscape of Software Development
Traditionally, the most expensive part of a feature request was the actual coding. This led to an engineering instinct to heavily debate and validate scope upfront to avoid costly implementation tangents. However, with the advent of AI code generation, the cost of producing an initial code patch has significantly decreased. This fundamental shift requires re-evaluating long-held software development practices and decision-making processes, especially concerning how we assess and manage technical debt and complexity.
AI as a 'Price Check' for Implementation
Instead of lengthy debates on whether a 'small ask' is truly small or in scope, the article proposes using AI to generate a preliminary patch. This initial code is not the final deliverable but a "probe" or "price check" to quickly gain concrete evidence about the change's actual scope and impact. This allows teams to move from arguing based on abstract notions to evaluating a tangible artifact, making scope discipline more evidence-driven.
Key Questions for Evaluating AI-Generated Patches
When using AI for a "price check," focus on: Is the diff contained or sprawling? Are tests clear or difficult to write? Does it maintain existing abstractions? Does it introduce new product decisions? Can a human confidently own this behavior long-term? These questions reveal the true cost beyond just code generation.
Distinguishing Cheap-to-Write from Cheap-to-Own
The critical distinction in the AI era is that a change is not cheap merely because its code was easily generated. It is cheap only if a human can confidently review and own the resulting behavior. A large or complex diff, even if AI-generated, that nobody wants to take responsibility for is a deferred cost, not a cheap change. The true measure of cost shifts to the effort required for human validation and long-term maintenance.
- Cheap-to-own examples: Adding a display field from existing backend data, refactoring a well-tested helper function.
- Expensive-to-own examples: Changing authorization logic, altering data retention policies, modifying core product contracts, introducing privacy/billing/compliance implications.
Shifting Scope Discipline Closer to Evidence
Traditionally, scope discipline occurred _before_ implementation to protect against expensive coding efforts. Now, some of that discipline can move to the review stage. This doesn't eliminate planning but makes it more precise. By asking for a _constrained_ attempt (smallest possible patch, behind a feature flag, no public contract changes, tests included), teams can use AI-generated output to better price uncertainty. This allows for informed decisions based on concrete costs rather than speculative debates.