Back to blog

Complex systems will still punish Vibe First: What is really scarce in the AI ​​era is specification and verification discipline

When AI pushes the coding speed to new highs, the team's deepest bottleneck emerges earlier: unclear requirements boundaries, unexecutable acceptance, and untraceable responsibilities. This article starts from Replit's discussion spread and explains why the competition points of complex products are returning to spec, ownership and observability.

March 23, 20265 min read
news-analysisAI Generatedmanagement-news reactionnews-analysisZH-TWmanagement-news

This article started as an AI-generated draft and was reviewed before publication.

Complex systems will still punish Vibe First: What is really scarce in the AI ​​era is specification and verification discipline

What’s really worth noting is not who AI allows to write faster, but whose specification flaws it allows to come to light more quickly. After March 16, 2026, Replit-related discussions quickly amplified, and many people read it as "vibe coding is not good". I think this interpretation is too shallow: what is proven is not that a certain tool fails, but that the physical laws of delivery of complex systems have not changed. When you enter multi-role processes, data models, permissions and asynchronous states, the winning and losing points must come back to spec, judgment and verification discipline.

Let’s get the focus right first. AI has indeed greatly reduced the cost of grammar and boilerplate, but it has not eliminated the cost of system decision-making. As a result, the team will have a common misunderstanding: commits are made quickly in the early stage, and functions seem to grow continuously. It is not until the integration period that the boundary definitions are inconsistent, wrong paths are not covered, and role permissions conflict with each other. It seems to be a speed issue, but it is actually a definition issue.

Why does the bottleneck become more painful when the speed becomes faster?

When implementation friction decreases, uncertainty does not disappear, it is simply pushed back. In the past, you were stuck in the coding stage, but now you may be stuck a week before going online. This is why many teams feel that "AI makes development faster, but delivery is not more stable": rework is delayed rather than eliminated.

If we put it back into the team's daily routine, we should first ask: Can our acceptance criteria be directly verified? Demand that cannot be verified is equivalent to leaving risky debt to integration and maintenance.

What the team will copy is not the prompt, but the specifications.

In the personal demo stage, prompt techniques can create huge efficiency differences; in the multi-person collaboration stage, what is truly replicable are specification assets that can be quoted, handed over, and audited: interface contracts, data dictionaries, acceptance conditions, and test cases. It is usually not the most complete system that will spread, but the most understandable and reproducibly verifiable.

This is why “Vibe First” often succeeds in small areas but stalls in complex products. It’s not that everyone can’t write, it’s that no one can take over without guessing.

The focus of competition shifts from producing code to compressing uncertainty.

This is important not because of the functionality itself, but because the delivery bottleneck has moved from implementation to judgment. When generative capabilities become widespread, the difference will not be in output, but in who can define boundaries earlier, who can establish feedback closed loops faster, and who can observe failure modes first.

The question is not whether it can be done, but whether it can be done stably, observably, and maintainably. This means that the roles of PM, Tech Lead, and architecture will not be weakened, but will become more like risk compressors: turning vague requirements into testable hypotheses, and moving cross-role conflicts forward to the planning period for resolution.

The second-order effects of this wave of transfers

The cost of AI import will mainly fall in the following places:

  • Adoption cost: You need to rewrite the requirements template, code review specifications and testing strategies, not just install the tools and end it.
  • Operability: Without runbook and fault classification, the generation speed will directly turn into maintenance noise.
  • Observability / Debugability: Without event tracking and status visualization, the team only sees the result error and cannot see which path the error lies in.
  • Cognitive load: When the specification semantics are not accurate, engineering time will be eaten up by "guessing the product intention".
  • Ownership boundary: If the responsibility boundary is not redrawn, responsibility will drift between PM, project, and platform when an accident occurs.

Before adopting AI, do three layers of governance

I suggest to upgrade the process first, and then accelerate the generation:

  1. Spec Gate: Every Epic must have goals, boundaries, non-goals, and acceptance conditions, all of which are indispensable.
  2. Verification Gate: Convert acceptance criteria into executable checks, covering at least integration, data constraints and permission cases.
  3. Runtime Gate: Define the minimum set of observables (key events, state transitions, error classification) for high-risk processes.

The next level down is to define the boundaries of AI usage: which modules can be generated in large quantities, which architectural points must be manually adjudicated, and which processes are prohibited from automation. Finally, two indicators are used to verify the effectiveness: rework rate and whether the time when defects are discovered has been moved forward.

Risks and Boundaries

This judgment currently mainly comes from community discussions and practical observations. It is not a strictly controlled experiment, so it should not be interpreted as an absolute rejection of a single tool. Another common bias is excessive governance: applying the same set of heavy processes to all tasks will offset the efficiency dividends brought by AI. A more feasible approach is to manage risk-based stratification rather than one-size-fits-all.

final judgment

What AI will eliminate is not engineers, but the delivery process without specification discipline.

Sources and References