Be the page a developer finds before they pick a tool

Your reference is written for somebody who has already chosen you. It lists endpoints, parameters and limits. It does not argue for an approach, weigh two of them, or explain what to do when a migration goes sideways. That is the docs-adjacent layer, and on most developer-tool sites nobody owns it.

Four page shapes fill it, and every one can be grounded in material you already hold:

• Concept explainers that define a term in your category and show where the product sits, without turning into a pitch.
• Migration and upgrade guides naming the removed endpoint, its replacement and the version it landed in.
• Troubleshooting pages built from the errors your support inbox actually receives.
• Integration recipes for the frameworks and runtimes your users pair you with.

Articles are grounded in your own first-party material where it exists — reference docs, changelog entries, product data, support answers — so a page quotes your real limits and parameter names rather than a plausible-looking invention. That grounding in first-party data is also what clears the novelty check: a draft that restates the existing top ten carries nothing only your company could have written.

The SaaS and developer tools page covers the same engine from a marketing team's side.

“Alternatives to X” and “X against Y” are the highest-intent queries in any tool category, and they are where generated content most often goes wrong: a competitor's price, quota or feature lifted from a two-year-old blog post and presented as current. That is a factual error with a legal edge, and the rival's team is the audience most likely to spot it.

The guardrail is the research step. Research fetches the pages that rank for the query, and the fact-check judge — a model from a different vendor than the writer — tests every claim in the draft against what was actually retrieved. A statement about another product that no fetched page supports does not survive to publication.

Volatile detail is handled by leaving it out. Prices, quotas, plan names and model versions move without notice, so the article sends the reader to the rival's own page for the current number and spends its words on what does not go stale: the architectural trade-off, the workload each design suits, the migration cost, the thing your engineers say on calls and have never written down.

Our own comparison pages work the same way, and print the date we last checked the other product's public pages.

For a developer audience an invented parameter is worse than a dull paragraph. It gets pasted into a terminal, it fails, and the reader concludes your documentation cannot be trusted.

The defence here is structural rather than stylistic. Writers are Claude models, and the model that writes is never one of the judges. Four checks then run in parallel. None is run by the model that wrote the draft, and every check includes at least one model from a different vendor: Gemini and GPT lead the fact-check and the novelty score, while the E-E-A-T and AI-tell panels pair a Claude judge with a GPT or Gemini one. The four are a fact-check against the retrieved sources, a novelty score against the competitor pages fetched during research, an E-E-A-T critique, and AI-tell detection. Any failure returns the draft to the writer with the specific objections, for up to three revision rounds; a draft that still fails is rejected rather than published.

The pass rates are measured, not projected. Across 186 Standard-tier runs, 21% of drafts cleared every check on the first attempt with no revision, and 51% got there within the three revisions allowed; the rest never published. Pro-tier judges are stricter: 25% cleared every check across a small sample of 16 runs. For articles carrying API-level detail, Pro is the tier we suggest.

Billing follows the same logic: per published article, drawn from a prepaid balance rather than a subscription, and a draft that fails the checks is not charged. Fixed prices per published article: Lite £9, Standard £19, Pro £39 and Premium £69 — about $11, $24, $50 and $88, charged in GBP. Length does not change the price, only the tier does; the tiers are compared on pricing. For API-level detail, budget for Pro at £39 an article rather than Standard at £19. See how it works for the full sequence.

Most tool companies run a Next.js or custom marketing site, and most content products assume WordPress. Articles are delivered through whichever door your site actually has.

• @itmaster/sdk for Next.js: install the package, add a route, and published articles render inside your own components with your typography, navigation and dark mode. They arrive as data, not pasted HTML.
• REST pull feed: fetch published articles with a per-site key, at build time or on request, and render them however your stack prefers.
• Signed push webhook: the engine posts each article to an endpoint you name, signed so you can verify it before storing it. This is the route for a headless CMS or a static generator.
• WordPress plugin if the blog itself runs WordPress: install it, paste one key, and posts arrive with the Yoast or Rank Math fields filled.

Every article ships finished: Article and FAQ schema, internal links into your docs and related posts, a hero image and an FAQ block. On publish, IndexNow notifies the search engines that support it, and the engine serves your llms.txt — the convention Jeremy Howard proposed as “a /llms.txt markdown file to websites to provide LLM-friendly content”, an H1 plus H2 sections of annotated links (llmstxt.org, checked 4 September 2026) — rendered from your published articles as an H1, a one-line summary and a bulleted index, rather than hand-maintained. Shopify and Webflow we handle on request; on Wix or Squarespace the dashboard keeps a copy-paste queue instead. The payload shape is in the docs.

The mechanism is the same regardless of category: every live tenant's articles are grounded, cross-vendor checked and published before measurement ever runs, so what gets measured is a page built to be citable, not one fixed up afterwards to look that way.

Measurement then runs nightly. The loop reads each article's impressions, clicks and queries from Search Console and queues a refresh when a page starts to decay — worth more in this category than most, because a guide to an API that changed last quarter is worse than no guide at all.

It also puts the questions your articles were written to answer to GPT and Perplexity, and records whether your site is named. That citation rate is the series to watch where buyers ask an assistant for a shortlist before they ever open a results page. Nobody can promise a citation; what the engine controls is whether there is a page worth citing.

Start with the free site check, the AI Visibility Checker or the AI Crawler Check on the site you have now.

The honest disqualifiers, so you can rule yourself out in a minute rather than a month.

• Pre-category products. If nobody searches for the problem yet, discovery will return a thin list and say so. It reads DataForSEO and your own Search Console; it does not invent demand that is not there.
• Documentation that lags the product. Grounding retrieves what you have. If the docs are two releases behind, so are the articles written from them, and the refresh loop reacts to Search Console decay rather than to a changelog entry.
• A requirement that engineering signs off every published sentence. Clearing the four checks is the gate, and a passing draft publishes. Takedown, per-site pause and the global off switch all act afterwards.
• You want the reference manual written. This is the layer above it. Your docs stay the source of truth and the articles link into them.
• You need a competitor's current pricing on the page. Comparison articles deliberately leave volatile figures out and link to the rival's own page for them, because a stale quota or price attributed to another company is a factual error with a legal edge.

One further limit that catches people out: the engine does not run your code. It can describe an approach and quote your documented limits, but it never executes a snippet to check that it compiles, so a code-heavy tutorial still wants an engineer's eye before you rely on it.