What a chunk actually is, and how retrievers split your page

What a chunk actually is when an AI reads your page

A chunk is a self-contained slice of your page that an AI system stores and retrieves on its own, separate from everything else you wrote. You published one page.

The AI kept twenty pieces of it, each indexed and searchable as its own little document.

Say you have a support page with an FAQ. One of the answers reads: "Refunds are processed within 5 business days to your original payment method."

That single answer can become one chunk. It gets stored, ranked, and later pulled into an answer completely apart from the paragraphs above and below it.

The AI does not treat your page as a document. It treats it as a bag of quotable units.

Your headings, your intro, your carefully sequenced argument, all of it gets sliced into passages that stand alone in storage.

That is the gap most people miss. You think of your page as one thing with a beginning, middle, and end. The retriever thinks of it as, say, six passages that happen to share a URL. When someone asks ChatGPT or Perplexity a question, the system does not go read your whole page. It finds the one or two chunks that best match the question and quotes those.

Why quote a chunk instead of the full page? Two reasons, both practical.

A chunk is small enough to fit alongside dozens of other candidates in the model's working memory, so the system can compare many sources at once. And a chunk that already answers the question needs no editing, so it gets lifted almost word for word. That is why the paragraph that directly answers survives, and the setup intro that builds toward the answer usually gets skipped.

The practical takeaway for you is simple. Every passage on your page is auditioning as a standalone answer. If a chunk only makes sense when you read the two paragraphs before it, the AI storing it in isolation loses that context, and your point gets mangled or ignored.

Why AI systems break your page apart instead of reading the whole thing

AI systems break your page apart because they can't afford to read the whole thing. A language model has a fixed context window, the amount of text it can hold in memory at once, and stuffing an entire page into that window costs tokens (the units models charge and compute by). So the retrieval step in front of the model does the opposite of reading: it pulls a handful of short passages that look most relevant to the question, and ignores everything else on the page.

That retrieval step doesn't match a question to your document. It matches the question to the single closest chunk. Each chunk gets stored as a vector, a numeric fingerprint of its meaning, and the question gets the same treatment. The system compares fingerprints and grabs the top few matches. Your page title, your careful intro, your internal links, none of it enters the comparison. Only the chunks do.

The practical consequence is blunt: the chunk competes for the citation, not the page. Two paragraphs from the same URL can score very differently. One answers the question in the first sentence and gets pulled. The one three paragraphs up, where you were building toward the point, never surfaces. Your page can be the best source on the topic and still lose the citation to a competitor whose relevant sentence happened to sit alone in a clean chunk.

Then there's query fan-out, which multiplies the problem. Systems like Gemini and Perplexity often break one question into several sub-queries, each aimed at a different angle, and run retrieval on each. A question like "is chunking worth optimizing for" might fan out into "what is a chunk," "how do retrievers split pages," and "does chunk structure affect citations." Each sub-query goes hunting for its own closest chunk, sometimes across several sites.

Your page might win one sub-query and get shut out of the other two. That's why a single page needs multiple self-contained passages, not one long argument that only makes sense read top to bottom.

How a retriever decides where one chunk ends and the next begins

A retriever picks a boundary based on one of four rules: token count, sentence breaks, structural markers, or meaning. Most live AI systems use a mix, but each method draws the line differently, and where it lands decides whether your answer survives intact or gets cut off halfway.

Fixed-size splitting is the blunt one. The retriever counts tokens (roughly 4 characters each) and cuts at a set number, say 512 tokens, no matter what word it lands on. It is fast and predictable, which is why developers reach for it first. The cost is obvious the moment you watch it work: it will slice a sentence in two, leaving "the recommended dose is" in one chunk and "500 mg twice daily" in the next. Neither piece answers the question on its own.

Sentence splitting fixes the mid-word problem by breaking only at periods. Each chunk is one or more complete sentences, so nothing gets truncated. The limit shows up with long, winding sentences and with ideas that need two or three sentences to make sense. Split them apart and each fragment reads fine but says nothing useful.

Recursive splitting is the workhorse for real pages. It tries the biggest natural break first (a double line break between paragraphs), and only if a piece is still too large does it fall back to sentence breaks, then to raw characters. The result respects your paragraph and heading structure most of the time. Write in tidy, self-contained paragraphs and recursive splitting rewards you. Write one 600-word block and it has nothing to break on except mid-thought.

Semantic and heading-based splitting group text by what it means. Heading-based splitting treats every H2 or H3 as a hard boundary, so each section becomes its own chunk. Semantic splitting goes further, comparing sentences and cutting where the topic shifts, even without a heading. This is the method most likely to keep a full answer together, because it is looking for meaning, not counting characters.

Two settings shape all of this: chunk size and overlap.

Chunk size is the target length of each piece, usually measured in tokens. Small chunks (around 200 tokens) are precise but can lose context. Large chunks (800+ tokens) hold more context but dilute the answer with surrounding filler. Most retrievers settle somewhere in the 256 to 512 token range as a compromise.

Overlap means each chunk repeats the last slice of the one before it, often 10 to 20 percent. Overlap exists to patch the damage from splitting. When a boundary lands in an awkward spot, the repeated text at the seam gives the retriever a second chance to keep a key sentence attached to the context it needs. It does not fix a buried answer or a wall of text. It only softens clean cuts that happen to fall in the wrong place.

Watch one page become six chunks

Here's a real-style page. It's a support article titled "How to reset your API key." It has an intro paragraph, three headings, several body paragraphs, and a numbered list. Watch it split.

The raw page reads like this:

• Intro: "Keeping your credentials secure matters more than ever. Our platform gives you full control over your API access, and rotating your keys is one of the simplest habits you can build into your security routine."
• Heading: When to reset your key
• Body: "Reset your key if it was exposed in a public repo, shared over email, or if an employee with access leaves. We recommend a scheduled rotation every 90 days regardless."
• Heading: How to reset your key
• Body: "You can reset from the dashboard in under a minute. The old key stops working immediately, so update your integrations first."
• List: 1. Go to Settings, then API. 2. Click Revoke next to the active key. 3. Click Generate new key. 4. Copy the key and store it in your secrets manager. 5. Update every service that calls the API.
• Heading: What happens to old requests
• Body: "Requests using the revoked key return a 401 error. There's no grace period. Test in staging before you rotate in production."

Under a heading-based split, the retriever cuts at each heading boundary. That page becomes six clean chunks.

The intro is the loser here. Pulled out of context, it's filler. That's the pattern: answer-first paragraphs get pulled, setup intros get skipped.

Same page, fixed-size split, and everything changes. A fixed-size splitter ignores your headings entirely. It counts tokens and cuts wherever the count lands, mid-sentence if it has to. On this page, a fixed-size cut might land right after "Click Generate new key." Steps 1 through 3 sit in one chunk. Steps 4 and 5 fall into the next chunk, glued to the start of the "What happens to old requests" section. Two unrelated ideas share a chunk. The reset steps got severed from their own list.

The lesson from the split is direct. Under heading-based splitting, this page produces boundaries that mostly match its ideas. Under fixed-size splitting, the same page fragments at arbitrary points. You don't get to pick which method a given AI system uses. What you control is whether your ideas sit inside clear boundaries, so that even a blunt token cut has a hard time slicing one idea in half.

Why the answer-first paragraph gets pulled and the setup intro gets skipped

A retriever pulls the chunk that answers the question, not the one that leads up to it. That is the whole mechanism.

When someone asks ChatGPT or Perplexity a question, the system converts that question into a vector (a numerical fingerprint of its meaning) and looks for the chunk whose fingerprint sits closest to it. A paragraph that states the answer directly reads, in that math, as a near match. A paragraph that describes why the topic matters reads as a distant one.

This is why a tight, self-contained answer of 40 to 60 words wins. It behaves as a clean, quotable unit. The system can lift it whole, drop it into a response, and cite it without needing the sentence before or after.

Narrative intros lose because they answer a question nobody asked. "The way brands show up in AI answers has changed a lot in the past year" scores well against questions about change over time, and poorly against the actual query, which was probably "how do I get cited in AI answers." The intro is meaning-adjacent, not meaning-matched.

Burying the answer costs you the citation outright. Say your real answer sits in paragraph four, after a setup, a caveat, and a bit of backstory. A competitor states the same answer in their first paragraph. Both pages contain the correct information. The retriever ranks the competitor's chunk higher because it matches the question more directly, and their paragraph gets quoted while yours gets skipped. Same facts, different placement, and only one of you shows up in the answer.

The order of your writing is the order the retriever reads your value. Lead with the claim, then earn it with the supporting detail underneath.

What happens when a chunk cuts your idea in half

A split idea is an uncitable idea. When a retriever cuts your content at the wrong spot, the AI gets two half-thoughts instead of one complete answer, and neither half is quotable on its own. That is the single most common reason a page that reads perfectly to a human never shows up in a ChatGPT or Perplexity answer.

Here are the four ways context gets split, and what each one costs you.

A definition split across two chunks. You write "A chunk is the unit of text a retrieval system pulls into an answer" in one chunk, and "because it fits inside the model's context window" in the next. Neither chunk carries the full definition.

Pronouns that point back to a chunk that got left behind. Write "This cuts your citation rate in half" and the retriever grabs that sentence without the paragraph above it. Now "this" refers to nothing. Words like it, they, that approach, and the above are all landmines.

Data or steps separated from their heading. Your "Pricing" heading sits in one chunk. The actual numbers land in the next chunk with no label. The retriever pulls a bare list of figures with no clue what they measure.

Walls of text that guarantee a mid-idea cut. A 400-word paragraph with no subheading, no list, and no natural break gives the retriever no clean boundary to cut on. So it cuts by token count instead, usually right through the middle of your best sentence.

You can spot the risk before an AI ever reads the page. Scan for any sentence that opens with this, it, or that and points to a previous paragraph. Look for numbers or steps that would be meaningless without the heading three lines up. Find your longest paragraph and ask where a token-based split would land inside it.

Structuring a page so every chunk stands on its own

A page chunks cleanly when each section can be lifted out and still make sense with no surrounding context. Here is the actual procedure, in order.

1. Write a descriptive heading that labels the answer below it. A heading like "Cost of a Shopify migration" tells the retriever what the chunk contains before it reads a word. A heading like "Let's talk money" tells it nothing.
2. Put one idea in each paragraph, and keep answer paragraphs to 40-60 words. That length holds a complete answer without spilling into a second idea a splitter might cut in half.
3. Lead with the answer, then add the detail. The first sentence should state the conclusion outright. AI systems pull the chunk that answers the question, not the intro that builds up to it.
4. Give each list item and table row a complete thought. "Set the crawl budget" is not liftable. "Set the crawl budget to 10,000 URLs per day so Googlebot reaches deep pages within a week" survives on its own.
5. Repeat the subject instead of leaning on pronouns. When a new paragraph starts with "It handles this automatically," and the noun sat two paragraphs back, the retriever that split them has no idea what "it" is. Name the subject again.
6. Add schema markup that names what the chunk is about. Marking a FAQ block with FAQPage schema, or a how-to with HowTo, tells the system the chunk's type and boundaries. Run it through the Schema Markup Validator before you publish. CiteTrack's free Schema Markup Generator shows what complete schema should look like, and the free AI Crawlability Checker confirms GPTBot and ClaudeBot can actually reach the page.

None of these moves fights how retrievers split text. They match it. A heading-based splitter breaks at your headings, so make the headings honest. A sentence or recursive splitter respects paragraph edges, so keep one idea per edge.

Before and after: a page rewritten to chunk cleanly

Take a real support page that answers "how long does a refund take" but buries it.

Before: a heading reading "Our commitment to you" sits above three paragraphs about customer values, then a paragraph about payment processors, and finally, in sentence four of paragraph three, the actual number: refunds land in 5 to 7 business days.

A retriever splitting that page by heading grabs one chunk titled "Our commitment to you." That chunk opens with brand language, not the refund window. When someone asks an AI system how long a refund takes, this chunk scores low, because the first 50 words never mention refunds or a timeline.

After: the heading becomes "How long does a refund take?" The first paragraph answers it directly: Refunds take 5 to 7 business days after we approve your return. The delay is on your bank's side, not ours, since card networks post credits on their own schedule. Contact us if it has been longer than 10 days. That is 42 words. The values and payment-processor detail move below, as supporting context.

One more move helps the machine agree with your intent: mark the page up as an FAQ or QAPage so the question and answer are labeled in the code, not just visually.

Do ChatGPT, Gemini, Google AI Mode, and Perplexity split your page the same way

No, and that's the part most guides skip. The splitting mechanics are similar, but what each system pulls from your chunks differs enough that optimizing for one alone leaves citations on the table.

ChatGPT rewards prose clarity and source reputation. It pulls chunks that read as complete, confident statements, and it weighs where the claim comes from.

Gemini and Google AI Mode lean harder on structured data and step-based content, especially for follow-up queries.

Perplexity favors tight, quotable facts it can cite almost verbatim. A crisp 40-to-60-word claim beats a paragraph it has to summarize.

Notice the overlap. Every column rewards a chunk that stands on its own and states its point plainly. Write once for clean chunks and you're readable everywhere, rather than tuning a page to game a single engine and watching it flop on the rest.

Common writing habits that make your content uncitable

Five writing habits quietly keep your content out of AI answers. Each one breaks chunking in a different way, and each has a fix you can apply in one pass.

Walls of text with no internal breaks. When you write eight sentences with no heading, list, or paragraph break, a retriever has no natural place to cut. Fix it by breaking every idea into its own short paragraph, and use a list when you have three or more parallel items.

Answers buried under setup and caveats. If your actual answer is the fourth sentence, the chunk that gets pulled is the setup, not the payoff. State the answer in the first 40 to 60 words, then add the caveats below it.

Headings that name a topic but not the answer. A heading like "Pricing" tells a retriever the subject but nothing about what you concluded. A heading like "Most tools charge $50 to $200 per month" carries the answer into the chunk boundary itself.

Context split across sections. When you define a term in one section and use it three sections later, the chunk containing the use has no idea what the term means. Define the concept in the same paragraph you first use it.

Pronouns that break when a chunk is read alone. "It handles this automatically" reads fine in the full page. Pulled out as a standalone chunk, "it" and "this" point to nothing. Name the subject in each paragraph instead of leaning on pronouns.

How to check whether your pages are chunking and getting cited well

Start with the free CiteTrack Chrome extension. It scores any page for SEO, AEO, and GEO readiness and generates a prioritized fix list showing which sections are structured for clean extraction and which are not.

Then test one page at a time with this rule: read each section on its own, out loud if you can, and ask whether it answers a real question without the sentences before it.

Run three checks in order:

• The standalone read. Cover everything except one section. Does that section still say something complete?
• The answer-first check. Does the section lead with a 40-60 word answer, then support it?
• The crawler-log check. Look at your server logs for user agents like GPTBot, Google-Extended, PerplexityBot, and ClaudeBot.

The gap most people hit: fetching is not citing. Your logs can show ChatGPT pulled a page while ChatGPT still cites a competitor for the same question. That is why you have to track citations separately. CiteTrack's citation tracking runs your prompts across five engines on a schedule and logs which pages get cited, mentioned, or skipped. Its crawler log analysis ties that back to what the AI systems fetched.

Frequently asked questions

Where to go from here

Every idea in this guide is a formatting decision, not a content rewrite. You are not changing what you say. You are changing where the answer sits so a retriever finds it before it finds your competitor's version. Start with one page: rewrite the heading as the question, move the answer to sentence one, and read every section on its own with the rest covered. If it makes sense alone, it chunks clean. If it doesn't, fix that section before touching anything else. Chunk size content optimization is the shorter practical version of this guide if you want the decision without the mechanics. The wider retrieval pipeline, of which chunking is one stage, is covered in how AI decides which products to cite, and how to write content ChatGPT will cite is the editorial playbook for the prose inside those chunks. The free Chrome extension and AI-Readiness Grader let you score any page for chunk-level citability right now.

Guides