Both paths produce working software. Only one produces a surviving account of why it works that way.
Code ships. The chat scroll nobody rereads. Six weeks later, the spec must be reverse-engineered from the artifact.
The spec keeps working after ship: loaded by the next agent session, amended in one line, answering why does it do that without the original author's memory.
The residue is code plus a chat scroll nobody rereads. The reasoning that produced every decision — the constraints you held in your head, the tradeoffs you rejected, the edge cases you deferred — gone when the context window closes.
Six weeks later: new feature request. New hire. An agent touching adjacent code. Someone needs to know why the system behaves a particular way. There is no document. There is archaeology.
Reverse-engineering intent from code is slower and less accurate than capturing it at the moment of the decision. The rebuild tax is not a project-management failure. It is a documentation failure, paid in estimate error and correction loops on work that was already done once.
Prompt-stream work leaves no context for its successor. Every new session loads the codebase; none of them load the reasoning. The agent guesses at intent. You correct it. That correction is the unwritten spec, exacted again.
It is paid in corrections. It is paid in onboarding. It is paid in the meeting where everyone asks the same question and nobody has the answer. There is no salvage value. It produced working software once. It will cost you again every time you touch the code it built.
The decision to write it down is not ceremony. It is the decision about whether the thinking you are doing right now will exist next week.
The next agent session that touches this feature can load the spec. It has the problem statement, the constraints, the tradeoffs you recorded. It starts informed, not guessing. That is not a small thing. That is the difference between a session that moves and a session that corrects.
When requirements shift, the written spec becomes the amendment site. You change a sentence. The agent receives the updated document. The decision record reflects the change.
Without the spec: the reasoning must be reconstructed, the intent must be inferred, and the correction will miss edge cases the original author knew and did not write down.
Each feature adds a document. Each document is available to every future feature that touches the same surface. The spec for the permissions model informs the spec for the sharing feature. The spec for the API contract informs the spec for the mobile client. Unwritten, none of that compounds.
The spec does not exist because someone filed a ticket. It exists because the agent captured it while doing the work. That is the distinction.
Maintaining a spec is a discipline. Producing a spec as a byproduct of the agent's job is architecture. DecisionGraph is where that architecture runs: the spec is written before the build, lodged in the graph, connected to the stories it generated, and connected to the code those stories produced.
Six weeks later, the new feature request arrives. The agent opens the spec. The reasoning is there. The constraints are there. The tradeoffs are there. The question why does it do that has an answer — without the original author, without archaeology, without the meeting.
The prompt stream produced software. The written spec produced software plus a document that compounds.
That is not the same investment.
The spec lives in the graph — captured as a byproduct of the build, connected to the code it produced, loadable by the next session that needs it. The unwritten spec costs you every time. The written spec compounds.
Block in the rough form. Spend your time on the work that's actually yours.
Read → /apprenticeYour mockup is half a spec. Here's the other half.
Read → /visualDecisionGraph knows when to use them.
Read → /skillsThe whole loop — spec, decompose, build, verify — start to finish.
Watch → /spec-to-code