The cost YAGNI was never about
Software engineers are reexamining the “You aren’t gonna need it” (YAGNI) principle in light of AI-assisted coding and cheaper refactoring. Some argue that speculative abstractions and premature structure still create costly technical debt, while others say strict YAGNI can undercut necessary “table stakes” features and make future changes harder or politically impossible. Several commenters note that AI lowers the cost of writing code and tests but can also generate brittle test suites and poorly structured code, so judgment about when to generalize, when to defer, and how to keep systems safely evolvable remains critical.
AI, Restructuring, and Opportunity Cost
- Some argue AI has sharply reduced the cost of restructuring, adding tests, and doing sophisticated zero-downtime migrations, making “easy, safe change” the primary optimization goal.
- Others counter that AI mostly accelerates typing and boilerplate, not the true bottlenecks (coordination, risk management, approvals).
- In large organizations, deployment frequency is constrained by bureaucracy and risk controls; AI doesn’t change contract deadlines or governance.
- Concern that AI-generated tests and code often increase brittleness and make safe refactoring harder, especially when agents are poorly guided.
YAGNI, Prediction, and Option Analogy
- Core tension: YAGNI says “don’t build speculative features/structures”; critics note that this itself is a prediction about the future (“you aren’t gonna need it”).
- Supporters emphasize: you usually overestimate your ability to foresee future needs; abstractions are better built after seeing real use cases (“rule of 3”).
- Detractors say YAGNI often becomes a reflexive “no” that blocks legitimate future-facing design, especially when developers don’t understand the domain or ignore stakeholders.
- The article’s financial-option analogy is debated: some see unwritten code as preserving flexibility; others say only implemented behavior has value, and “scaffolding” is just paid option premium that may never pay off.
Abstractions, Technical Debt, and Testing
- One camp claims most tech debt comes from over-generalized, unused abstractions that constrain future changes.
- Another camp points to rushed, under-architected code with layer violations and weak tests that later become “load-bearing messes.”
- AI-driven test generation is criticized for creating large, brittle test suites; mutation testing is seen by some as over-indexing on catching any code change, further raising refactor cost.
Process Context: Agile, Waterfall, and Domain Constraints
- Hardware/chip and safety-critical domains are highlighted as places where agile/YAGNI-style thinking fits poorly due to huge change costs; more traditional, waterfall-like processes and independent verification remain standard.
- Others note “shift left” and iterative practices existed long before agile branding; agile mainly packaged and popularized them.
Reaction to the Article and AI Use
- Several commenters find the main body of the piece incoherent or “word soup,” attributing this to its explicitly AI-generated portion.
- Some see the post as a useful experiment in “agent optimization”; others view it as a distraction that weakens the underlying YAGNI argument.