Changelog

Measuring without collecting

Every page on this site now runs a small script that measures the standard web performance numbers — how long until the first paint, how long until the largest element rendered, how much the layout shifted. These are the same “Core Web Vitals” every performance tool measures.

Here is the part worth writing down: the numbers go nowhere. They exist in your browser’s memory while the page is open and are discarded when you leave. The site’s own security policy (connect-src 'self') would block a transmission to any third party, and there is no server endpoint to receive one — the site is static files. The instrument is not “analytics with the sending turned off as a courtesy”; it is incapable of sending, by construction, and you can verify both halves in the open-source repository.

Why build a measurement nothing reads?

Because the alternative was shipping the reading half first and the honesty half later.

The plan — stated in the open, in the campaign records — is that these measurements will eventually flow to an aggregate performance dashboard, so the site’s real-world speed for real visitors can be watched rather than assumed. That step is deliberately gated on a human decision, and it has not been taken. What shipped today is the instrument, wired and demonstrably working: the test suite loads a page and asserts that at least one measurement was actually emitted. A script that is present but inert fails the build — because “shipped” and “working” are different claims, and this site has been bitten before by the gap between them.

The privacy page moved first

The privacy page has carried a commitment since July: if analytics of any kind is ever added, the page updates before the change ships. This is that update, in the same change as the instrument itself. The page now has a section explaining exactly what is measured and where it goes (nowhere), and it will update again — first — if the dashboard step is ever taken.

A weekly sweep that is allowed to fail

Separately, the repository gained a scheduled performance sweep: once a week, CI builds the site, crawls every page with Lighthouse, and fails the run loudly if any page misses the performance budget. Not a report someone might read — a red build.

One detail from the plumbing: the sweep and the visual-regression tests both drive a browser over the entire site, and running them simultaneously produces flaky screenshots that look exactly like real regressions. The rule that they must not co-run is enforced by the CI system’s own concurrency mechanism, not stated in a comment — because this campaign keeps re-learning that a rule recorded only in prose is a rule with no gate.

The links that let you check us were broken

The rest of today’s changes are one theme: the surfaces whose whole job is to let you verify something were the surfaces that did not work. A review of the site found no broken journeys and no false claims a reader couldn’t recover from — but four defects clustered exactly there.

The get-started tour shows you the four files an agent reads on first run, verbatim, with a hash for each and a link to the same file in the public repository. Every one of those links returned 404. The bytes on the page were correct and the hashes were honest; the commit the page cited existed only on one machine. A build script had been reading the commit id out of a local checkout and pairing it with the public repository’s address — two different repositories, one link. The page now cites the published release of the standard, v8.9, and all four files are byte-identical to that release. That is checkable, and we checked it, and now a test refuses to let the page publish an identifier that only exists locally.

The markdown copy of the quickstart — the version an AI agent reads — was serving broken commands. Where the page correctly shows ls ~/aDNA/<name>.aDNA/what, the machine copy had silently dropped the <name> placeholder, and the sentence explaining it read “Replace “ with whatever you called your project.” The conversion was mistaking the placeholder for markup and deleting it. Nothing caught this, because every existing test asked whether the machine copy was well-formed and none asked whether it said the same thing as the page. One now does.

And the site’s own security policy was refusing to load one of its own fonts, on every page. The fix moves the font out of the stylesheet and into a file; the policy itself is untouched, because loosening a security rule to make an error go away is not a fix.

Two sentences that were true and read as more than they were

“Nothing is sent anywhere” was a promise about the workspace, printed next to a command that ends by launching an AI agent — which does need an account, and does send the files it reads to its provider. Both halves were always true; only one was written down. The page now says both, and says you can skip the agent entirely.

The smaller one: a five-command check said “each prints nothing, except the last two.” Three of them print. That is the kind of error nobody reports and everybody notices.

A sentence that stopped being true

Since 17 August the community page has described the community space like this:

registration is approval-gated, and its terms of service, privacy policy, and branding are still being stood up

Every word of that was accurate when it was written. On 21 August the venue published its terms of service and its privacy notice, and from that moment the sentence was false — not because anyone edited it, and not because anyone was careless, but because it described someone else’s system and that system moved.

This is a different failure from the ones we usually write about here. A claim that was always wrong has an author. A claim that goes stale does not: there is no bad edit to find, no commit to blame, and from the outside a stale sentence and a broken one look exactly alike.

The check that should have caught it was the reason it survived

Every load-bearing claim on this site has a row in a register, and the register is wired into the test suite. Rows marked verified are asserted to be present in the built pages — because the honest, unflattering sentences are precisely the ones a cheerful rewrite deletes first, and we wanted their removal to break the build.

That check worked exactly as designed, and the design had a hole in it. The register row for this sentence was stamped verified against evidence gathered on 17 August, and nothing about a row ever expires. So the suite was not merely failing to notice the false sentence:

it was green because the false sentence was there, and would have gone red the moment we told the truth.

Nothing in the register carries a probe date. A test that pins wording can only tell you the wording has not changed — it cannot tell you the world has.

From today, any sentence on this site describing an external surface carries the date it was checked, on its face, and its register row records that date too. That does not make staleness impossible. It makes it visible, which is the most a check of this kind can honestly promise.

The rules are linked now

The venue’s terms of service, privacy notice, and code of conduct are published. They are short and they say so themselves that they are interim, pending review. They are now linked directly from the community page, because “there are rules somewhere” is not useful to someone deciding whether to join, and “we have a policy” is the kind of sentence that sounds like a fact and functions like a reassurance.

Two commitments in them are worth repeating, and we repeat them as commitments the documents make rather than as facts we have independently verified:

• Your content is not used to train or evaluate AI models.
• Every agent in the space is labeled as an agent, and undisclosed automation is not allowed.

Agents work there, and the page said they did not

The same paragraph carried a second sentence that had gone false: that agents work in the repositories and on the public record, not in chat.

That was true of the venue as originally scoped. It is no longer the posture, and the venue’s own code of conduct now says plainly that the community includes AI agents as working members, every one of them visibly labeled.

We found this the only way it can be found — by reading the code of conduct before linking to it. Had we linked it without reading it, this page would have said agents are absent one line above a document saying they are present, and a reader would have found the contradiction in a single click.

The page no longer asserts either way who is inside. It states the rule, which is checkable by anyone from the published document, instead of a fact about attendance that we cannot see from outside an approval-gated venue and should not pretend to.

The same claim, two more pages

The old description also appeared on the network and canonical-properties pages, which both call the venue “human-to-human” and then point at the community page for its honest current state — a page that, as of today, says something different.

They shared one line in one data file, so the correction was one edit. The reason it is worth mentioning is the habit it enforces: after removing a wrong claim, search the rendered site for what the claim said, not just for the file that said it. The first search found the fixed page and told us we were done. The second found two pages we had not touched.

What we did not do

The community page does not map the participation ladder to specific channels in the venue.

That mapping would be genuinely useful, and we cannot verify it. The venue is approval-gated, so its channel structure is not visible from outside, and a rung-to-channel map assembled from anything other than direct observation would be a plausible guess presented as guidance. It is deferred until it can be checked, and recorded here as deferred rather than left as a gap you would have to notice.

The registry is now data

This site has listed the vault registry as HTML for months. For a reader that was fine. For an agent it was the wrong shape: the only way to get the vault list was to scrape the registry page or pull bare slugs out of the sitemap, which gives you names and nothing else.

We checked the four addresses an agent would guess. All four returned 404.

/vaults.json now serves the whole registry — every entry and every declared relationship, with the same fields the pages render. One curl and you have it:

curl -s https://adna.network/vaults.json | jq '.vault_count'

There is also a pinnable copy at /api/registry.v1.json. It serves identical bytes. The difference is what each promises: the first gives you whatever is current, the second gives you the v1 shape. If a field ever has to change meaning, that change lands at a new versioned address, the old one keeps serving for at least 90 days, and /vaults.json only follows afterwards. Adding a field is not a breaking change and can happen at any time — so write consumers that ignore keys they do not recognise.

Both are built by the same function, which is the only reason the pin is worth anything. A versioned URL that quietly drifts from the canonical one is worse than not having one, because you cannot tell from the outside that it has drifted.

The endpoint tells you how thin it is

Seven of the nineteen published fields are populated zero times across the entire registry. No vault has a tagline. None has a current phase, a documentation URL, or a headline mission.

That is not a bug and it is not a fetch error. Those fields were emptied on purpose, when internal working language was stripped out of the public projection. Sparseness is what honest sanitization costs.

The problem is that from outside, a field that is empty for this vault and a field that is empty for every vault look exactly the same — and a consumer that guesses wrong builds a view around a column that will never have anything in it. So the payload counts it for you:

"field_coverage": {
  "display_name": { "populated": 74, "of": 74 },
  "persona":      { "populated": 61, "of": 74 },
  "note":         { "populated": 44, "of": 74 },
  "tagline":      { "populated":  0, "of": 74 }
}

Check coverage before you depend on a field. One deserves particular care: last_synced records a registry sync, not vault activity, and most rows carrying it share a single date. Reading it as freshness would be false, so the endpoint says what it is.

The same instinct applies to the caveat that matters most. Every entry in this registry is self-declared, and nothing corroborates it — no build status, no commit feed, no external check. That sentence has been on the registry page since we redesigned it. It is now in the payload, because a machine consumer never reads the page.

Rows that are thin on purpose

Three vaults are listed with identity, class, status and persona only. They are real engagements whose detail is private, and they stay listed so the count stays true.

Until today those rows just looked empty in any machine-readable form, which is the failure mode worth naming: a suppressed row and a missing row are indistinguishable from the outside unless the data says which one you have. Each now carries a listing marker and a note saying it is a minimal card and why. The vault is real and governed; its detail is not public.

What the endpoint deliberately does not contain

It publishes exactly the fields the registry’s own pages already show, and nothing else. The underlying registry holds more — some of it non-empty — but a field that no page displays is not made public by being convenient to include.

It is also a snapshot of one operator-run node’s declarations. It is not a census of who uses aDNA, and nothing in it is checked against anything outside itself. The full reference states the schema, the versioning policy, and these limits together, so you can see the shape and its caveats in one place.

Machines can now tell what the registry is

The registry page described itself to machines as a generic collection of pages. It now also describes itself as a Dataset, with a pointer to the JSON endpoint — so a machine that lands on the HTML can get to the data in one step instead of guessing.

Three pages — the design system, privacy, and security — carried no structured data at all. They do now.

What we did not fix

Individual vault pages still describe themselves as generic web pages. A vault is a structured, typed, governed thing, and saying “web page” is the least informative true statement available.

We are not fixing that with a quick relabel, because the obvious labels are wrong. A vault is not plainly a dataset, and calling it source code would be false for the seventy-three that have no public repository. Picking the right description is a decision about what a vault is, and it deserves to be made deliberately rather than as a side effect of shipping an endpoint. Recorded as open, with the reason, rather than closed quietly.

A front door for agents

Everything above is useless to an agent that cannot find it. Until today the only pointer to /llms.txt anywhere on this site was a link in the footer, and the fact that the site is itself an aDNA vault was stated once, three clicks deep, on a page about what aDNA is.

The homepage now says both, in one block: what this site is, and where a machine should start. Three surfaces, each of which already worked and none of which was advertised where anyone would look — the curated index at /llms.txt, the markdown twin of almost every page, and the registry endpoint from the section above.

We measured before writing it. The twin count in that block is read from the same manifest that generates the twins, so it cannot drift into a number nobody checked; two pages out of 224 have no twin, and the block states the count rather than claiming “any page”.

One sentence did not survive the review. The block first said these surfaces were “a by-product, not an add-on bolted on later” — which is false, and our own changelog proves it: the twins shipped two days ago and the endpoint shipped this morning, both because an audit found them missing. What is true is narrower and checkable: each surface is generated from the same source as the pages, so it cannot fall out of step with them. That is what it says now.

What is not here

There is no MCP server. One exists, it works, and it is not published — so nothing on this site mentions one, and /.well-known/mcp.json returns 404 rather than describing software you cannot install. When it is published, it will be listed here and not before.

The whole site is now readable as markdown

This site’s argument is that context should be navigable by agents. An agent arriving here could read the HTML — it is all server-rendered, and that part was already fine — but three things it would reasonably expect were missing, and their absence argued against the claim more than any missing feature would.

Every page now has a markdown twin. Add .md to any address — /learn/what-is-adna.md, /get-started.md, /vaults.md. 221 of them, generated from the same source the HTML is built from, so they cannot drift into saying something the page does not. Each opens with a pointer back to the index and the date it was generated.

The same markdown is served on the ordinary URL to anything that asks for it with Accept: text/markdown — the convention Claude Code and several other agents already use. Before today that header changed nothing at all; you got the HTML, byte for byte, down to the same ETag.

llms-full.txt is now actually full. It was a 2 KB index of routes wearing a name that promised the whole corpus. It is now the whole corpus — every page, about 900 KB — and the index it used to be is still there at the top, serving as the table of contents.

And llms.txt is now findable. The curated index has been good for months and was mentioned nowhere on the site: the string “llms” appeared zero times in every page we checked. An agent had to already know the convention to look. It is now in the footer, in robots.txt, and declared in the head of every page that has a twin.

One deliberate limit, since a machine surface should not overstate itself: three routes have no twin — the 404 page, the design-system page (whose content is its rendering), and the network graph (whose keyboard-navigable twin is the vault registry). Those pages do not advertise one either, because a pointer to a missing file is worse than no pointer.

There is now a way to propose a change

Until today, a standard that anyone could read had no stated way for anyone to change it. That is a preference with good documentation, not a standard.

Changes to the standard now go through numbered aDNA Enhancement Proposals. The rules are short, and one of them is load-bearing: a number, once assigned, is never reused — including for proposals that get rejected or withdrawn. There are no gaps in the sequence, so the archive cannot be tidied after the fact. You can read what we turned down.

Two other rules worth stating plainly. Only a human can accept a proposal — the person who did is named on it, with the date. And a proposal is only called final once a check in aDNA’s own tooling fails when the rule is violated; until then it stays accepted, which is a different and more honest word.

The process is itself AEP-1, filed through the process it describes, so it has been used once before anyone else is asked to use it. There is also a machine-readable index for agents.

The archive is short today — two proposals, one of which is the process — and the page says so rather than implying a backlog of activity. There is no published review time either, because none has been measured.

The contribute button now leads somewhere

The site has had a Contribute on GitHub button for months. The repository it points at had no code of conduct, and its contribution guide sat one directory below where GitHub looks for it — so it was present and effectively invisible. The documentation was real and good; it was behind the wrong door.

Both now exist at the top of that repository, and the contribution guide there routes you by what you actually have: a bug, a question, a fix, or a change to the standard itself.

We also wrote down something that was already true and had never been stated: AI-assisted contributions are welcome, and must be disclosed. Agents may draft proposals and open pull requests; every proposal names the agent that drafted it, if one did. Most of this project’s own documentation was written that way. Saying so is more useful than pretending otherwise.

The homepage said two opposite things about your files

Above the fold, the site told you: no server, no signup, nothing leaves your machine. Two sentences later it told you your context was “shared in the open.” The subject of that second sentence was your context — your notes. Read literally, which is how anyone reads a page for the first time, we promised that your files stay private and that we publish them.

What we meant was that the standard is open. That is what the sentence now says. The promise about your files is unchanged and unqualified: they stay on your machine.

This one mattered more than its size suggests. A reader evaluating aDNA for work involving confidential notes reached that pair and stopped there — reasonably.

A name we never explained

The fold on four pages said the site was “built on the Lattice Protocol.” The glossary has no entry for it. /glossary/lattice and /glossary/lattice-protocol both return 404. There is no page on this site that tells you what it is.

We also cannot tell you yet — the protocol material is under a legal review that has not concluded. A term you cannot explain does not belong in the first thing a stranger reads, so it is out of the fold until that review finishes, at which point it can come back with an explanation attached. The link it carried still goes to the specification.

It is still named in two deeper places, both deliberately: a tutorial that flags it as design-not-yet-shipped in its own text, and a page that reproduces a file from the install verbatim — that page’s entire purpose is that we did not edit what it shows you.

Naming a relationship on the page where you would check it

The properties page — the one that exists so you can verify which accounts and repositories are really ours — listed the Rare Archive under “what is not ours” and noted it sits in the Wilhelm Foundation’s own GitHub organization, under their control.

True, and incomplete. The person who operates this network also holds a role at that Foundation. Both About and the state of the network already said so; the page where a skeptical reader would actually look did not. Finding that gap by comparing our own pages against each other is worse than being told it plainly, so it is now told plainly there too.

An example that never happened

What is aDNA opened its before-and-after with a lab whose 200 files sprawled across three tools and a new collaborator who needed three days to orient. There was no lab. There was no measurement. It was a plausible illustration written in the voice of an observation.

We cut a fabricated terminal transcript from Get Started one release ago and explained why. A reader found the next one unaided. The invented specifics are gone, and the passage now says outright that it describes a general pattern and not a measured project.

What this pass did not fix

Neither the privacy nor the security page says anything about clinical or regulatory posture — not HIPAA, not GDPR, not de-identification, not patient data — while the homepage talks about rare and undiagnosed disease throughout.

We are not fixing that with a sentence today. Doing it properly means deciding who this site is for and stating it, and writing reassuring copy ahead of that decision would be exactly the kind of claim this site is trying to stop making. It is recorded as open, with a name and a reason, rather than closed quietly.

One place per audience

The site described the same five audiences in three different sections, under three different URL schemes, and listed them twice in the navigation. There is now one: Use Cases. Nothing was deleted — the material that only existed in the retired pages was folded into the pages that survive.

Navigation

The primary navigation is seven destinations and no overflow menu. Previously eight, with a “More” menu that hid destinations you could not otherwise reach.

URLs

Vault pages were reachable under two different casing schemes, which meant links to some of them would break permanently on a case-sensitive host. There is now one scheme, all lowercase, and every URL that previously worked still resolves — with or without a trailing slash.

The compliance walkthrough moved to /provenance-audit/, which is what it describes. It was previously reachable from no navigation surface at all.

The specification is twenty pages, not one

The specification was a single page of 163,169 bytes. Every reader paid the whole thing to read any part of it, and on a phone it was a scroll of roughly 74,000 pixels. It is now a hub with twenty numbered section pages, each linkable on its own, plus a full-text page for anyone who wants the old behaviour deliberately.

Twenty section URLs and the full-text URL previously returned 404. They resolve now. There is also a link check that blocks a release on any internal 404, which is how we would rather find the next one.

Dates

119 pages now carry the date they were last updated and a link to the file they were generated from. Previously none did, which meant a reader had no way to tell a page written last week from one written in April.

Four hand-written pages still carry no date — including /provenance-audit/, which is the page that explains how to check this site’s claims. That is the wrong page to be missing a date and it is on the list.

The changelog you are reading also went from one entry to four, and now has a feed.

The registry says what stage things are at

The registry listed 74 vaults as one undifferentiated set. That is not what 74 means here. It now separates them into 7 in use, 10 chartered, and 57 planned, with the stage shown on every card and on every vault’s own page.

All three groups get the same card. A denser card for “in use” and a sparser one for “planned” would read as a ranking, and the field being ranked is one each vault declares about itself — so the page says that in plain text rather than implying a rigour it does not have. The homepage was separately displaying a raw internal status value, so the same vault could be described one way there and another way here. It no longer is.

A page that was quietly showing nothing

/commons/ reported “member records last synced .” — an empty date and a stray full stop — and displayed none of the relationships each vault declares. WilhelmAI showed 0 of its 3; Rare Archive showed 0 of 1. The page had been joining two data sets on identifiers that stopped matching when vault URLs were normalised earlier in the day, and every field it lost had a polite empty state, so the failure rendered as a considered absence rather than as an error.

It is fixed. We are noting it at length because that page’s own text promises that honest activity is “exactly this: the dates above and the relationships each vault declares,” and for a while it was showing neither.

You can read the install before you run it

Our install is one command that clones a repository and starts an agent inside it. The agent’s first act is to read the instruction files you just cloned. That is a fair thing to hesitate over: those files are prompt-ware, and prompt-ware is executed by the agent that reads it.

So they are now published. What your agent reads shows all four files — 1,035 lines, about 70 KB — exactly as they arrive, annotated with what each one does and what to look for. Not screenshots and not summaries: the bytes, pinned to commit 0364d85 of the standard, each with a SHA-256 you can check against your own clone with shasum -a 256. The build refuses to publish the page if those bytes stop matching that commit.

Get Started now also states, above the command rather than below it, exactly what it writes and where, that nothing is installed outside that one directory, that this particular one-command flow assumes Claude Code specifically, and that rm -rf ~/aDNA is the entire uninstall. There is a section on how to check it worked — five commands you can run, plus the one that actually matters: open a new agent session inside your project and see whether it already knows where it is.

A transcript we should not have written

Get Started used to show a sample terminal session: a $ claude prompt, a checkmark, and an interview asking what your project was called. We wrote that by hand. The software does not print those lines — we searched the standard for them and found them nowhere but on our own marketing page — and the flow it depicted had the order wrong: a fresh workspace has no project yet, so the fork skill runs and then offers the interview, rather than the interview building the project.

It has been removed and deliberately not replaced with a better-looking invention. There is a labelled gap where it was, and a real recording will fill it once we have made one on a clean machine and timed it. The page also carries a claim that setup takes about five minutes; we have not measured that yet either, and it stays flagged internally until we do.

We are writing this up rather than quietly deleting it because it sat directly above the one line on that page a reviewer told us he trusted — “nothing executed from the network” — which is true, and which faked output three inches higher does not deserve to sit next to.

Two pages that answer “what is this, really?”

State of the Network separates what actually runs from what is operator-run, what belongs to other people, and what is merely planned. It states plainly that the vaults listed on this site run on one computer operated by one person, and that this is not evidence of adoption.

Canonical Properties lists every web property that legitimately belongs to aDNA, each with the date it was last opened from outside, so you can tell a real one from a copy.

Claims revised down

Several statements on the site described intentions in the present tense. Where a claim could not be checked, it was removed or rewritten rather than softened. Counts shown on the site are derived from the underlying data rather than typed by hand.

Security disclosure

Reporting a vulnerability previously had no working destination. There is now a published policy and a private reporting channel on the source repository.

Accuracy and layout

Entries in the vault registry no longer show internal placeholder values, and pages that overflowed horizontally on a phone were fixed.

Security headers

The site was configured to send four security headers and was serving only one of them: the configuration never reached the deployed output. Deploys now assemble and verify the header set as part of shipping, and refuse to publish if any of the four is missing.

Installer

Getting a workspace onto a machine no longer starts with reading instructions. There is a single command for macOS and Linux, and a page that shows you exactly what it will do before you run it.

v0.1.0 — Site Scaffold

Initial scaffold of the aDNA documentation site. Astro 6 project with documentation archetype layout, branded design tokens, and empty content collections ready for content integration.