You wrote a guide on how to do something, but the AI never cites it. The problem isn't what you wrote: it's that the steps are buried in a block of text and the model can't recognize it as a procedure. It moves on to whoever has clear, numbered steps, even if your guide is more accurate. It takes just thirty minutes to restructure it into the format the AI understands — and from that moment on, every guide of yours can become the default answer.
Someone asks ChatGPT “how to do X” in your field. The AI engine builds the answer by stringing together logical steps in sequence: first this, then that, finally the result. If your guide has exactly that structure — numbered steps, clear actions, expected outcome — the system maps it directly onto its own reasoning and cites it almost word for word. If instead your guide is a 1,500-word discursive block without numbers, the model discards it and goes to fetch from whoever handed it the steps already prepared.
This isn’t an aesthetic preference. It’s the way these systems reason, and I’ll explain exactly why.
Chain-of-thought reasoning is not a metaphor
When an AI model tackles a procedural question — “how do I configure X”, “how do I optimize Y” — it doesn’t generate the answer in one shot. It activates what in the research world is called Chain-of-Thought: it breaks the problem down into intermediate steps, tackles them one at a time, checks the consistency of each, and then assembles the final answer.
Shervin Minaee et al. (2024), in the most comprehensive survey available on language model architectures, describe three emergent capabilities of these systems. The third is the most relevant for anyone writing guides:
“Multi-step reasoning, where LLMs can solve a complex task by breaking down that task into intermediate reasoning steps as demonstrated in the chain-of-thought prompt.”
(A Survey of Large Language Models)
In plain terms: the model isn’t looking for a monolithic answer. It’s looking for intermediate steps that support each link in its logical chain. A guide that already presents those steps — numbered, sequential, with an action verb at the start — slots into the model’s reasoning like a puzzle piece. A discursive guide, on the other hand, forces the model to extract the logical sequence from the text on its own — and nine times out of ten it prefers a source that has already done that work for it.
I covered this in depth in the article dedicated to Chain-of-Thought, where you’ll find the full mechanism. Here I focus on the practical consequence: how a guide must be structured for the model to use it.
Retrieval follows reasoning, not the other way around
There’s a second layer that makes the how-to pattern even more powerful for AI visibility. In advanced systems like Perplexity or ChatGPT with web browsing, chain-of-thought reasoning doesn’t operate in isolation — it actively drives the retrieval of sources.
Gao et al. (2024), in the reference survey on RAG systems, document a specific mechanism:
“IRCoT uses chain-of-thought to guide the retrieval process and refines the CoT with the obtained retrieval results.”
(Retrieval-Augmented Generation for Large Language Models: A Survey)
Pause for a second on this passage, because it’s worth its weight in gold. The chain of reasoning guides the retrieval — and the retrieval results refine the chain of reasoning. It’s a loop. At each step of the reasoning, the system launches a micro-search to find the source that supports that specific step.
Translated to your case: if your guide has 6 numbered steps, each step is a potential retrieval query. The system reaches step 3 of its reasoning, looks for a source that answers that step, and if your Step 3 answers exactly that question, it extracts it. Multiply this by each step and you understand why a step-by-step guide has 5 or 6 chances of being cited where a discursive article has only one.
The title promises a sequence, the body delivers an essay.
The anatomy of a step the model can use
Numbering the paragraphs isn’t enough. I’ve tested dozens of guides across multiple AI engines, rephrasing the same query in different ways, and the pattern that emerges is fairly clear: the steps that get extracted and cited almost word for word share three characteristics.
A precise action verb at the start. “Verify”, “configure”, “implement”, “analyze” — not “you could consider” or “it would be useful to evaluate”. The model’s reasoning proceeds through concrete actions, and it maps better onto instructions that have the same imperative structure. “Step 2: Implement Organization schema on your site” enters the reasoning. “Step 2: Consider the opportunity of adding some structured data” does not.
The why of the step, not just the what. Every step that gets extracted frequently contains an explicit rationale. “Step 3: Add a TL;DR paragraph at the top of the page — retrieval systems favor self-contained summary blocks in the first 150 tokens” is a self-contained chunk. The model can cite it without having to retrieve additional context. “Step 3: Add a TL;DR” without an explanation is an orphan instruction — the system doesn’t know why it maps onto that point in the reasoning, and discards it.
If you want to dig deeper into how the TL;DR works in this context, I covered it in the article on the TL;DR paragraph.
An expected outcome at the end of the step. “Outcome: your business profile becomes verifiable by AI engines through independent sources” closes the logical loop of the step. Chain-of-Thought works through checkpoints — each step has to produce an output that the model uses as the input for the next step. If your step doesn’t state the outcome, the model has to infer it on its own, and this lowers the probability that that chunk gets preferred.
“Step 3: Add a TL;DR paragraph at the top of the page — retrieval systems favor self-contained summary blocks in the first 150 tokens” is a self-contained chunk.
The mistake I see in almost every guide I analyze
Most guides online have a structure that looks step-by-step but isn’t. Title: “How to do X in 5 steps”. Then you open it and find five discursive paragraphs of 200 words each, with no numbers in the text, no action verbs, no expected outcomes. The title promises a sequence, the body delivers an essay.
The AI model sees the same thing. The title suggests it will find sequential steps. It enters the content and finds prose. At that point it has two options: laboriously extract the logical sequence from the discursive text, or move on to the next source that has the steps already prepared. Guess which one it picks.
The other frequent mistake is mixing procedural steps and contextualization in the same block. “Before configuring the markup, it’s important to understand that traditional search engines use a different approach compared to AI engines, and this has implications for the…” — by this point the model has already lost the thread of the sequence. Context goes before or after the sequence, never inside it.
Partial conclusions and HowTo Schema: two accelerators
Two elements that very few people include in guides and that have a measurable impact on visibility.
The first is partial conclusions. After every 2-3 steps, a sentence that summarizes the state: “At this point your site is readable by AI crawlers and has the basic structured data — you’re ready for the distribution phase.” It’s not a summary for the human reader. It’s a checkpoint for the model, which in its Chain-of-Thought naturally produces these intermediate states. If you offer them already prepared, it doesn’t have to build them on its own.
The second is HowTo Schema as structured markup. The markup doesn’t appear in generative AI answers the same way Google’s rich snippets do, but it provides an explicit semantic signal that tells the crawler: “this content is a procedure, these are the steps, this is the final result.” It’s an additional layer that reinforces what the structure of the text already communicates — and in my tests on samples of procedural queries, pages with HowTo Schema implemented correctly appeared with greater frequency in AI engine answers compared to equivalent pages without markup.
Put your guides to the test today
Take the three most important procedural guides on your site — the ones that answer the “how to” questions in your field — and run them through this check. It’s not a complete audit, but it gives you a clear direction on how much you’re leaving on the table.
For each guide, verify:
- Are the steps numbered in the text, not just in the headings?
- Does each step start with a transitive action verb?
- Is the why of each step explicit?
- Is there an expected outcome at the end of each step?
- Are there partial conclusions every 2-3 steps?
- Are the initial prerequisite and the final result stated?
- Is HowTo Schema implemented in the markup?
If three or more answers are no, your guides are probably losing visibility in procedural AI answers. The model reads them, doesn’t find the structure it’s looking for, and moves on to the next source. For a precise diagnosis you need a structured analysis — these checks are a starting point for understanding where to intervene.
The step-by-step how-to pattern connects directly to the other answer patterns that AI uses for different types of queries: the comparative pattern for “what’s the difference” questions, the ordered list pattern for “which are the best” questions, and the expanded FAQ pattern for blunt questions. Each format intercepts a different type of model reasoning — and the more formats you cover, the more queries you manage to intercept.
