跪拜 Guibai
← All articles
Code Standards · AI Programming

When the AI Bubble Bursts: Engineering Discipline Is the Only Hedge

By 喵个咪 ·
Read original on juejin.cn ↗ Google Translate ↗ Alt translation

When AI-generated code floods the market and then collapses under its own debt, the survivors will be engineers who can audit, own, and reconstruct systems, not prompt writers. A contract-first framework like GoWind offers a concrete workflow for turning that accountability into a daily development practice.

Summary

A hypothetical 2027 scenario puts vibe coding's accumulated technical debt into a crisis timeline. Enterprises that let AI generate their core business systems without anyone understanding the code face a shutdown wave: no docs, no design, nobody who can fix a concurrency fault or architectural collapse. Outsourcing teams that used AI to speed delivery face warranty claims that could force a brutal shakeout. The same scenario hits the supply side, with model providers shutting down and compute overcapacity echoing the fiber-optic dark fiber glut after 2000, where infrastructure outlives the asset's market value.

The aftermath rewards engineers with deep fundamentals: people who can read logs, refactor, and reconstruct AI legacy systems. AI's role gets confined to filling interfaces inside strong contracts, local 8B-32B models replace pay-per-token cloud APIs, and software delivery moves toward third-party audits of code robustness and "AI contamination." For individual technologists, four principles hold regardless of bubble direction: treat AI as an amplifier, not a crutch; accumulate fundamentals that survive cycles; cage AI with engineering discipline; and build verifiable credibility.

The author's GoWind framework institutionalizes these principles. A single .proto file compiles into backend gRPC stubs, HTTP stubs, error helpers, validators, PII desensitizers, OpenAPI docs, and TypeScript clients, so documentation and implementation can't diverge. The framework's fixed layering, Wire dependency injection, and CI checks leave AI with no freedom to define architecture, only to fill in business logic. Codegen handles deterministic output from table schemas, while AI fills the generated skeleton. GoWind Admin is a monolith; CMS is a minimal microservices layout that serves as a learning ladder. The bet is simple: engineering discipline is a hard requirement no matter what happens to AI.

Takeaways
— AI-written single-point code often exceeds human average quality, but systems without an overall owner run in an unmanned state, and that is where the real risk lies.
— Enterprises that vibe-coded their core systems will face shutdowns when deep concurrency or architecture faults appear, because nobody can read or fix the generated code.
— Outsourcing teams that used AI to speed delivery face astronomical warranty compensation claims when projects fail within the warranty period.
— A single-API dependency can kill a system overnight if the model provider folds, a faster version of the single-SaaS-vendor failure story.
— Compute overcapacity after a bubble will follow the 2000 dark fiber pattern: asset prices collapse, but the infrastructure remains and later carries the next generation of applications.
— After a loss of confidence, the market revalues senior engineers who can read logs, do performance analysis, and refactor AI legacy systems.
— AI governance converges on compliance-first workflows: strong types, CI/CD, SAST, and forced architectural layering reduce hallucination space.
— Local open-source models in the 8B-32B range become the enterprise default for security, cost control, and model autonomy.
— GoWind's .proto source of truth generates backend gRPC stubs, HTTP stubs, error helpers, validators, PII desensitizers, OpenAPI docs, and TypeScript clients with one buf generate command.
— GoWind's framework forces fixed directory structure, Wire dependency injection, unified error codes, and CI lint checks, leaving AI no authority to define architecture.
— GoWind's codegen creates three-layer API/Service/Data code, frontend CRUD, route permissions, and migration scripts from table structures, with AI filling the generated skeleton.
— GoWind Admin is a monolith design; CMS is a minimal microservices layout used as a teaching ladder from monolith to distributed systems.
Conclusions

The claim that AI code is above-average at single points but dangerously unowned as a whole captures the systemic risk of vibe coding: the bottleneck is accountability, not code quality.

The dark fiber analogy suggests that even a catastrophic AI bubble leaves behind useful infrastructure, meaning the tech itself is not what dies; the speculative financial structure is.

The author's scenario-based framing avoids a falsifiable prediction, letting the argument for engineering discipline stand regardless of whether the bubble actually bursts in 2027.

GoWind's rule that humans always hold architecture rights reflects a broader division of labor: AI does filling work, humans define boundaries and trade-offs, and the quality of that boundary definition is what separates good outcomes from bad ones.

Concepts & terms
Vibe Coding
A programming approach where a developer uses natural-language prompts to let an AI generate code, often without fully reading or understanding the output. The result may run, but the system has no single human owner who can explain how it works.
Deterministic development
A development methodology that confines AI output to strongly typed interfaces, fixed architecture rules, and reusable code generators so that every generated piece of code is predictable, auditable, and reproducible, reducing hallucination and undocumented behavior.
Contract-driven development
Using a formal contract file, such as a Protobuf .proto, as the single source of truth for interfaces, data models, errors, and validation. All related code, documentation, and clients are compiled or generated from that contract, making implementation and documentation impossible to drift apart.
Source: juejin.cn ↗ Google Translate ↗ Backup ↗