How to Audit Your Page Chunks for AI Search Retrievability

Most under-citing pages in mid-2026 are not under-citing for content reasons. They are under-citing because their chunks do not segment cleanly into the ~600–900 character passages the substrate retrieves at. The playbook below assumes the content quality is solved and focuses on the structural rewrites that convert page-level citations into passage-level wins. Most programs see the first measurable lift at week 5–7 — faster than any other AI-search optimization lever.

10 steps for auditing and rewriting your page chunks

1. Step 1: Lock the priority page set the chunk audit will cover

   The audit is a function of the pages it has to cover. The right input is the 40–120 priority pages the rest of the AI-search stack scores against — the same set the visibility dashboard tracks, the brand entity graph audits, and the rationale snippet audit reads. Adding a second page set for chunk-level work splits the writer's attention and lets the two sets drift apart; one set, scored across page, chunk, and image surfaces, is the discipline that compounds. Re-anchor the set quarterly with the rest of the stack — never per-audit.

2. Step 2: Build the chunk audit table

   Seven required columns: page slug, chunk index (0..n), char count, heading-bounded? (Y/N), self-anchoring opening? (Y/N), one claim? (Y/N), cited? (engine + ISO week). Optional but high-leverage: entity density per 100 characters (named entities — brand names, product names, numbers, dates), and the chunk's heading-bounded-sibling-cited proximity. The table is the chunk-level analog of the rationale snippet audit and the multimodal capture table; one row per chunk, one chunk per heading-bounded section, every priority page covered.

3. Step 3: Segment each priority page the way the engine does

   Engines segment pages on a five-signal priority order: h2/h3 heading boundaries first, paragraph breaks second, list boundaries third, semantic stop points fourth, hard ~900–1,100 character cap last. Walk every priority page top-to-bottom and number each chunk by the boundary the substrate would land on. Pages with consistent h2/h3 cadence every ~600–900 characters run 8–14 clean chunks; pages with one h2 followed by a wall of prose run 3–4 oversized sections the substrate then splits arbitrarily. The segmentation walk is the table's first row pass.

4. Step 4: Score chunk size against the 600–900 character window

   Count the characters in each chunk verbatim. Anything under 400 flags as a low-context fragment the substrate down-weights; anything over 1,000 flags as a chunk the substrate forces a mid-paragraph split on. Most under-citing pages either run 120-character bullet fragments (too short — group bullets into clusters of 4 with an introductory sentence per cluster) or 1,500-character paragraph walls (too long — break into three paragraphs separated by an h3). The fix shape is mechanical and consistent across the priority set.

5. Step 5: Score every chunk on heading-bounded?

   A chunk is heading-bounded if it starts within one sentence of an h2 or h3 and ends before the next h2 or h3 begins. Pages whose chunks all pass heading-bounded retrieve at materially higher rates than pages with chunks split mid-section by the substrate. The fix on a failing chunk is to insert an h3 at the semantic shift point — most wall-of-prose chunks have an obvious shift point a writer can spot in one pass. The h3 splits the chunk cleanly and gives the substrate the right boundary.

6. Step 6: Rewrite chunk openings to self-anchor

   Every chunk's opening sentence should restate the page-level context the chunk operates inside — without it, the retrieved chunk arrives at the engine as a context-less fragment. 'The mid-2026 inline image carousel surfaces on roughly 35% of commercial queries on Perplexity' is self-anchoring; 'It surfaces on roughly 35% of those' is not. Self-anchoring chunks retrieve at 1.5–2.0× the rate of context-less chunks at the same chunk size. This is the single highest-leverage rewrite layer in the entire chunk audit — chunks that pass the structural properties but fail self-anchoring under-cite by a wide margin.

7. Step 7: Enforce one-claim-per-chunk discipline

   Each chunk should present one main claim, supported by one or two quantified or named-entity evidence sentences, and one synthesis sentence. Chunks that try to compare three competitors, present three pricing tiers, or list three different use cases inside a single 800-character paragraph under-cite by 0.5–0.7× because the substrate cannot attribute the retrieved passage to a single claim. The fix is to split into three separate heading-bounded chunks — one h3 per claim, one ~600–800 character chunk under each. The rewrite usually leaves the word count unchanged; only the structure changes.

8. Step 8: Verify closing-sentence finality on every chunk

   The last sentence in each chunk should land on a complete thought, not trail mid-paragraph into the next idea. Pages whose chunks always end on a finished thought retrieve materially better than pages whose paragraphs run continuously across heading boundaries. The fix is to add a closing synthesis sentence at the end of every heading-bounded section — one sentence that resolves the chunk's claim and leaves no dangling thread. The synthesis sentence also doubles as the rationale snippet the rationale audit reads against, so the two audit programs reinforce each other.

9. Step 9: Read the citation URL text fragments to find the cited chunk

   Google AI Mode, Microsoft Copilot, and ~80% of Perplexity citations append a #:~:text= fragment to the cited URL that highlights the exact passage retrieved. Visit the citation URL with the fragment intact — the browser scrolls to and highlights the cited chunk. The chunk you see is the chunk the substrate retrieved; everything else on the page was indexed but did not win the retrieval for that query. The text fragment is the cleanest signal for the chunk audit table's 'cited?' column; it also surfaces the chunk-pattern clusters competitors are winning citations on.

10. Step 10: Run the six-week rewrite program against the worst-scoring chunks first

    Sort the chunk audit table by composite score (chunks failing heading-bounded + self-anchoring + one-claim are the highest-leverage rewrites) and rewrite from the top. Week 1: lock priority set + first audit. Week 2: rewrite top 10 highest-traffic pages into heading-bounded chunks. Week 3: rewrite chunk openings on the same 10 pages to self-anchor. Week 4: audit and rewrite the next 20. Week 5: first weekly retrieval capture. Week 6: first measurable lift (most programs see 20–35% increase in passage retrievals on rewritten pages, faster than the 8–11 week curve on full-page rewrites). Wider gain at week 10–14 once the next 40–60 pages are rewritten on the same discipline.

Why this matters in mid-2026

The retrieval substrate every major engine routes against indexes at the passage embedding level — one vector per ~600–900 character chunk, not one per URL — and roughly 84% of mid-2026 citations resolve to a single chunk inside a longer page. The implication is operational: a page can win the URL-level click and still lose the passage-level retrieval if the chunks inside that page do not segment cleanly. Brands rewriting existing chunks lift citation share 2–3 weeks ahead of brands publishing new URLs on the same content budget.

The chunk audit is the structural side of the same loop the passage-level optimization playbook sets up on the strategy side. Run together with the visibility dashboard for the priority page lock, the rationale snippet audit for the synthesis sentence that closes each chunk, and the brand entity graph audit for the entity layer the self-anchoring opening sentence relies on, the chunk audit is the structural rewrite that unlocks passage-level citation share on the page set you already own.

Sites that haven’t shipped a persona-locked visual library yet should ship one alongside the first chunk-rewrite batch — the carousel slot beside the retrieved chunk is the second-half citation surface, and the text chunk and image chunk both winning is what unlocks the full citation slot. The llms.txt implementation complements both — it maps the engines to the priority pages the chunk audit covers, accelerating the embedding refresh that propagates the rewrites.