We've Stopped Arguing About Whether AI Changes Software

Greg Herlein · article · 2026-07-07 source ↗ Reader 🖥️

Agent Security Agentic Engineering AI Labor Disruption Code Was Never the Bottleneck Ephemeral Code Knowledge Base Leadership Under Pressure Moats & Defensibility Organizational Legibility Spec-Driven Development Taste & Judgment Technology Diffusion & Transformation Curves Verifiability (as the Quality Bar)

The debate over whether agentic AI transforms software engineering is settled; the transformation is a shift in the center of gravity of the work — from writing code to specifying, verifying, and curating knowledge.

mixed · mixed — A first-person retreat reflection: reportage of what the author heard (expository/narrative) advancing several theses about how software work is changing, and closing with prescriptive 'what to do Monday' guidance (practical). It honestly stages an unresolved counter-argument rather than only asserting.

Structure

Part	Role
Chatham House framing and epistemic disclaimer	Establishes the setting (a Thoughtworks/Fowler retreat on the future of software development) and frames the whole piece as one attendee's opinion under Chatham House Rule, not reported consensus
The whether-debate is over	Contrasts the earlier February event (aspirational, 'what might come') with this one (everyone shipping in production) to establish that the argument has moved from whether to how
The Center of Gravity Moved	States the core compression (work moves to spec + verification), reframes the quality bar as verifiability, and honestly stages the unresolved code-ephemeral vs. code-as-better-spec debate
Knowledge Is the Bottleneck, Not Code	Argues tacit knowledge (the undocumented 'why') is the scarce resource agents starve for, and proposes agents generate/feed back their own learnings ('docs are now MCP')
The Junior Pipeline Is In Trouble	Diagnoses that agents eating the entry-level rung removes how junior engineers acquired judgment/taste/troubleshooting, with no known replacement
The Stuff That Doesn't Change	Grounds the future-shock in two constants: deterministic systems still need capital-E Engineering, and agent knowledge-retrieval is a wide-open frontier ('what is PageRank for agents?')
The Session I Missed Scared Me the Most	Relays secondhand that senior, hard-to-spook people left the security session terrified, and reasons that the attack surface has moved to spec/prompts/skills/knowledge/tools/supply-chain
The Gap Is Widening, Maybe Forever	Argues adoption compounds into a flywheel; the fear is laggards fall so far behind the gap becomes a structural moat, evidenced by an org of thousands already doing spec-driven development at scale
So What Do I Do Monday	Synthesizes the practical takeaway: stop obsessing over code; obsess over spec, verification, and knowledge; and grow the next generation of engineers

Key terms

center of gravity Leadership Under Pressure
The locus of where the essential, valuable software work happens; the claim is that it is moving away from writing code toward specifying, verifying, and curating knowledge
spec
The specification the agent executes against; in the author's framing the spec, not the code, is now 'the point' and is where a developer's taste lives
verifiable enough Verifiability (as the Quality Bar)
The new quality bar: whether you can confirm the artifact does what it is supposed to, at which point the form of the artifact (code or not) stops mattering
ephemeral (code)
Code treated as a disposable byproduct the agent regenerates from the spec on demand, rather than a durable hand-maintained artifact
the code is the better spec
The counter-position (which the author concedes is hard to wave off) that code, being unambiguous, executable, and deterministic, is the truest specification, and prose specs are the fuzzy thing that should be regenerated
Engineering (capital E)
The deterministic discipline of building things that do not surprise you — same input, same output, every time — which is still required precisely because agents are non-deterministic
the why
The tacit rationale behind a decision — why it was done this way, what was tried and failed — which the author calls the single most valuable knowledge to capture because the code already records the what
PageRank for agents
The author's shorthand for an as-yet-undiscovered mechanism for weighting and ranking knowledge sources for agent retrieval, analogous to how PageRank ranked web pages
structural moat / flywheel
A compounding adoption advantage — organizations ahead use agents to accumulate knowledge, skills, and velocity, pulling ahead faster — that can harden into a permanent gap laggards never close

Propositions

explicitThe debate over whether agentic AI changes software engineering is over; the industry has moved to arguing about how.conf: high
explicitThe center of gravity of software work is moving from writing code to specifying, verifying, and curating knowledge.conf: high
explicitThe new quality bar for a software artifact is verifiability — 'is it verifiable enough' — not elegance or even whether the artifact is code.conf: high
explicitdevelopedWhether code is now an ephemeral byproduct the agent regenerates from the spec, or remains the artifact that matters, is genuinely unresolved — the strongest counter to spec-as-center being that code, unlike a fuzzy prose spec re-interpreted each run, is unambiguous, executable, and deterministic, making the code the better spec.conf: high
refines ←Presentation: From Retrieval to Reasoning: Building Production-Ready Agentic AI Systems with Knowledge Graphs · p8 — That extraction leaves open whether code remains 'the artifact that matters' or becomes an ephemeral byproduct regenerated from spec; Shum's practical stance answers this from one side, with a mechanism (graph-based intent/reality reconciliation) for keeping both without discarding either.
explicitKnowledge — especially the tacit, unwritten 'why' behind past decisions — is the real scarce bottleneck, not code.conf: high
explicitThe single most valuable thing to capture is why a decision was made, not what the code does, because the code already records the what.conf: high
explicitAgents should generate their own learnings — summarizing and aggregating each session and feeding it into the next — turning documentation into a live, agent-queryable layer.conf: medium
explicitdevelopedAs agents take the implementer role, the entry-level rung that trained junior engineers is disappearing, threatening the future supply of senior engineers.conf: high
extends ←The New Rules for Becoming an Enterprise Leader · p3 — Extends the engineering-specific 'disappearing entry-level rung' problem to the general enterprise-leadership pipeline — same mechanism, a different professional ladder.
explicitcorroboratedThe scarce, valuable, hard-to-teach human skills are now judgment, taste, and troubleshooting, and there is no known way to teach them without first letting people do the grunt work agents now absorb.conf: high
supports ←Adam Mosseri: AI is a tailwind for authenticity · p16 — Both locate the scarce, valuable human skills in judgment and taste as AI absorbs execution.
explicitEverything that must be deterministic still requires disciplined capital-E Engineering, precisely because the agents producing it are non-deterministic.conf: high
explicitKnowledge retrieval for agents is a wide-open frontier, and knowledge graphs are roughly as accurate as vector search while being faster and cheaper in tokens.conf: medium
explicitcorroboratedAI shifts the security attack surface from human-written code to the spec, prompts, agent skills, knowledge layer, agent tool access, and supply chain — surfaces that legacy, human-review-based security models were not built to defend, requiring continuous self-directed red-teaming baked into the loop.conf: high
supports ←The Claude Code active attack didn't stop. 294,842 secrets stolen from 6,943 machines. It evolved and now spreads through Python too and uses Claude Code itself to steal your secrets. The risk to your credentials just got bigger. · p11 — A concrete campaign that moved its attack surface to AI review and agent configuration.
explicitcontestedAI adoption compounds into a flywheel, and the danger is that the slowest laggards fall so far behind that the gap becomes structural — a permanent moat rather than a lag closable with effort.conf: high
contradicts ←Travel Through the Lens of AI with Booking.com CEO Glenn Fogel · p1 — Fogel denies that any advantage is permanent ('there is no such thing as a moat'); p13 warns the AI-adoption flywheel can harden the laggard gap into 'a permanent moat rather than a lag'—exactly the permanence Fogel rejects.
extends ←Ordinary Engineers, Not Heroic Inventors · p12 — Diffusion theory explains why a compounding adoption gap becomes a permanent structural moat rather than a closable lag.
implicitAn organization's durable competitive advantage now rests more on knowledge capture and adoption velocity than on engineering headcount.conf: medium

Arguments

The highest-leverage human work is now the spec, verification, and knowledge capture rather than writing code. strength: medium

Explicit premises:

The work is moving from writing code to specifying, verifying, and curating knowledge; the agent executes against the spec.
The new quality bar is verifiability, so the form of the artifact stops mattering once it can be verified.
Knowledge — the tacit 'why' — is the real scarce bottleneck, and agents starve for exactly that context.

Implicit premises:

A good spec plus a capable agent reliably produces the working artifact.
Verification of agent output can in principle be made tractable even though it is currently unsolved.
Tacit organizational knowledge can be captured and fed to agents at scale.

Inferences:

Therefore developers should shift their effort up the stack to the spec, to how they verify correctness, and to writing down the why.

Deterministic systems still require disciplined capital-E Engineering even in an agentic world. strength: high

Explicit premises:

Agents are wonderfully, terrifyingly non-deterministic.
Some systems (a payment system, a submarine reactor) must produce the same output every time with no variance.
We still need the ability to change (agile) and the resilience to change (the devops 'ilities').

Implicit premises:

A probabilistic generator cannot by itself guarantee deterministic behavior of the systems it produces.
The cost of surprise in safety- or money-critical systems is unacceptable.

Inferences:

Therefore human engineering discipline must wrap, constrain, and verify the probabilistic agents, and matters more, not less, as agents write the code.

The adoption gap between leaders and laggards may become a permanent structural moat rather than a closable lag. strength: medium

Explicit premises:

Organizations that are ahead use agents to accumulate knowledge, skills, and velocity, which lets them pull ahead faster — a flywheel.
An organization of thousands of engineers is already doing spec-driven development at scale in production.
Firms that operationalize agentic development early get a valuation premium that decays and eventually flips to a penalty for not having it.

Implicit premises:

The flywheel's compounding rate exceeds any laggard's achievable catch-up rate.
The accumulated advantages (tacit knowledge, velocity) cannot simply be bought or copied late.

Inferences:

Therefore the lead becomes structural and, for the slowest, potentially insurmountable.

Narratives

The author attended the sold-out Future of Software Development Retreat Europe (hosted by Thoughtworks and Martin Fowler at the Kempinski Palace in Engelberg, Switzerland), run under Chatham House Rule, and writes only his own interpretation of what he heard.
→ Establishes the setting and the epistemic frame — this is one participant's honest take, not reported consensus — which licenses the strong theses while signaling humility.
Reading the reports of the February gathering of many of the same people, the conversation was aspirational — what agentic development might look like. This time, everybody in the room was doing it, shipping to production rather than showing slides.
→ Concrete before/after contrast that grounds the claim that the whether-debate is over.
Six engineers rebuilt the Amazon Bedrock engine in 76 days — work originally scoped at roughly 40 engineers for a full year — using AWS's agentic AI-DLC method and Kiro; the author calls it 'not a productivity bump' but 'a different physics.'
→ Public-knowledge proof point offered as evidence that agentic development is a change in kind, not degree.
The author skipped the security session (it ran opposite his own), but some of the most senior, hardest-to-spook people walked out saying they were terrified; he reasons secondhand that the attack surface has moved to spec, prompts, skills, knowledge layer, and supply chain.
→ Dramatizes the security threat through the reaction of unflappable experts, and models reasoning from that reaction rather than from specifics he did not hear.
One attendee described an organization of thousands of engineers already doing spec-driven development at scale — not a pilot, not a lighthouse team — while much of the industry still debates whether any of it is real.
→ Turns the compounding-gap theory into a present, concrete fact and raises the stakes from lag to structural moat.

Questions addressed

✅ Is the question of whether agentic AI changes software engineering still open?
No — it is settled; the room had stopped arguing about whether and moved entirely to how.
⭕ Is code now an ephemeral byproduct regenerated from the spec, or still the artifact that matters?
Genuinely unresolved; brilliant people are split. The author leans spec-as-center but concedes the deterministic 'code is the better spec' argument is hard to wave off and does not expect resolution soon.
⭕ How do you know the software is doing what it is supposed to do?
Named as the frontier — 'testing, but bigger than testing' — but presented as the hard problem nobody has fully solved.
⭕ Where do the senior engineers of 2035 come from if agents eat the entry-level rung?
Open. The room floated apprentice models, pairing, and rotation, but nobody — including the author — had a clean answer.
⭕ What is the retrieval/ranking mechanism that lets agents find the right knowledge ('PageRank for agents')?
Unsolved and framed as a wide-open frontier; graphs as index-and-memory are promising (roughly as accurate as vector search, faster and cheaper).
✅ What should an engineer or leader actually do now?
Stop obsessing over code; obsess over the spec (where taste now lives), verification (how you know it is right), and knowledge (write down the why and make agents help); and if you manage people, figure out how to grow the next generation.

Gaps

incompleteVerification is elevated to the central frontier and the new quality bar ('is it verifiable enough'), yet no concrete method is given for verifying non-deterministic agent output; 'testing, but bigger than testing' names the gap without specifying how to close it.
Read next: Read on evals, property-based and specification-based testing, and formal/executable specifications for agentic output.
closed bySoftware Factories, Light and Dark — Supplies the concrete method the earlier piece named but didn't specify for 'is it verifiable enough': green/red oracles, type gates, property tests, and rubric-backed review agents, plus loop length (3-10 steps) as an operational proxy for verifiability.
illogicalThe author leans 'spec-as-center' while conceding the 'code is the better spec, because deterministic' argument is hard to wave off, but never reconciles how a fuzzy prose spec that an agent re-interprets each run can be the durable source of truth when verifiability is the stated quality bar. The essay's own thesis is in tension with the counter-argument it admits.
Read next: Read on executable/formal specifications, spec-to-code determinism, and whether specs can be made unambiguous enough to be the source of truth.
incompleteThe junior-pipeline collapse is diagnosed sharply but left without a solution; apprentice, pairing, and rotation models are 'floated' and explicitly declared to have no clean answer, so the mechanism for growing judgment/taste/troubleshooting in an agent-first world is unresolved.
Read next: Read on deliberate practice, apprenticeship models, and skill acquisition in AI-augmented teams.
closed byPodcast: How Will We Train Developers If AI Does the Routine Work: A Conversation with Scott Hanselman — That gap notes apprentice/pairing/rotation models were 'floated' with no clean answer for growing judgment in an agent-first world. This document supplies a specific, named model -- preceptorship plus explicit pairing/fellowship -- with a concrete evaluation criterion (preceptors are metriced on producing new seniors, not on code shipped).
uninformedSecurity is flagged as terrifying but the author explicitly relays no specifics (he missed the session); the threat models and defenses are reasoned from the attack-surface list and the reaction of senior attendees rather than from firsthand content, leaving the actual mechanisms and mitigations thin.
Read next: Read on prompt injection, the lethal trifecta, memory poisoning, and agent/supply-chain security architectures.
closed byThe Claude Code active attack didn't stop. 294,842 secrets stolen from 6,943 machines. It evolved and now spreads through Python too and uses Claude Code itself to steal your secrets. The risk to your credentials just got bigger. — Partially: supplies a concrete, real-world threat model for the AI-shifted attack surface (AI-reviewer manipulation, agent-config persistence, credential harvesting from developer machines) and the corresponding containment/recovery practices.
incompleteThe 'compounding gap becomes a permanent structural moat' claim rests on flywheel logic plus a single secondhand anecdote (an org of thousands); it does not examine catch-up dynamics, whether late adopters can buy tools/talent, or evidence that early-mover AI advantages actually persist rather than erode.
Read next: Read on technology-diffusion S-curves, durability of first-mover advantage, and enterprise AI adoption catch-up patterns.
closed byOrdinary Engineers, Not Heroic Inventors — Diffusion theory (vs. leading-sector theory), evidenced by the Japan/US case, gives the mechanism for why a compounding adoption gap becomes a structural moat rather than a closable lag — it's decades of skill-infrastructure accumulation that laggards cannot fast-forward, not flywheel logic alone.

We've Stopped Arguing About Whether AI Changes Software

Structure

Key terms

Propositions

Arguments

Narratives

Questions addressed

Gaps

Related documents