Procedural content that could be marked up as a HowTo

A procedure has a shape a parser can recognise without understanding the subject. Three or more items in sequence, each opening with an imperative verb, where the order is doing work. "Install the CLI", "authenticate", "push your first build" only makes sense in that order, and that dependency is the signal.

Supporting signals raise confidence: a heading containing "how to" or "setting up", an ordered list rather than a bulleted one, time or tool nouns near the top of the page, screenshots interleaved with the items. None of them is sufficient alone, which is why the check reports candidates rather than failures. A candidate is a page worth your judgement, not a bug.

Before running anything site-wide it is worth seeing the pattern with your own eyes on a page you know. Paste this into the browser console. It lists ordered lists that look imperative and says whether the page already declares HowTo.

// Ordered lists on this page that read like instructions,
// plus whether any HowTo markup is present at all.
const declared = [...document.querySelectorAll(
  'script[type="application/ld+json"]'
)]
  .map((s) => s.textContent || '')
  .join(' ')
  .includes('"HowTo"')

const IMPERATIVE =
  /^(add|open|click|select|choose|install|run|copy|paste|set|enter|create|download|upload|connect|verify|check|remove|delete|deploy|configure|restart|sign|log|navigate|scroll|save)\b/i

const candidates = [...document.querySelectorAll('ol')]
  .map((ol) => {
    const items = [...ol.children].filter((el) => el.tagName === 'LI')
    const verbs = items.filter((li) =>
      IMPERATIVE.test((li.textContent || '').trim())
    ).length
    return { ol, steps: items.length, verbs }
  })
  .filter((row) => row.steps >= 3 && row.verbs / row.steps >= 0.6)

console.table(
  candidates.map((row) => ({
    steps: row.steps,
    imperative: row.verbs,
    first: (row.ol.textContent || '').trim().slice(0, 60),
    markup: declared ? 'HowTo declared' : 'none',
  }))
)

Two things to notice in the output. A nav or contents list will show up, which is the second false positive above arriving in practice. And a page whose procedure is written as paragraphs returns nothing at all, because there is no ol to find. An empty result is not necessarily a clean page.

You will get more candidates than you expect and you should mark up fewer than you expect. The rich result that used to justify doing this in bulk is gone, so blanket coverage now costs maintenance and returns close to nothing. Work down the list with three questions.

• Is the procedure the point of the page?A page whose whole job is one task is a real candidate. An installation section inside a forty-screen reference document is not: HowTo describes a task, and that page's task is "be a reference". If one page holds three unrelated procedures, the finding is that it should be three pages.
• Does the page get traffic or support tickets? The pages worth the effort are the ones people already arrive at with the intent to follow along. A procedure nobody reaches gains nothing from a declaration about it.
• Will it still be accurate in six months? This is the one people skip. Marked-up steps are a second copy of the procedure, and a UI change that updates the page but not the JSON-LD leaves you describing a flow that no longer exists. If the procedure churns, and product onboarding flows churn constantly, leave it alone.

What is left is usually a short list of stable, well-trafficked, single-task pages. Those are worth writing, and the markup itself, with the properties that matter is a separate guide because the decision and the implementation are separate jobs.

No, and this is one of the checks where the honest answer needs the distinction spelled out. A detection changes nothing on its own. A model reading your page does not know or care that an audit flagged it, so the effect depends entirely on which of the two available responses you pick.

Convert prose into a real ordered list and you have changed something an assistant will notice, because a nine-item list arrives as nine items rather than as a paragraph that might get cut after the fourth. Add JSON-LD to a page that was already a clean ordered list and the increment is small and undocumented by every vendor involved.

So the useful reading of this check for AI search is a list of pages whose structure may be wrong, with the markup question as a second-order follow-up. Ranked against the checks in the AI search group, whether a crawler is allowed in and whether your text survives without JavaScript matter considerably more than whether your procedures are declared.

A candidate is closed either way, and recording which way matters more here than on most checks. If you marked it up, the confirmation is that the declared step count matches the visible one and the block parses. If you decided against it, the confirmation is that the decision is written down, because the same page will resurface on the next crawl and someone will re-triage it from scratch.

Do not watch the candidate count as a score. It falls when you mark pages up and it also falls when you delete a good procedure, and the number cannot tell the difference. The figure worth tracking is narrower: of the pages where a procedure is the whole point, how many are ordered lists with a task-shaped heading. That one only moves when the page genuinely improved.