The machine view, part 1: how machines read your outline and your structured data

Why look at a page the way a machine does?

This is part one of a two part series. I built By Robots For Robots as a small laboratory for the machine-readable web, and its main instrument is the machine view: press Shift + M on any page and a dock opens with four panels. This post covers the first two, Outline and Structured Data. Part two covers Extraction and Chunks.

The reason to look at pages this way is simple. Before a person reads your page, something else almost always has: a search crawler, an AI assistant fetching sources, a retrieval pipeline building an index. None of them see your fonts or your layout. They see structure. If the structure is clear, everything downstream gets easier, from rankings to rich results to being quoted in an AI answer. If it is muddled, no amount of design will fix it.

What does the Outline view show?

The Outline panel lists every heading on the page, indented by level. Here is what it shows for the By Robots For Robots home page:

H1 By Robots For Robots
  H2 Three things it is trying to be
    H3 Machines read first
    H3 Build the instrument
    H3 Nothing is gated
  H2 See the page the way the machine does
  H2 Experiments
    H3 The Machine View
    H3 Readability Probe
    H3 Citation Drift
    H3 The Robots Ledger
  H2 Notes
    H3 The Evolution of This Website
  H2 Permanently unfinished

14 headings. No skipped levels. The hierarchy is contiguous and machine-navigable.

That last line is the verdict. The panel counts the headings, checks whether any level is skipped (an H2 jumping straight to an H4, for example), and says so either way.

Turn the overlay on and the page itself gets labeled too. Each heading gets a small tag with its level, and each semantic region gets a name. The site header, for example, is labeled "#HEADER · SITENAVIGATIONELEMENT." That is the machine's view of the page skeleton: regions first, then a ladder of headings inside them.

The useful test is to read the outline on its own, without the paragraphs. This one tells a coherent story: what the site is, the three things it is trying to be, how to see the page like a machine, the experiments, the notes, and a closing section. If you only had the headings, you would still know what the page covers. That is the standard.

Why does the heading outline matter to machines?

Headings do three jobs for a machine.

1. They summarize. A heading is a short, high-signal description of the text below it. Search engines and AI systems both lean on that signal to understand what a section is about, especially on long pages.
2. They set boundaries. Many retrieval systems split pages into passages at headings. The heading becomes the label for that passage. That is why part two of this series spends so much time on chunks: chunk quality starts with outline quality.
3. They match questions. A heading phrased the way people ask, such as "What does structured data actually do?", gives an answer engine an obvious place to find the answer. Every H2 in this post is written that way for exactly that reason.

Google has said for years that heading order is not a strict ranking rule and that pages with imperfect heading levels can still rank. I agree, and I would not rewrite a page just to fix a skipped level. But skipped levels are usually a symptom: headings chosen for their font size rather than their meaning. And a machine has only the meaning.

What outline mistakes show up most?

• Styling with heading tags. Using an H4 because it looks right in the design, not because it is a sub-section of an H3. This is where most skipped levels come from.
• Decorative headings. "Our Story," "Learn More," "Welcome." They say nothing about the content below, so a machine learns nothing from them.
• Multiple H1s fighting. A logo wrapped in an H1 plus a page title in another H1. Not fatal, but the machine has to guess which one is the topic.
• Text that is not really in the heading. The By Robots For Robots build log records a good example. The home headline is split across two lines with markup, and the first version of the outline read it as "By RobotsFor Robots," with no space. A person sees two lines. A parser that concatenates text nodes sees a word that does not exist. If your headings are assembled from spans and line breaks, check how they read as plain text.
• Headings hidden from the HTML. Headings drawn into images, or injected late by JavaScript, may not be there when a machine reads the page.

What does the Structured Data view show?

The Structured Data panel shows the JSON-LD on the page, parsed. On the By Robots For Robots home page the header reads "BLOCK 1 / @type: WebSite, Organization, WebPage, ItemList," followed by the JSON itself. Trimmed down, it looks like this:

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "WebSite",
      "@id": "https://www.byrobotsforrobots.ai/#website",
      "name": "By Robots For Robots",
      "publisher": { "@id": "https://www.byrobotsforrobots.ai/#publisher" }
    },
    {
      "@type": "Organization",
      "@id": "https://www.byrobotsforrobots.ai/#publisher",
      "name": "Double Atari",
      "url": "https://www.double-atari.com/",
      "areaServed": "Minneapolis, Minnesota"
    },
    {
      "@type": "WebPage",
      "@id": "https://www.byrobotsforrobots.ai/#webpage",
      "isPartOf": { "@id": "https://www.byrobotsforrobots.ai/#website" },
      "about": { "@type": "Thing", "description": "The practice of structuring web content so that crawlers, retrieval systems and answer engines can parse, cite and reuse it accurately." }
    },
    { "@type": "ItemList", "itemListElement": [ "...four experiments..." ] }
  ]
}

Three details are worth noticing.

• One block, one graph. Instead of four separate scripts, everything sits in a single @graph. That makes the relationships easier to follow.
• Entities point at each other by ID. The WebSite names its publisher by @id, and the WebPage says it is part of the WebSite by @id. That turns a list of facts into a small connected graph.
• The publisher is a real entity elsewhere. The Organization is Double Atari, with its own URL. That is the line that tells a machine this lab and the consulting practice are the same people.

If the JSON-LD on a page will not parse, the panel shows the error instead of the data. That is the most valuable thing it does, because broken structured data is invisible on the page itself.

What does structured data actually do?

Structured data is a way of stating things a machine would otherwise have to infer. This page is an article. This person wrote it. This organization published it. This is the breadcrumb trail. These are the questions it answers.

What it does, concretely:

• It makes some search features possible. Google uses specific schema types for specific rich results, and it documents which ones it supports. Supported markup makes a page eligible. It does not guarantee anything.
• It removes ambiguity about entities. Who wrote the page and who published it are exactly the questions that matter when a system decides whether a source is trustworthy. Clear Person and Organization markup, connected by ID across the site, answers them directly.
• It is cheap and checkable. Unlike most SEO work, you can verify it in a minute.

What it does not do: it does not make a weak page rank, and I would be careful with anyone who claims a specific schema type is a secret key to AI answers. The evidence on how much AI assistants use JSON-LD directly is mixed. My position is that clean, accurate structured data is cheap insurance that removes guesswork for every kind of machine, so it is worth getting right. I wrote more about this in schema markup for AI search.

What structured data mistakes show up most?

I will start with my own. A Semrush site audit of double-atari.com flags five invalid structured data items, including one on the homepage. They are the only errors in a 92% Site Health score, which is a good illustration of the problem: nothing looks wrong on the page, and you would never notice without a tool. The most common causes I see:

• Syntax errors. A trailing comma or a stray quote, and the whole block fails silently.
• Markup that does not match the page. FAQ schema with questions that are not visible on the page, or a rating that does not exist.
• Missing required properties for the type, which makes the item invalid for the rich result it was meant for.
• Disconnected entities. An Organization defined three different ways on three templates, with no shared @id.
• Stale data. A dateModified that never changes, or an address the business moved away from.

How to check your own outline and structured data

1. Read only your headings. Use a browser extension, or paste your HTML into the Readability Probe, which checks outline integrity along with fifteen other structural checks. Ask whether the headings alone tell the story.
2. Look for skipped levels and empty headings, then fix the ones caused by styling.
3. Rewrite vague headings as specific ones, ideally phrased the way people ask.
4. Validate your JSON-LD with Google's Rich Results Test and the Schema.org validator, on every template rather than one page.
5. Connect your entities by ID. One Organization and one Person, defined once and referenced everywhere.
6. Re-check after every template change. Structured data breaks quietly.

Then flip the machine view on byrobotsforrobots.ai and compare. In part two, the more interesting half: what a crawler keeps from your page, and how a retrieval system cuts it into pieces.

Outline and structured data FAQ

Do heading levels affect SEO?

Heading levels are not a strict ranking rule, and pages with imperfect heading order can still rank. But headings help search engines and AI systems understand what each section covers and where sections begin and end, so a clear, descriptive heading outline makes a page easier for every machine to read.

What is a skipped heading level?

A skipped heading level happens when a page jumps from one heading level to a deeper one without the level in between, such as an H2 followed directly by an H4. It usually means headings were chosen for their visual size rather than their meaning.

What is JSON-LD structured data?

JSON-LD is a format for adding structured data to a page in a script tag, using the Schema.org vocabulary. It states facts a machine would otherwise infer, such as the page type, author, publisher, breadcrumbs, and questions answered.

Does structured data help with AI search?

Structured data removes ambiguity about what a page is and who stands behind it, which helps any machine that reads it. The evidence on how much AI assistants use JSON-LD directly is mixed, so treat it as cheap insurance rather than a guaranteed ranking factor.

How do I check my structured data for errors?

Use Google's Rich Results Test and the Schema.org validator on each page template, or a site audit tool that flags invalid structured data items. The By Robots For Robots machine view also shows parsed JSON-LD, or the parser error if it is broken.