AEO Step-by-Step Instruction Patterns

TL;DR

Use

for the visible step sequence, add HowTo JSON-LD schema with HowToStep, and frame each step with an action verb followed by an object. Add a prerequisite block above the steps and a verification block below. AI engines reward procedural content that has unambiguous start conditions, ordered steps, and a check that the procedure succeeded.

Why step-by-step extraction matters for AEO

Procedural queries ("how to do X", "steps to configure Y", "how do I install Z") are among the most common in AI search. Answer engines that recognize procedural content can render numbered steps in their answers, often with deep links back to the source. When the markup is procedural-aware, the entire sequence is cited together; when it is not, the engine may quote a single sentence and lose the procedure's intent.

Core extraction primitives

A reliable step-by-step extraction pattern combines five primitives:

1. A real
   element. The visible ordering must be encoded in HTML, not just in CSS or numbering inside paragraphs.
   1. HowTo JSON-LD schema. Names the procedure, declares total time, and lists each HowToStep.
   2. Prerequisite block. Explicit list of tools, supplies, or preconditions before the first step.
   3. Step grammar. Each step starts with an imperative verb ("Open", "Click", "Run", "Verify").
   4. Verification step. A final step describes how the user confirms success.

   Minimal HowTo schema example

   Copy

   {
     "@context": "https://schema.org",
     "@type": "HowTo",
     "name": "Configure llms.txt for an AI-friendly site",
     "totalTime": "PT15M",
     "supply": [
       { "@type": "HowToSupply", "name": "Editor with file write access" }
     ],
     "tool": [
       { "@type": "HowToTool", "name": "Static site generator" }
     ],
     "step": [
       { "@type": "HowToStep", "position": 1, "name": "Create the file", "text": "Create /llms.txt at the site root." },
       { "@type": "HowToStep", "position": 2, "name": "List canonical sections", "text": "Add an H1 with the site name and an H2 per section." },
       { "@type": "HowToStep", "position": 3, "name": "Verify accessibility", "text": "Visit https://example.com/llms.txt and confirm it renders as plain text." }
     ]
   }

   Google reduced HowTo rich-result eligibility in 2023 (now mostly limited to specific surfaces), but the markup remains a strong extraction signal for general AI answer engines per practitioner reports.

   Prerequisite block patterns

   An explicit prerequisite block:

   • Names the tools, accounts, and permissions required.
   • States the assumed starting state ("You have a deployed Next.js site").
   • Calls out time, cost, or risk if relevant.

   Without a prerequisite block, AI engines often lift step 1 but lose the precondition, leaving readers stuck. A short bulleted list above the

   is sufficient.

   Step grammar rules

   • Start with an imperative verb. "Open the terminal" extracts cleanly; "You should now open the terminal" does not.
   • One action per step. If a step contains "and", consider splitting.
   • Front-load the object. "Click Settings" is easier to extract than "Now you can click on Settings".
   • Bold the UI label or command. Visual emphasis on the actionable token helps both readers and extractors.
   • Use code blocks for shell commands. Not inline code; full code blocks preserve formatting.

   Verification step patterns

   A verification step closes the procedure:

   • "Confirm the file returns HTTP 200 and renders as plain text."
   • "Open the dashboard and confirm the new agent appears."
   • "Run npm test and confirm all tests pass."

   Verification steps protect users from silent failures and are routinely lifted by AI engines as the answer to "how do I know it worked?" follow-up queries.

   Common anti-patterns

   • Numbered paragraphs instead of
     . Even with manual numbering, paragraphs are not procedurally typed.
     1. Mixed instruction and explanation. Long expository sentences inside a step dilute the action.
     2. No verification. Steps that end at "deploy" leave the user unsure whether the procedure succeeded.
     3. Implicit prerequisites. "Open the project" without saying which project or what state it is in.
     4. Drift between schema and visible steps. HowTo schema with three steps but four visible steps confuses extractors.
     5. Steps that branch. "If A do X, otherwise do Y" inside one step. Split into two procedures or a clear conditional sub-list.
     6. Skipping ordinality. Using
        for inherently ordered procedures suppresses the order signal.

        Surface behavior across platforms

        • Google AI Overviews sometimes renders procedures as a numbered list with citations per step when the markup is clean.
        • Perplexity typically extracts ordered procedures verbatim with inline source markers.
        • ChatGPT browse lifts procedures into its own answer formatting; well-bounded steps survive compression.
        • Gemini and Claude both reward HowTo schema and explicit verification.

        None of these behaviors are guaranteed, but the underlying signal — "a real, semantically procedural sequence with prerequisites and verification" — is rewarded across all of them.

        Practical application checklist

        • Convert numbered paragraphs to
          .
          1. Add a prerequisite block above the procedure.
          2. Add HowTo JSON-LD with HowToStep for each step.
          3. Start every step with an imperative verb.
          4. Bold UI labels and use code blocks for commands.
          5. Add a verification step at the end.
          6. Validate the HowTo with the Rich Results Test.

        FAQ

        Q: Is HowTo schema still worth adding given Google's 2023 changes?

        Yes. While Google narrowed HowTo rich-result eligibility for traditional search, the schema remains a strong extraction signal for AI answer engines, screen readers, and downstream consumers.

        Q: Should every procedure use HowTo schema?

        Use HowTo for any procedure that is an answer to a query. Skip it for incidental sequences inside a longer reference article where the procedure is not the primary answer.

        Q: How granular should each step be?

        One action per step. If a step requires more than two short sentences to describe, consider splitting or moving the explanation into a callout.

        Q: How do I handle conditional or branching steps?

        Keep the main

        linear. Move branches into a sub-list or a separate procedure with its own HowTo markup. Branching inside a single step damages extraction.

        Q: Can I include images in steps?

        Yes. HowToStep supports an image property. Inline images near each step help users; ensure images have descriptive alt text so AI engines can use them as supporting evidence.