TL;DR
The piece argues that when systems can be reliably regenerated from intent, the primary unit of change shifts from code text to the reasons behind it. Versioning must track structured intent—requirements, constraints, plans and decisions—rather than only diffs of generated artifacts.
What happened
The author lays out a vision where 'regenerable' systems—those that can recreate components from recorded intent with equivalent behavior—break the long-standing assumption that source text is the principal record of why software looks the way it does. In this model, artifacts like code are outputs of a generation pipeline driven by structured inputs: requirements, constraints, decision records and generator metadata. To make this practical, intent needs to be represented as a content-addressed graph of nodes (requirement, constraint, plan, generator, etc.), with edges expressing causality and a root hash serving as the component 'version.' The essay contrasts this approach with traditional diff-based version control and traces how build tools and formal specifications partially address parts of the problem. It also catalogs practical challenges—canonicalizing natural language specs, implicit assumptions by agents, and generator nondeterminism—while noting current generator tooling does not yet emit stable, versionable intent graphs.
Why it matters
- Versioning that tracks intent would let teams answer not just what changed in an artifact but why it changed.
- If provenance drives generation, traceability becomes infrastructure rather than manual overhead.
- Auditing, debugging and change impact analysis could operate at the level of requirements, plans and constraints.
- Existing diff-centric workflows risk becoming a lossy history when code is produced by agents rather than handwritten.
Key facts
- Regenerable: defined as the ability to delete a component and recreate it from stored intent with the same behavior and integration guarantees.
- The proposed unit of change is reasons (requirements, constraints, decisions), not lines of code.
- Intent should be represented as a content-addressed graph where nodes have types, canonical content, explicit dependencies and evaluation artifacts.
- A component's version is the root hash of its intent graph; changing a requirement alters only downstream nodes.
- Plans are decision records (chosen strategy, rejected alternatives, constraints) and are treated as part of the implementation rather than mere documentation.
- Build systems like Bazel and Nix use hashed inputs and content-addressed caches; formal methods provide precise specifications—both are related but do not alone provide generative provenance.
- Current AI generators typically do not emit stable, versionable plans or structured intent graphs (this is presented as a gap).
- Practical failure modes include natural-language canonicalization issues, agents making unstated assumptions, and nondeterministic generation producing different outputs from identical inputs.
What to watch next
- Development of tools and standards for emitting and storing structured intent graphs (not confirmed in the source).
- Generators or agent frameworks that surface decision records and make plans versionable (not confirmed in the source).
- Adoption of content-addressed provenance models in build and CI tooling to link intent to generated artifacts (not confirmed in the source).
Quick glossary
- Regenerable system: A system where a component can be deleted and recreated from recorded intent and produce equivalent behavior and integration.
- Intent graph: A content-addressed graph whose nodes represent requirements, constraints, plans, decisions and other causal inputs, with edges expressing dependencies.
- Content-addressed hash: A cryptographic or stable hash derived from an item's canonical content used to identify and version that item.
- Plan (decision record): A structured record of a generator's chosen strategy, rejected alternatives and constraints that explains why an implementation was produced.
- Provenance: The recorded history of inputs and decisions that led to an artifact, enabling traceability and reproducibility.
Reader FAQ
Does this describe how current AI code generators work?
No. The source states current generators do not typically emit stable, versionable plans or structured intent graphs.
Would code disappear under this model?
No. The argument is that code becomes an artifact of synthesis while intent becomes the primary record; code still matters operationally.
How does this differ from traditional version control like Git?
Git versions text files and diffs; the proposed model versions content-addressed intent (requirements, plans, decisions) so versions reflect causal inputs rather than only changes in generated artifacts.
What are the main technical challenges?
The source highlights canonicalizing natural-language specifications, surfacing implicit assumptions by agents, and handling nondeterministic generation as key difficulties.
The Phoenix Architecture Provenance Is the New Version Control Chad Fowler January 13, 2026 5 2 0 When code can be thrown away and recreated, the unit of change is…
Sources
- Provenance Is the New Version Control
- Track Prompt Provenance in Version Control
- Understanding Code Provenance in The Age of Generative …
- Spec Driven Development: When Architecture Becomes …
Related posts
- PawSense: Catproof Your Computer With Simple Tools and Tips Guide
- How Ozempic and other GLP‑1 drugs are reshaping Americans’ food spending
- Danish developer converts floppy drive into a simple TV remote for child