Overview: a paradigm shift in progress

Between 2025 and 2026, software development went through a dramatic convergence of paradigms: the twenty-year-old problem of "business design models" drifting apart from "underlying executable code" was hit with a hundred-fold acceleration by the explosion of AI coding, which in turn triggered an industry-wide governance pivot.

The through-line in one sentence:

  • In February 2025, Karpathy coined Vibe Coding ("forget that the code even exists");
  • Within half a year, empirical data showed code churn doubling and duplicated code quadrupling — in complex systems, AI became an "architecture demolition machine";
  • In February 2026, Karpathy himself declared Vibe Coding passé and pivoted to Agentic Engineering — humans no longer write 99% of the code directly; instead they act as architecture supervisors, orchestrating agents through specifications, eval loops and deterministic guardrails;
  • In parallel, the industry pushed hard along four fronts on "anti-hallucination and architecture governance", and best practice converged on Harness Engineering.

Prehistory: two decades of model–code separation (2001–2024)

Even in the era of purely hand-written code, keeping "high-level business semantic models" aligned with "underlying code" had been an ongoing struggle for over twenty years:

Period Attempt Outcome
2001–2006 OMG pushes Model-Driven Architecture (MDA) with heavyweight UML/XMI one-way code generation One-way generation was only a "one-time act" at project start. Once programmers edited source directly, model and code disconnected permanently — Model Drift (per the classic Czarnecki & Helsen research cited by the JDomInO paper)
2003–2019 Eric Evans introduces Domain-Driven Design (DDD), drawing consistency boundaries with bounded contexts and aggregate roots; the Swiss OST team open-sources Context Mapper DSL (CML) and the Context Mapper ArchUnit extension Model–implementation synchronization depended heavily on team discipline; deadline pressure inevitably caused model drift

Key conclusion: model drift is not a failure of team discipline but a failure of the toolchain — a judgment later formalized by the JDomInO paper, and one of the theoretical starting points of the entire AI-coding governance era.


The Vibe Coding explosion and its crisis (2025)

3.1 The concept explosion

In February 2025, a single tweet from Andrej Karpathy made Vibe Coding go viral:

"There's a new kind of coding I call 'vibe coding', where you fully give in to the vibes, embrace exponentials, and forget that the code even exists. It's possible because the LLMs (e.g., Cursor Composer w Sonnet) are getting too good."

Adoption was startlingly fast: in the YC Winter 2025 batch, 25% of startups had 95% of their code generated by AI.

3.2 The empirical data: a "maintainability gap" behind doubled output

When the development mode shifted from "humans hand-writing code" to "agents mass-producing thousand-line PRs", three sets of hard data exposed the brutal reality:

① Code churn doubled, duplicated logic proliferated

GitClear's 2025–2026 research series (analyzing between 153 and 211 million lines of changed code; see also Kunal Ganglani's breakdown and the Larridin report):

  • The churn rate — code modified or deleted within two weeks of being committed — soared from 3.3% in 2020–2021 to 5.7%–7.1%;
  • Lacking global context awareness, AI tends to "rewrite new logic rather than reuse existing abstractions", driving a 4x surge in duplicated code blocks while refactor-flavored "Moved Code" fell off a cliff.

② Defect rates up 1.7x and review paralysis

  • The Foundra 2026 founders report: AI-co-authored code carries 1.7 times as many major issues as purely human-written code;
  • Larridin and the Three Dots Labs engineering chronicle both point out: "writing code is no longer the bottleneck — reading code is". AI-generated PRs look right on the surface (clean syntax, complete comments), so reviewers rubber-stamp them — until two weeks later, when cross-module cascading failures ignite.

3.3 Academia weighs in: the flow–debt trade-off and architectural semantic blindness

3.4 Voices from the community front line (Hacker News / Reddit)

The local-attention trap — a top-voted comment on HN item?id=44940089 dissects why "watching AI write code" accelerates architectural decay:

"Reading vibe code 'localizes' our attention to the correctness of the code produced and clogging the processes that otherwise think about connection of this code to other parts of the system."

AI cannot spontaneously deduplicate or refactor globally — HN discussion item?id=44785562, where a developer likens Vibe Coding to "not declaring you'll build a 20-story tower first, but letting the LLM stack it room by room", and shares the typical failure of asking Claude Code to eliminate duplicated logic:

"Once it became plain that there was duplicate functionality and that it was a problem, yeah, the first thing she did was tell Claude at a high level to factor out duplicate functionality. This didn't really work - it would often implement a factored-out piece of logic but just leave the pre-existing code alone."

AI will even argue on behalf of its own bad code — microservices authority Chris Richardson recorded in his GenAI development platform guardrails write-up (microservices.io, Mar 2026) that when a Prompt Skill merely asks Claude Code to respect code-health checks, the agent frequently refuses to fix architectural smells, making excuses that the issues are "pre-existing" or "acceptable".

Collective community anxiety:

3.5 Willison pours cold water: Vibe Engineering draws the production line (Oct 2025)

Django co-creator Simon Willison first warned in Will the future of software development run on vibes? (Mar 2025):

"Vibe coding your way to a production codebase is clearly a terrible idea."

He then formalized Vibe Engineering in Vibe engineering (Oct 2025), stressing that senior engineers must discipline agents through up-front planning, specifications and automated test loops:

"You're not just responsible for writing the code—you're researching approaches, deciding on high-level architecture, writing specifications, defining success criteria, designing agentic loops, planning QA, managing a growing army of weird digital interns who will absolutely cheat if you give them a chance, and spending so much time on code review."


The formal pivot: Agentic Engineering (Feb 2026–)

In February 2026, exactly one year after coining Vibe Coding, Karpathy declared it passé (see The New Stack: Vibe coding is passé) and, in the Sequoia AI Ascent 2026 fireside chat (see also AI Builder Club's framework breakdown), formally iterated it into Agentic Engineering:

"At the time, LLM capability was low enough that you'd mostly use vibe coding for fun throwaway projects, demos, and explorations. It was good fun and it almost worked."

"Today (1 year later), programming via LLM agents is increasingly becoming a default workflow for professionals, except with more oversight and scrutiny. The goal is to claim the leverage from the use of agents but without any compromise on the quality of the software."

"Personally, my current favorite [is] 'agentic engineering': 'agentic' because the new default is that you are not writing the code directly 99% of the time, you are orchestrating agents who do and acting as oversight — 'engineering' to emphasize that there is an art & science and expertise to it."

The core demand: claim the leverage of AI coding agents while holding software quality to zero compromise through strong engineering discipline and deterministic architectural guardrails. The human role becomes "oversight" — orchestrating agents through specification design, eval loops and boundary control.

Industry signals confirmed the pivot: the April 2026 Thoughtworks Technology Radar Vol. 34 formally adopted "Architecture drift reduction with LLMs" and "Putting coding agents on a leash"; QCon AI Boston 2026 dedicated an evolution track to "anchoring AI coding agents with deterministic graph structures".


The solution-design shake-up: four evolutionary stages

Traditional drag-and-drop graphical UML (Visio, Enterprise Architect) is virtually extinct in the agile AI community — large models poorly understand pixel drawings and heavyweight XML, and diagrams drift out of sync with code far too fast. In its place, a rapid evolution:

Stage 1: single-prompt generation and the Vibe Coding wild west (2023 – early 2025)

Zero solution design; the prompt is everything. Developers give one sentence describing the outcome ("write a snake game in React"), leaving technology choices, module decomposition and data structures entirely to the LLM's imagination. The experience is delightful for standalone scripts under 500 lines, but in multi-module business complexity the agent quietly carves out the wrong abstraction boundaries beneath the surface, producing uncontrollable hidden cross-file coupling.

Stage 2: the prompt-roleplay multi-agent boom and disillusionment (2024 – mid 2025)

The community tried to imitate a human software company's pipeline: MetaGPT, ChatDev, CrewAI, AutoGen — prompting "PM agent → architect agent → programmer agent → reviewer agent" into meetings, code and refactors. In real engineering it receded quickly for three reasons: hallucination cascades, token-burning circular debates, and "verbal review cannot replace deterministic compilation and tests".

Empirical reality checks:

  • The r/better_claw 200-task local multi-agent benchmark (Jul 2026): multi-role orchestration frameworks hover at only 54%–58% completion on complex tasks:

    "The 200-task benchmark on Qwen3 32B puts complex-task completion at 54%, and my runs agreed. The failure mode is structural: when a mid-pipeline agent hits a bad tool result, CrewAI's recovery option is basically 'start over,' and on a second run the intermediate results differ, so outcomes aren't reproducible... The catch: without hard iteration caps, the failure mode is two agents politely debating in circles at 20 tok/s on your GPU until you kill the process."

  • The r/hermesagent multi-agent role-design retrospective (Oct 2026) (synthesizing MetaGPT, ChatDev, Anthropic's multi-agent research and the NeurIPS 2025 MAST failure taxonomy):

    "Distinct inputs, outputs, tools and acceptance criteria help. Persona backstories ('you are a senior architect with 20 years of experience') show mixed or no benefit... The real gap is execution verification. A builder's self-tests and a reviewer's prose approval don't prove anything works. The MAST study lists verification as its own failure category. Debate and consensus panels don't reliably beat simpler baselines at equal cost... Authority belongs in code, not prompts... Baseline to beat: one accountable agent plus deterministic checks."

Stage 3: Spec-Driven Development (SDD) and the Plan Mode boom (mid 2025 – early 2026)

Led by AWS Kiro, GitHub Spec Kit (specify CLI), Tessl and the open-source BMAD-METHOD, the SDD movement mandated running Constitution → Specify (requirements, usually in EARS syntax) → Plan (technical architecture with Mermaid C4 diagrams) → Tasks (atomic tasks) before coding (see the DEV 2026 SDD guide).

It soon hit the waterfall-style backlash of "AI-generated Markdown design docs being harder to review than the code". Thoughtworks Distinguished Engineer Birgitta Böckeler recorded four walls in her hands-on field report on Martin Fowler's site:

  1. Markdown review hell (Verschlimmbesserung):

    "With the amount of steps spec-kit took, and the amount of markdown files it created for me to review, this again felt like overkill for the size of the problem... To be honest, I'd rather review code than all these markdown files."

    "Especially with the more elaborate approaches that create lots of files, I can't help but think of the German compound word 'Verschlimmbesserung': Are we making something worse in the attempt of making it better?"

  2. A false sense of control — even with lengthy design documents, agents ignored them and reinvented wheels anyway:

    "Even with all of these files and templates and prompts and workflows and checklists, I frequently saw the agent ultimately not follow all the instructions... it just took them as a new specification and generated them all over again, creating duplicates."

  3. Conflating "planning" with "a plan" — former GitHub senior engineer Ayman Nadeem's retrospective, Plan mode is dead (Sep 2026):

    "The first thing we learned was that we had conflated planning with a plan... our specs were long... the problem was: they were AI-generated. There's something about the pacing and overly structured nature of AI-generated text that makes it very difficult to read. My eyes kept glazing over."

    "Real thinking doesn't happen this way... Our interface forced users to prematurely 'finish thinking' so that they could start building."

  4. Spec-as-Source repeats MDD's mistakes — Thoughtworks' Shangqi Liu column and Böckeler's assessment of Tessl both warn: MDD's formal DSLs were at least "parseable and deterministic", whereas "natural-language specs + probabilistic LLMs" loses twice; academia (Deepak Babu Piskala, arXiv:2602.00180) holds that Spec-Anchored (specs and code co-evolving through automated contract tests) is the sweet spot for production systems.

Stage 4: Harness Engineering and controlled autonomy (H2 2026–)

Best practice shifted from "writing long static Markdown plan documents" to building deterministic harnesses wrapped around the model. See Harness engineering for coding agent users (Apr 2026) on Martin Fowler's site and Anthropic's official Claude Code best practices (updated Nov 2026). Five hard-won rules converged:

① The reverse interview replaces the long-form plan

Instead of having AI generate thousand-word documents nobody reads, the agent plays interviewer, pressing the human through rounds of follow-up questions until boundary conditions are decided, condensing everything into a minimal SPEC.md, then starting a fresh session to implement. The official Claude Code pattern:

"Ask Claude to interview you instead: 'I want to add rate limiting to the public API but haven't thought it through yet. Interview me until you could write the spec, then write it to SPEC.md.' ... Once SPEC.md exists, start a fresh session to build from it, so the build begins with a clean context and a written definition of done."

② Severely separating "non-deterministic guidance" from "deterministic enforcement"

  • CLAUDE.md cut to under 200 lines, containing only "the tacit information Claude cannot see from reading the code"; module rules split into .claude/rules/api.md files with path filters;
  • Zero-tolerance rules sink into computational hooks. The official golden rule:

    "If you keep adding emphasis to a CLAUDE.md line and Claude still misses it, that's a sign the line belongs in a hook... A Stop hook runs your script whenever Claude tries to end its turn, and sends Claude back to work if the script exits with code 2. This one is enforced by Claude Code (the harness), so the turn doesn't end until the typecheck passes."

③ Ashby's Law: compress the agent's degrees of freedom with high-constraint topology templates

Böckeler brings in cybernetics' Ashby's Law of Requisite Variety:

"Ashby's Law of Requisite Variety is another interesting argument for these pre-defined topologies. The law says that a regulator must have at least as much variety as the system it governs, and it can only regulate what it has a model of. An LLM-based coding agent can produce almost anything, but committing to a topology narrows that space, making a comprehensive harness more achievable. Defining topologies is a variety-reduction move."

This explains why architecture scaffold templates with strongly-typed languages, predefined bounded contexts and read/write separation contracts keep gaining popularity — defining an architecture topology is itself a variety-reduction move.

④ Blind review by context-unpolluted independent subagents, with mandatory skip style

After the main agent finishes coding and passes the Stop hook gate, spin up a brand-new subagent that never saw the coding conversation, feed it only SPEC.md + git diff for blind review, and always specify skip style:

"In the terminal, /code-review reviews the diff in a fresh subagent that never saw your conversation. It isn't swayed by the reasoning that produced the code... Don't drop the skip style part of that prompt. A reviewer that's asked to find problems will always find something. If you fix every finding, you end up with extra abstraction layers and tests for cases that can't happen."

⑤ Always-on background "architecture garbage collection" (Janitor / GC loops)

OpenAI internal teams and Stripe (the Minions system) have disclosed (see the Martin Fowler case collection) that even with up-front specs and commit gates, high-frequency parallel agents still produce progressive architectural entropy. Top teams run periodic "architecture garbage collection" outside the CI trunk — deterministic static scanners (dead code, cross-layer dependencies, duplicated logic) plus dedicated cleanup agents, issuing small-granularity refactor PRs on a schedule like a timed GC, preventing the broken-windows effect from accumulating.

Sidebar: what about architecture visualization? — UML replaced by text-based diagrams

The agile AI community did not abandon architecture visualization; it moved wholesale to Diagrams-as-Code:


Four industry schools: results and remaining blind spots

Around "preventing AI coding hallucination and architectural decay", global teams in 2025–2026 pushed hard along four fronts.

School 1: syntax-level code knowledge graphs + MCP (the AST / call-graph school)

Representatives: Codebase-Memory (arXiv:2603.27277) (Charité Berlin and Humboldt University, with GitHub: DeusData/codebase-memory-mcp), Nomik (Neo4j + MCP), graph-codebase-mcp, code-graph-mcp, Graphify (60k+ stars), Understand-Anything (71k stars), Neo4j's official Claude + MCP recipe; in academia CodexGraph (NAACL 2025), RepoGraph (ICLR 2025); commercially Augment Code, Sourcegraph, Greptile.

Results: the Codebase-Memory paper demonstrates on a benchmark of real repositories across 31 languages that exposing structured graph queries via MCP instead of grep and file traversal cuts token consumption 10x (roughly 10,000 → 1,000 tokens/query), reduces tool calls 2.1x, with query latency under 1ms.

Blind spot: it understands syntax (AST) but is entirely blind to business domain semantics (DDD semantics) and asynchronous event causality. The JDomInO paper (arXiv:2608.05612) points out that AST/reflection-based static graphs can only see "class A calls class B" — they cannot tell which class is the aggregate root, which is an immutable value object, or where the bounded-context boundary lies; nor can they trace the Command → DomainEvent → Policy/Saga → ReadModel causal chains asynchronously dispatched over the event bus in CQRS / Event Sourcing.

School 2: DDD / event-storming modeling with roundtrip engineering (the model-driven & roundtrip school)

Representatives:

Results: proved that "model drift is a toolchain failure"; feeding structured domain metamodels to LLMs instead of raw source means lower noise, better token efficiency, and upgrading natural language's "probabilistic intent guidance" into "unambiguous deterministic structural contracts".

Blind spots:

  • Qlerify's validation is advisory — the official docs state "Validation is advisory. You can push a model that still has open issues", and /sync lets the coding agent read the code and then edit the model, with no compiler-grade two-way symbol-table locking;
  • Section 6 of the JDomInO paper admits the reverse path uses best-effort name matching, with no persistent provenance anchors (Provenance Identity Markers) embedded in source code — rename or move a class and it desynchronizes; the independent model-integrity validator is unfinished; only single-bounded-context Java synchronization was validated, with no coverage of distributed Saga orchestration or Actor event sourcing.

School 3: enterprise ontology constraints and neuro-symbolic architecture (the neuro-symbolic & ontology school)

Representatives: Ontology-Constrained Neural Reasoning in Enterprise Agentic Systems (arXiv:2604.00555, Jun 2026) (published by Foundation AgenticOS/FAOS with Novartis): a role/domain/interaction three-layer ontology, 7 bounded contexts partitioned by DDD, 650+ agents deployed across 22 vertical industries; Skan AI's Agentic Ontology of Work (AOW); OG-RAG at EMNLP 2025 (fact recall +55%); Graph-Constrained Reasoning (GCR, KG-Trie constrained decoding) at ICML 2025. See also InfoQ: knowledge graphs and production-grade agentic systems.

Two key theoretical weapons:

  1. The Inverse Parametric Knowledge Effect (Inverse PKE): through 1,800 controlled cross-model experiments (Claude Sonnet 4, Qwen 2.5 72B, Gemma 4 26B), FAOS found that the thinner the LLM's pretraining coverage of a private business rule, a role-specific decision flow, or a non-generic domain, the larger the accuracy gain from ontology grounding (up to 2x or more, p < .001); conversely, stuffing universally-known concepts into context produces "contextual interference" and degrades performance.
  2. Asymmetric Neurosymbolic Coupling: an L0–L5 six-level coupling maturity model — nearly all enterprise AI systems today sit at L1–L3 (input-side context injection, tool filtering), while L4–L5 (output-side ontological conformance checking and closed-loop evolution) is blank.

Blind spot: FAOS-class systems target business Q&A and workflow routing; L4–L5 output-side formal verification remains on paper because "free text resists translation into OWL description logic". Software engineering and code generation are uniquely positioned to industrialize the L4–L5 loop first — because code has compiler ASTs, type systems, invariant guards and bidirectional provenance anchoring.

School 4: post-hoc deterministic guardrails and architecture fitness functions (the post-hoc guardrails & runtime school)

Representatives:

Blind spot: CodeScene governs "code smells and cyclomatic complexity", ArchUnit governs "package dependency direction", Encore governs "cloud resource declarations" — none of them can govern deep business domain invariants, the legality of aggregate-root state transitions, or cross-microservice distributed Saga transaction contracts.


Timeline of key events

Time Event
2001–2006 OMG pushes MDA; one-way code generation hits model drift
2003–2019 DDD establishes the tactical primitives; DSL explorations such as Context Mapper DSL
2023 – early 2025 The "single-prompt generation" wild west; zero solution design
2024 – mid 2025 MetaGPT / ChatDev / AutoGen multi-agent roleplay boom and disillusionment
Feb 2025 Karpathy coins Vibe Coding; 25% of YC W25 companies at 95% AI code
Mar 2025 Willison warns that production-grade Vibe Coding is a terrible idea
Mid 2025 – early 2026 The SDD movement: AWS Kiro / GitHub Spec Kit / BMAD; then the Markdown-waterfall backlash
Oct 2025 Willison proposes Vibe Engineering
Feb 2026 Karpathy declares Vibe Coding passé; proposes Agentic Engineering
Mar 2026 Chris Richardson publishes GenAI guardrails in practice; the C4 for Agentic Systems paper
Apr 2026 Thoughtworks Technology Radar Vol. 34; Böckeler publishes Harness Engineering
May 2026 Karpathy elaborates Agentic Engineering at Sequoia AI Ascent 2026
Jun 2026 FAOS neuro-symbolic ontology paper (Inverse PKE, L0–L5 maturity)
Aug 2026 KIT's JDomInO tactical-DDD bidirectional sync paper; Three Dots Labs' "DDD matters more when AI writes the code"
Sep 2026 Ayman Nadeem's "Plan mode is dead"; Curo architectural drift report; QCon AI Boston evolution track
Oct 2026 Liferay's technical-debt black-box case retrospective
Nov 2026 Claude Code official best-practices update (reverse interview, hooks, blind-review subagents)

Reference link index

The paradigm pivot

Empirical data and community

Core papers

Representative projects by school

SDD and Harness Engineering