Your website has two front doors. Your AI agent uses the worse one.

Open your site's home page. Now open it the way an AI agent does — curl the URL, or watch what a headless crawler actually receives. For a lot of modern sites, those are two different pages. The human gets a fast, rich, hydrated experience. The agent gets a shell: a skeleton of empty <div>s, a spinner, and a polite note to enable JavaScript. Same URL. Two front doors. The agent walks through the worse one.

For most companies that's a rounding error. For a product whose entire pitch is "built to be used from inside your AI coding agent," it's an own-goal. So we fixed ours. Every page on otf-kit.dev now has a clean-markdown twin. Append .md to any path and you get the real content — no HTML shell, no hydration, no guessing:

• otf-kit.dev/pricing → otf-kit.dev/md/pricing.md
• otf-kit.dev/docs/getting-started → otf-kit.dev/md/docs/getting-started.md
• otf-kit.dev/templates/saas-dashboard → otf-kit.dev/md/templates/saas-dashboard.md

Open one. It's real, and it's checkable — which is the entire point.

Why the two front doors exist

You didn't build a bad page. You built a page for humans, and humans run a full browser. An agent usually doesn't. It either fetches the raw HTML and reads whatever came back before JavaScript ran, or it spins up a headless browser — slow, expensive, and something crawlers do sparingly. Either way, a heavily client-rendered page hands it a shell.

And even a fully server-rendered page is noisy. Wrapped around your 400 words of actual content is a nav bar, a cookie banner, a footer, three analytics tags, and a few hundred lines of framework markup. A human's eye filters that instantly. A model extracting "what does this kit cost and what's in it" has to fight through all of it, and sometimes loses.

Why it matters more every month

A growing share of "what's a good X for Y" no longer happens on a results page. It happens in an answer box — an assistant summarizing the web and handing back three recommendations. That answer is only ever as good as what the model could pull off your page. Feed it a shell and it does one of three things, all bad: hallucinates your price, mislabels what you actually ship, or skips you entirely for a competitor whose page was easier to read. Feed it clean text and it cites you, correctly.

Then there's the literal case, the one that's specific to tools like ours: the buyer's own coding agent is often the thing reading the site. When someone points their agent at OTF, it should be able to list every page, pull the exact install command, and read a component's real API — not scrape a rendered gallery and infer. The easier your site is to read, the more useful your product is at the exact moment someone's evaluating it.

What "agent-readable" actually means

Three pieces, all boring, all cheap:

1. An index. One machine-readable list of every page, at /llms.txt. An agent reads it once and knows the whole site.
2. A mirror. A clean-markdown version of every page at /md/<path>.md.
3. A signpost. A rel="alternate" type="text/markdown" link in each page's head, so a crawler that lands on the HTML knows the plain version exists and can go get it.

To be clear about what this is not: it is not cloaking. Cloaking is serving crawlers different content than humans to manipulate them — a genuinely punishable trick. This is the opposite. It's the same public content, in a plainer format, at its own public URL, served identically to everyone. You can open the .md yourself. Nothing is hidden; something is just made easier to consume.

The part everyone gets wrong: drift

Here's the trap that makes most "we made an AI version" efforts worse than doing nothing. You hand-write a markdown copy of your site. It's accurate for exactly one day. Then you change a price on the real page and forget the copy. Now your agent-facing content is confidently, machine-readably wrong — and a wrong fact stated cleanly is more dangerous than a right fact buried in markup.

So ours isn't hand-written. Every .md is generated from the same source the human page renders from. The pricing page and its markdown twin read the same pricing table. A kit's page and its .md read the same kit definition. The docs mirror is regenerated from the doc source on every deploy. Change a number once and both surfaces move together, because there is no second copy to forget.

One wrinkle worth naming, because it's the kind of thing that breaks silently: our site ships as a self-contained build, and the running server doesn't carry the raw content files around with it. So we extract the markdown at build time and bundle it into the deploy — the server never reaches for a file that isn't there. If you build this on your own site, that's the failure mode to check first: does the thing serving your .md actually have the source available at runtime, or only while building? Get that wrong and every mirror 404s in production while working perfectly on your laptop.

Is this going to sell more kits?

Honestly — not by itself, and not this week. There's no line in any dashboard that reads "agent read the markdown, then bought." It's plumbing. But it's the right kind of plumbing: it costs almost nothing to run, it can't go stale because it's generated, and it compounds as more discovery moves into AI answers. For an agent-native product it's table stakes. And most sites — including most developer-tool sites — still haven't done it.

And how will we know it worked? We won't, cleanly. There's no honest attribution line here, and anyone who sells you one is selling you something. What we can watch is narrower and truer: our own server logs, for AI crawlers actually pulling the .md files, and the answers assistants give when someone asks them to recommend a tool like ours — whether they quote our real numbers or invent them. If the crawlers show up and the citations get more accurate over the next few months, the plumbing earned its keep. If they don't, we spent a day on something cheap and reversible and we move on. That asymmetry is the whole reason it was worth doing.

The front door your agent uses is the one you never look at. So look at it. curl your own home page and read what comes back. If it's a shell, your agents have been reading the shell too — and quietly deciding what to tell people about you based on it.