Originally written in French. Translated by AI — the meaning has been preserved, not the prose.
Angle
The code repository has always been the authoritative record of what the product does; and yet it was the specification that held authority, because it alone could be read in a meeting. An artifact therefore does not govern a product chain through its reliability, but through how easily the others can be drawn from it — and that ease is a matter of access, never of nature. Once reading a repository, cross-referencing its merge requests and regenerating support documentation from it stops requiring a developer, the specification loses what held it in place: it was never truer, it was more accessible. Authority then passes to the code, with its two conditions — a readable repository and someone who knows how to question it — and with its hole: it says what the product does, never why it does it that way.
Synthesis
Taken separately, these ideas look like a field report on badly kept product documents. Put end to end, they describe how authority is distributed among a product's artifacts, and what shifts it.
The starting point is a gap between two properties that get confused. The code holds the real state: a behaviour present in the repository exists, a behaviour written in a specification and absent from the repository exists for nobody. But holding the real state has never been enough to govern the chain, because those who produce the documents — Product Managers, support, sales — do not read the repository. The natural-language layer took the vacant place, not for its quality of information, but for its quality of access.
That layer, once installed, started to diverge, and the divergence is not slackness. Two mechanisms add to it: the arbitrations made during development do not systematically find their way back, and resynchronizing specification, mockup, changelog and support documentation costs, at every change, more than the time available. Outdated documentation is the cumulative result of arbitrations that are all reasonable taken one by one.
What changes is not the reliability of the code, which was already there. It is the price of access to it. As soon as a repository can be questioned without knowing how to write code, the specification, the changelog, the support documentation and even the design system can be regenerated from it rather than corrected against themselves — and a regenerated artifact does not go stale, it is either remade or it is not. The reversal reaches even the stage thought furthest from the code: a mockup composed of elements that really exist stops being a representation.
This shift has a price, and it is paid in competence. It presupposes a readable repository, which makes code quality a product variable and not a comfort for the team. It also presupposes someone able to cross-reference code, history, merge requests and business rules — something no vertical tool does, because each one sees only one face. And it opens a trap: producing quickly building blocks that are each sound on their own, and paying afterwards for their articulation.
What the whole thing brings into view: an artifact's rank follows the cost of access to what it contains, and the hierarchy taken as natural in a product chain was only the map of the available readers.
Tensions / contradictions
The main tension sets two notes of this batch against each other. One grounds the Product Manager's position in the fact that no vertical tool sees several faces of the product at once; the other announces a protocol that gives each tool precisely that access to neighbouring perimeters. If the second movement succeeds, the first one's advantage vanishes — and nothing here makes it possible to say on what timescale.
A second tension, with an idea written elsewhere: AI was presented as what finally makes a neutral layer of knowledge between the sources and the deliverables affordable. Here, it serves rather to do without an intermediate layer by regenerating from the source. Both can hold — the layer you keep carries the intention, the one you throw away carried the state — but the criterion separating the two cases is not established.
Finally, the angle assumes that accessibility explains rank. One may object that a specification held authority also because it was signed: it committed somebody, which a regenerated artifact does not.
Questions
- Where do you record the intention behind a product decision, which neither the repository nor a regenerated specification carries?
- What replaces the commitment carried by an approved document, when the artifact is regenerated on demand?
- The demonstration holds for a software product: what becomes of it in a product chain whose real object cannot be read like a repository?