Docs & Code Guide

What makes documentation trustworthy: the three signals readers check before believing a page

Readers decide whether to trust a page on three signals, usually within the first minute: a visible date telling them when it was last verified, a named owner telling them a human answers for it, and the result of the first claim they can test against reality, a command run, a service name checked, a port tried. Pass all three and the page gets believed; fail the third and not only is the page discarded, the reader quietly downgrades the whole wiki. Trustworthiness is a design property you can build in, not a reputation that accrues on its own.

6 min readFor teams whose engineers ask in Slack instead of reading the wiki

See it as a diagram

Everything below, as a diagram you can edit. Describe yours and see it in seconds.

132/20003 credits left
Try:

No account needed · Editable canvas, not a picture

Signal 1: a date the reader can see

Readers use the date as a proxy for accuracy before reading a word, and platforms feed the habit by showing last-edited automatically. The problem is that last-edited lies in both directions: a typo fix makes a wrong page look current, and a correct page about a stable system looks abandoned. The stronger signal is last-verified, a stamp a human sets only after checking the page against reality, distinct from the edit timestamp the platform maintains.

The stamp works because it is falsifiable: it names a date and a person, and a reader who finds a lie under a fresh stamp knows exactly what broke down. Pages missing their expected stamp are equally informative, which is what makes the stamp queryable infrastructure for documentation freshness metrics, not just reassurance.

---
title: Payments service runbook
owner: "@team-payments"
last-verified: 2026-08-10
verified-against: release 2026.32
---

Signal 2: a named owner

An owner in the header changes the reader's risk calculation: a page signed by the payments tech lead can be wrong, but someone specific answers for it, and there is an obvious person to ping before acting on a doubtful claim. An anonymous page offers neither, so prudent readers treat it as rumor. Team names work; individual names attached to a role work better, provided ownership metadata survives departures, the mechanics covered in who owns architecture documentation.

Ownership also feeds the first signal: an unowned page has nobody to stamp it, so the two signals decay together, which readers notice as a pattern long before any dashboard does.

Signal 3: surviving the first spot check

Engineers spot-check by instinct: before investing in a page, they test its cheapest verifiable claim. If the command runs, the service name resolves, the port answers, the page earns provisional trust; if not, reading stops. This is rational Bayesian behavior, and it means a page's credibility rides disproportionately on its most checkable claims, wherever they sit.

Design for the check instead of hoping to dodge it: put a claim the reader can verify in seconds near the top, keep exact names and commands over paraphrase, and cut claims nobody can test. A page that invites verification and survives it converts skeptics; a page of untestable generalities cannot even be trusted in principle.

One wrong page poisons the whole wiki

Trust in documentation is evaluated per source, not per page: a reader burned twice stops checking the wiki at all and routes every question to a human, which is why teams with hundreds of fine pages still see the wiki bypassed on the strength of a few prominent lies. The asymmetry is brutal, one bad experience outweighing many good ones, and the senior engineers absorbing the redirected questions pay the bill, one input to the cost of outdated documentation.

The repair sequence follows from the asymmetry: cull before you fix. Archiving every page nobody will re-verify removes the encounters that reset trust to zero, and a smaller surface of stamped, owned pages can then rebuild it. The full recovery playbook is in stale documentation, and the terminal form of the disease has its own page in wiki rot.

What this means for diagrams

Diagrams take the spot check harder than prose: a reader who spots one missing service dismisses the whole picture, because a diagram asserts completeness the way a paragraph does not. A pasted screenshot also carries no trust signals at all, no stamp, no owner, no way to tell which year it describes.

A live embed changes what the artifact is evidence of: an image served from the source diagram, re-rendered when the diagram changes, means what the reader sees follows the current source within minutes rather than being frozen at paste time. It shifts the question from is this copy current to is the source maintained, one question instead of one per copy. The honest limits: the project must be shared public for the embed URL to exist, and a human or an MCP-connected agent still has to update the source when the architecture changes, since nothing watches the repository by itself.

The checklist for one page

A last-verified stamp with a name, an owner the reader can ping, and one claim testable in seconds near the top. A page with all three earns the benefit of the doubt; a wiki of such pages earns back its readers.

FAQ

What makes documentation trustworthy?

Three signals readers check before believing a page: a visible last-verified date showing a human recently confirmed the content against reality, a named owner who answers for the page, and the page surviving the reader's first spot check, the cheapest claim they can test, like running a command or checking a service name. Pages designed to pass all three earn trust; failing the spot check loses not just the page but the wiki's credibility.

What is the difference between last-updated and last-verified?

Last-updated is a platform timestamp that changes on any edit, including typo fixes, so it can make a wrong page look current and a correct stable page look abandoned. Last-verified is a deliberate stamp a human sets only after checking the page against reality, with a name attached. It is falsifiable, which is what makes it a trust signal rather than a byproduct of editing.

Why do developers stop trusting internal documentation?

Because trust is evaluated per source, not per page. After being burned by one or two confidently wrong pages, a reader rationally stops consulting the wiki entirely and asks humans instead, even though most pages may be fine. The effect concentrates on prominent pages like onboarding guides and runbooks, and it reverses only by removing the lying pages, not by adding good ones.

How do you rebuild trust in a wiki nobody believes?

Cull first, then stamp. Archive every page nobody will re-verify, so readers stop encountering the lies that reset trust. Then give the surviving surface the trust signals: a named owner and a last-verified stamp per page, renewed by short verification passes on a stated cadence. A small surface of stamped pages rebuilds trust faster than a large surface of mixed quality ever can.

How do you make an architecture diagram trustworthy?

Stop distributing it as screenshots, which carry no date, no owner, and no connection to the source. Serve it as a live embed from the source diagram so every page showing it follows the current version within minutes, keep an owner on the source, and update it through a repeatable loop, manually or via an MCP-connected agent reading the repository. A diagram that visibly tracks its source survives the reader's completeness check; a pasted image invites it and fails.