theviatlas.com

My website theviatlas.com scored 15/100 on Good for Bots (Poor). Good for Bots measures one thing: whether a language model can read a site and cite it.

I need you to: let the Good for Bots crawler through the WAF.

The check it fails is "Serves our crawler without a challenge", a penalty taking 15 points off the score. What the scanner saw: A Cloudflare challenge identified by the cf-mitigated header. A model fetching this page gets the challenge, not the content.

The challenge is Cloudflare's. Bot Fight Mode and the Managed Challenge are the usual
culprits, and neither is switched off by marking anything as a verified bot. What works is
a WAF custom rule matching the user agent with the *Skip* action, with the boxes ticked
for Bot Fight Mode, rate limiting and the managed rules. Put it above the rules that issue
the challenge, because order decides which one fires.

When something in front of a site answers a crawler with an interstitial, a CAPTCHA or a
flat refusal, none of the work that site has done for machines is reachable. The same
thing happens to model crawlers, which is the part that matters: a challenge nobody can
solve is indistinguishable, from the other side, from having no content at all.

The crawler sends exactly one user agent on every request:

```
GoodForBotsBot/1.0 (+https://goodforbots.com/bot)
```

It makes roughly twenty requests per scan, sequentially, and it obeys `robots.txt`.

Add an allowlist rule for that user agent in whatever sits in front of this site:

- **Cloudflare**: a WAF custom rule matching the user agent with the *Skip* action,
  skipping Bot Fight Mode, Managed Challenge and rate limiting. A Bot Management
  "verified bot" exception is not enough on its own; the skip rule is.
- **AWS WAF**: a rule with `Allow` above the bot-control rule group, matching the
  `User-Agent` header.
- **Akamai**: a Bot Manager exception for the user agent; a rate policy alone is not
  enough.
- **Imperva / Incapsula**: an allowlist entry for the user agent under bot access
  control.
- **Vercel**: exclude the user agent from the Attack Challenge Mode or firewall rule.
- **Fastly, nginx, or a hand-rolled rule**: whatever matches on `User-Agent` before the
  challenge is issued.

If the intention is to block us, do that in `robots.txt` instead. A `Disallow` for this
crawler is honoured immediately and without argument, it costs no points, and it is the
honest way to say no. Only `robots.txt` counts as a refusal; a challenge is read as a
site a model cannot use.

Do not widen the rule beyond this one user agent, and do not disable bot protection
generally. One allowlist entry is the whole change.

The whole report, as markdown, is at https://goodforbots.com/r/theviatlas.com.md?scan=cmuthmels002301p3mb2eronk. Read it first: this prompt covers one finding, and the report has everything the scan saw.

When you are done, summarise what you changed and how to check it against a running instance. Do not try to run the Good for Bots scan yourself: it only sees what is already deployed, it is rate-limited, and re-running it is the site owner's call once the change ships.

My website theviatlas.com scored 15/100 on Good for Bots (Poor). Good for Bots measures one thing: whether a language model can read a site and cite it.

I need you to: serve markdown through content negotiation on all public HTML routes.

The check it fails is "Serves markdown when asked for it", worth 10 points. What the scanner saw: Asking the homepage for markdown returned HTTP 403.

Implement content negotiation across all public HTML routes, including page types
outside the scan's sample. Put it in the shared response handling or the handlers
for each page type, so new pages receive it too. Agents need the content of any
page they follow, including pages the report did not name.

When a request arrives with `text/markdown` in its `Accept` header, the same URL that
serves HTML to a browser should return a markdown rendering of that page's content.
Requests without that header must keep getting the HTML exactly as they do now.

The response must:

- set `Content-Type: text/markdown; charset=utf-8`;
- include `Accept` in the `Vary` header, so shared caches never serve the markdown to a
  browser or the HTML to an agent (RFC 9110 says a server SHOULD send `Vary` whenever
  the representation depends on a request header);
- contain real markdown, not HTML with a different header on it;
- drop `ETag` and `Last-Modified` for the converted response, since a conditional request
  cannot be honoured against a body generated on the fly.

Work out how to do this in whatever stack this project uses. If the site is behind
Cloudflare on a paid plan, the "Markdown for Agents" zone setting does all of the above
and is the least invasive option. Otherwise implement it in the framework: middleware
inspecting the `Accept` header, a route handler that returns the markdown source, or
whatever fits the architecture here.

Strip navigation, headers, footers and cookie banners from the markdown. The point is the
content, without the page furniture around it.

Verify HTML and Markdown responses for each public page type, including URLs
outside the reported sample. Check that each Markdown response contains that
page's content and that ordinary browser requests still receive HTML.

The whole report, as markdown, is at https://goodforbots.com/r/theviatlas.com.md?scan=cmuthmels002301p3mb2eronk. Read it first: this prompt covers one finding, and the report has everything the scan saw.

When you are done, summarise what you changed and how to check it against a running instance. Do not try to run the Good for Bots scan yourself: it only sees what is already deployed, it is rate-limited, and re-running it is the site owner's call once the change ships.

My website theviatlas.com scored 15/100 on Good for Bots (Poor). Good for Bots measures one thing: whether a language model can read a site and cite it.

I need you to: mark the content up so a parser can find it.

The check it fails is "Content is marked up so a reader can find it", worth 10 points. What the scanner saw: The homepage did not return an HTML document, so there is no markup to read.

Review the site's public page templates and shared layout components. Fix missing
content roots, heading structure and landmarks wherever they occur, including
templates outside the reported sample. Check the server's HTML response from each
page type: a shared layout fix can introduce a second `<main>` on pages that
already have one.

Semantic elements help a reader of raw HTML find the page's content and distinguish
it from navigation and other surrounding material.

Three things, all from the HTML standard. Change the markup; do not change what the page
looks like.

**1. One content root.** Wrap the page's dominant content in a single `<main>`.

```html
<body>
  <header>…site header…</header>
  <main>…the article, the docs page, the product copy…</main>
  <footer>…site footer…</footer>
</body>
```

The standard allows exactly one `<main>` per document that is not marked `hidden`, and
its ancestors may only be `<html>`, `<body>`, `<div>`, an unnamed `<form>` or a custom
element, which makes a `<main>` inside `<section>` or `<article>` invalid. Put the real
content inside it: a `<main>` that holds a sliver of the page while the article sits in a
sibling `<div>` marks nothing. If a framework template makes the element impossible,
`role="main"` on the wrapper is an acceptable substitute.

**2. A heading outline that holds together.** Exactly one idea per level, starting at
`<h1>`, and never skipping a level on the way down.

```html
<h1>What this page is about</h1>
  <h2>First section</h2>
    <h3>A detail</h3>
  <h2>Second section</h2>
```

`<h1>` → `<h3>` is invalid; `<h3>` → `<h2>` on the way back up is fine. Use heading
elements for headings and CSS for size: a `<div class="text-2xl">` is invisible to the
outline. If a heading is an image or an icon, give it real text and hide it visually
rather than leaving the element empty.

**3. Landmarks around the content.** At least two of these, outside `<main>`:

```html
<header>   <!-- the site header: becomes the banner landmark -->
<nav>      <!-- navigation -->
<footer>   <!-- the site footer: becomes contentinfo -->
<aside>    <!-- related content -->
<search>   <!-- a search form -->
```

Two rules that surprise people. `<header>` and `<footer>` only count as the page's banner
and contentinfo when they are children of `<body>`; inside `<article>` or `<section>` they
are that section's own header and footer and are not landmarks at all. And a `<form>` is
only a landmark when it has an accessible name, so give a search form
`aria-label="Search"`.

Do not add landmarks that describe nothing: five unlabelled `<nav>` elements are worse
than one. And do not wrap the whole body in `<main>`: that puts the header and footer
inside the content root, which removes the landmarks this asks for.

The report's content and navigation breakdown is diagnostic. It measures extracted
text in marked regions, not content quality. Keep useful navigation; do not remove
links or add filler to change a percentage. If much of the text is labelled "other",
check whether the real main content has a meaningful wrapper. The reported start of
main text follows HTML order, which can differ from the visual layout.

The whole report, as markdown, is at https://goodforbots.com/r/theviatlas.com.md?scan=cmuthmels002301p3mb2eronk. Read it first: this prompt covers one finding, and the report has everything the scan saw.

When you are done, summarise what you changed and how to check it against a running instance. Do not try to run the Good for Bots scan yourself: it only sees what is already deployed, it is rate-limited, and re-running it is the site owner's call once the change ships.