Why Martin Fowler Says Determinism Is Over in Software Engineering

Fundamental Shift: The End of Determinism

Fowler notes that while earlier language abstractions (e.g., moving from assembly to Fortran) preserved determinism—identical bugs appear on every compilation—LLMs break this premise: the same prompt can produce different code on different days, making software behavior probabilistic.

"We are not just moving up the abstraction ladder; we are sliding sideways into nondeterminism."

He likens this to structural engineering, where tolerance accounts for material variability and random loads. Software historically lacked such tolerance, but LLM outputs now require it.

Three Engineering Consequences of Nondeterminism

Test suite erosion: Intermittent AI‑generated code causes flaky tests, turning genuine bugs into noise.

Amplified quality issues: Poor base code quality is magnified by AI, leading to a degrading codebase.

Debugging difficulty: Faults originating from probabilistic AI inference are hard to attribute.

Vibe Coding vs. Agentic Engineering

Fowler distinguishes two extremes:

Vibe Coding – generate code without reviewing it; useful for one‑off exploration or throwaway prototypes.

Agentic Engineering – AI generates code but is surrounded by systematic verification and feedback mechanisms.

When projects exceed a few hundred lines, Vibe Coding collapses: AI fixes a bug while introducing two new ones, creating an unreadable black box.

"Learning Loop (idea → code → feedback → correction) is cut off when you never read the code."

He cites a real case where an AI‑generated SVG required a tiny manual tweak, yet the underlying code became an incomprehensible mess.

Harness Engineering: The Prescriptive Methodology

Building on the diagnosis, Fowler proposes a prescription: treat an AI agent as Model + Harness, where the Harness includes system prompts, code‑retrieval, orchestration, constraints, and validation.

Guides (Feed‑forward) and Sensors (Feedback)

Guides – pre‑execution constraints such as system prompts, AGENTS.md, coding standards, which raise the chance of a correct first attempt.

Sensors – post‑execution checks like tests, linters, type checkers, and code reviews that enable AI self‑correction.

Both are essential; lacking either leads to either blind rule‑following or repeated mistakes.

Computational vs. Reasoning Controls

Computational – deterministic, fast CPU‑based checks (e.g., static analysis, structural tests).

Reasoning – semantic, GPU/NPU‑based analyses (e.g., AI code review, "LLM as Judge").

Fowler’s key advice: use computational controls whenever possible and reserve reasoning for cases that cannot be formalized.

What/How Loop: Programming’s Core Remains

Programming still maps domain "What" to implementation "How" in an iterative feedback loop. TDD exemplifies this by expressing "What" in tests and "How" in code.

LLMs act as a translation layer within this loop: they can generate code from existing abstractions but cannot replace the human effort of establishing stable abstractions.

Engineer Role Re‑shaping

Engineers are moving from writing code to reviewing diffs. Fowler suggests the path forward is to become the creator of the Harness, turning diff‑review into a visible, measurable contribution.

"A team that can generate and validate five solutions in an afternoon outpaces a team that generates one solution and waits a week for feedback."

He outlines six AI‑development methodologies, from short‑term Vibe Coding to the mature Harness Engineering, and critiques Spec‑Driven Development for its rigidity and six systemic problems.

Unanswered Questions

Fowler admits uncertainty about the future of programming, whether AI is a bubble, and if junior engineers will be displaced, emphasizing that the unknowns are more valuable than any deterministic claim.

In summary, determinism has not vanished but transformed: from guaranteeing correctness to managing uncertainty through engineered harnesses that let AI write code reliably.