Answer-first writing: measured positions

"Answer-first" is easy to say and hard to check. It usually means: put the answer in the first sentence or two after a heading, then explain. That description is a style opinion until someone measures it. This article measures it — not across the web, and not across the 30-site study, which never recorded paragraph positions, but across the pages where the measurement was actually taken: this blog, on 2026-10-26.

The result is a small, reproducible number, and the method matters more than the number. Both are below.

What "position" means here

The scanner's rule is answer-first, worth 3 points. It looks at the first 30 heading-then-paragraph pairs in the page: an H2 or H3, optionally some wrapper elements, then a paragraph. At least 60% of those opening paragraphs must be 80 words or fewer. Fewer than three pairs fails the check; three or more with a lower ratio is a partial pass worth 1 of the 3 points.

Two words in that description do the work. "Opening" means the first paragraph after the heading, not the best paragraph in the section. "Position" means where the answer sits relative to the heading, not how good the answer is. The rule cannot tell whether the first paragraph actually answers the heading; it can only tell whether the answer arrives early enough to be cut cleanly.

The measurement, and its scope

On 2026-10-26 I fetched the 16 English blog articles on this site, extracted their H2/H3 headings and the first paragraph after each, and counted words. The method is a regex approximation of the rule, not the scanner itself: it reads the rendered HTML, strips tags, and treats whitespace-separated tokens as words. It does not allow wrapper elements, and it only counts a heading if a paragraph follows before the next heading. That makes it a slightly stricter, simpler version of the check.

A few individual pages, to show the shape rather than the average:

What the numbers do and do not show

They show that the pattern is measurable and that it is achievable in ordinary prose: 91 of 101 opening paragraphs are under the threshold, and every page in the set clears the scanner's ratio. They do not show that the pages are well written, that the openers answer their headings, or that any engine cites them. They are also not an independent sample: these are pages written after the rule was known, which is precisely the bias a study of other sites would avoid.

The honest reading is narrower. A page can be checked for where its answers sit, the check can be run in seconds, and the failure mode is visible without an engine's help. That is enough to justify doing it before a rewrite.

How to measure your own pages

The script below is the one used here, in its simplest form. It is deliberately crude: it counts words by splitting on spaces, which is fine for English and wrong for Japanese or Chinese, and it does not handle wrapper elements. Treat it as a first pass, then read the pages it flags.

// node measure.mjs
const urls = [/* your article URLs */];
for (const url of urls) {
  const html = await (await fetch(url)).text();
  const article = html.match(/<article[\s\S]*?<\/article>/)?.[0] ?? html;
  const headings = [...article.matchAll(/<h[23][^>]*>([\s\S]*?)<\/h[23]>/gi)];
  let pairs = 0, short = 0, questions = 0;
  for (let i = 0; i < headings.length; i++) {
    const text = headings[i][1].replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
    if (/\?$/.test(text) || /^(how|what|why|which|when|who|where|is|are|do|does|can|should|will)\b/i.test(text)) questions++;
    const next = headings[i + 1]?.index ?? article.length;
    const region = article.slice(headings[i].index + headings[i][0].length, next);
    const firstP = region.match(/<p[^>]*>([\s\S]*?)<\/p>/i);
    if (!firstP) continue;
    pairs++;
    const words = firstP[1].replace(/<[^>]+>/g, " ").trim().split(/\s+/).filter(Boolean).length;
    if (words <= 80) short++;
  }
  console.log(url, { pairs, short, questions, ratio: pairs ? Math.round((short / pairs) * 100) : null });
}

Read the output as a floor, not a verdict. A page with a low ratio has a structural problem worth looking at; a page with a high ratio has passed a cheap check, not a quality review.

The writing pattern the numbers describe

The pages above were written to one pattern, and it is not complicated. The heading names the question or the claim. The first paragraph gives the answer in one or two sentences, without a run-up. The next paragraphs carry the qualification, the evidence and the exceptions. Lists and tables hold the enumerable details, because those are the structures a parser can lift.

The pattern fails in two predictable ways. The first is the long opening: three sentences of context before the answer, which produces a passage that either includes the run-up or starts mid-thought. The second is the missing paragraph: a heading followed directly by a list or a table contributes no pair at all, so a page built entirely that way can fail on pair count even though it is well structured. The rule's arithmetic is unforgiving about both.

What the scanner scores

answer-first is 3 points; qa-headings is 4 points and counts headings that end in a question mark or start with one of fourteen question words. They measure different halves of the same idea: that the page makes its questions and answers explicit. Neither measures whether the answer is correct or whether the page is worth citing.

The measurement in this article is the bridge between the two: it shows what the numbers look like on real pages, and it makes the claim checkable rather than rhetorical.