A note on what this is: this article describes an independent, self-run experiment, not a peer-reviewed study. The linguistic and marketing claims that come from published research are cited below. The claims about the question matrix, the categorization results, and the saturation curve are my own findings, based on a dataset and pipeline I built myself. I've tried to flag clearly, section by section, which is which, and what a reader would need to reproduce each part.
Why This Started: Predicting the Next Logical Question
This project didn't start as a linguistics side-quest. It started because I wanted to build a tool that predicts the next logical question on any given topic — the specific question a reader would ask next that a topic's existing content hasn't answered yet. Some topics are already thoroughly covered; the interesting ones, for content strategy, are the ones with an obvious next question still sitting open.
Before building anything, I wanted to check whether this was actually worth pursuing as a GEO tactic, so I asked Google's AI Mode directly.
Me: If I have a blog on a topic, and I guess what people will ask next, and I answer it with actual numbers — what are the odds Google AI quotes me when someone asks that question?
Google AI Mode: You've got good instincts here. Giving a precise, numerically-backed answer to a question nobody else has answered yet is, right now, the single most valuable SEO move you can make.
That answer is what turned this from an idle idea into a project worth building. I want to be clear about what this exchange is and isn't: it's anecdotal, not evidence in itself — a single conversation with an AI system isn't a citable data point. But it matches the direction of the peer-reviewed GEO literature (below), and it's the reason I went looking for a systematic way to find a topic's unanswered questions, rather than treating the idea as settled.
Why This Matters for GEO?
The 2024 paper that coined the term "Generative Engine Optimization," by Aggarwal and colleagues at Princeton and IIT Delhi, showed that content style, structure, and — importantly — the presence of statistics and evidence can measurably change whether a generative engine cites a page in its answer (1). Later work on how generative engines select and absorb citations has continued to find that specific, well-evidenced answers tend to outperform generic ones. That published research is the independent backing for the instinct Google's AI Mode gave me above.
So the practical recipe I set out to build tooling for is:
- Take the most recent articles on a topic.
- Identify every possible Wh-question those articles touch on.
- Check which of those questions the articles already answer.
- Answer the ones that are still open, with specific numbers where possible. Step 2 is the hard one. LLMs can already do a version of this, so the natural question is: why not just ask one?
The Meta-Question Problem
To predict the next logical question for an arbitrary topic, I first had to solve a narrower problem underneath it — one I started calling the meta-question problem while I was working on it.
A concrete question like "How can I repair the wheel of a bus?" is really two things layered together: a topic (bus) and an abstract question shape (fix / how / indicative) that has nothing to do with buses at all. That same shape — fix / how / indicative — also generates "How can I repair a leaking faucet?" for plumbing, or "How can I repair a cracked phone screen?" for electronics. The shape is the meta-question; the topic is just a slot you fill in afterward.
That decoupling is the whole point. If the set of possible meta-questions is finite and can be enumerated in advance — independent of any specific topic — then generating candidate questions for a new topic stops being a creative or predictive task. It becomes mechanical: take the finite list of meta-questions, and for each one, slot in the topic. No guessing, and no risk of missing a category of question, provided the meta-question list itself is complete. The hard problem shifts entirely to building and validating that list — which is what the rest of this article is about.
Why Not Just Ask an LLM to Find the Missing Questions?
This is also the direct answer to a question people usually ask first: LLMs can already suggest "what someone might ask next" — so why not just use one instead of building a matrix?
● Once the meta-question problem is solved, question generation no longer needs a model that predicts likely questions at all — it needs one that enumerates possible ones. Those are different tasks. An LLM asked "what might someone ask next about buses?" is doing prediction: it's drawing on patterns of what people tend to ask, which leans toward what's emotionally salient — curiosity, worry, reassurance-seeking — rather than toward logical coverage of the topic's structure. A finite, pre-built matrix of meta-questions doesn't predict; it enumerates every fix/how/indicative-style shape and fills in "bus" mechanically. That's what makes it possible to check a topic for gaps systematically, rather than getting a plausible-sounding but incomplete list back from a model each time.
● It also meant I could build a lightweight, low-cost first version. Because slot-filling a known meta-question into a topic is mechanical, Python's NLP tooling was enough for an MVP — with one trade-off: the MVP only works on English text.
Both of these design choices are mine, not settled facts — a different implementation could route slot-filling through an LLM too, and the argument above doesn't depend on never using one. The point is narrower: enumerating which questions are possible for a topic doesn't require one, once the meta-question list is fixed.
Building the Meta-Question Matrix: The Linguistic Core
The starting idea, then: if I could enumerate every meta-question, filling in an actual topic afterward would be comparatively easy, as shown above. The question was how to enumerate the shapes.
Two things are true of every Wh-question in English: it contains a question word (what, why, where, who, when, how, which, whom, whose), and it contains a verb. Crossing those two dimensions gives a matrix — but a matrix built from individual verbs would be enormous. It only becomes usable if you build it from verb categories broad enough that any specific verb slots into one of them.
This is where I leaned on a rule of thumb familiar from primary-school grammar: verbs broadly do, be, or happen. I treated this as a first-pass, three-way top-level split and worked down into subcategories: do-type verbs such as make, execute, fix, move; be-type verbs such as define, qualify, compare; and happen. (This first-pass list turned out to be incomplete — see the note in the next section on the gap I found once I started categorizing real questions.) I want to flag directly what this is and isn't: it's a simplified, working taxonomy I built for this project, not a citation from the linguistics literature. The two closest published frameworks are Vendler's four aspectual verb classes — states, activities, accomplishments, and achievements, distinguished by how a verb behaves in time — and Levin's much larger classification of English verbs by their syntactic alternation patterns (2, 3). Neither maps cleanly onto a do/be/happen split; they're organized around aspect and syntax, not around the kind of coarse semantic grouping I needed for a question matrix. I'm citing them here because they're the established reference points for "verbs can be systematically categorized" — not because my three-way split is drawn from either of them.
Crossing the do/be/happen categories with the nine Wh-question words gives the matrix below (shown in simplified form — the do and be rows expand further into their subcategories):
- The table above shows the matrix in its corrected, near-final form, including "have" as a do-type subcategory. As described in the next section, "have" wasn't in my original list — it was added only after real data exposed the gap.
Verbs have a third relevant dimension: mood — indicative, conditional, imperative. Adding that as a third axis turns the matrix into a 3D grid of question types. Which raises the real question behind this whole exercise: does every real-world question people actually ask fall somewhere inside this grid? And does the grid produce false positives — cells that don't correspond to anything a real person would ask? Showing that the matrix captures real questions, without gaps or obvious dead cells, is what the rest of this article is about.
Testing the Matrix: Building a Real-Question Dataset
What I tested: whether real, naturally occurring English questions consistently fall inside the 3D matrix described above, or whether people ask things the matrix can't represent.
To test that, I needed a large set of real questions with real answers — not questions I invented to fit my own framework. I built a small Python and Streamlit tool that used the Exa.com search API to find and scrape FAQ-style question-and-answer content from American websites. That process produced a dataset of roughly 17,400 question-answer pairs.
What a reader can verify: the Exa API is a public, commercially available search product, and the method — searching for FAQ pages on a topic and extracting Q&A pairs — is straightforward to reproduce with the same or a comparable search API. I haven't published the raw dataset or the collection script alongside this article; if there's interest, I'm glad to share more detail on the collection pipeline in a follow-up. Readers should treat the 17,400-pair figure as a description of my own dataset, not as a benchmark anyone else can currently pull down and re-run against.
It's also worth being upfront about the dataset's limits: it draws only on English-language FAQ content from U.S. sites surfaced by one search API, so it's skewed toward however Exa's index and ranking favor certain topics and site types. A different search API, a different country's web, or non-FAQ question sources (forums, support tickets, search-query logs) could turn up question shapes this dataset doesn't contain. I don't think that undermines the core test — the matrix still needs to explain whatever real questions you throw at it — but it does mean "17,400 questions" describes one particular slice of the English web, not English questions in general.
Categorizing the Questions and Testing for Saturation
What I tested: whether the do/be/happen × Wh-word × mood matrix is comprehensive enough to hold a large, independently collected set of real questions — that is, whether new question categories kept appearing as I added more data, or whether the categories stabilized.
To categorize the 17,400 pairs, I wrote a second Python script that used the Claude API to assign each question to a cell in the matrix. Before automating the full run, I categorized the first 100 real questions by hand as a sanity check on the matrix itself — and that's where I found a gap. A cluster of questions built around "have" — things like "What documents do I have to bring to a car inspection?" — didn't fit anywhere. My original do-type list (make, execute, fix, move) simply didn't include a "have" bucket. I added "have" as its own do-type subcategory and re-ran the check before moving on to the full dataset.
I'm including this because it's a concrete, checkable example of the framework being corrected by real data, rather than the reverse. It's also a useful caveat for the saturation analysis below: it means the matrix that reached saturation on 800–900 questions is the corrected one, not my first draft — the first-100 gap is exactly the kind of thing a larger, unexamined sample could still be hiding elsewhere in the do or be branches.
I want to flag a further methodological limitation here directly: the categorization was done by a single LLM pass, and I have not yet run a human-coded validation sample to check inter-rater agreement against the model's labels. That's a standard check in qualitative coding work, and it's on my list for a follow-up — until it's done, the categorization results below should be read as a strong first pass rather than a validated coding scheme.
With the categorized data in hand, I ran a saturation analysis. The concept comes from qualitative research methodology: theoretical saturation is the point in a coding process where reviewing more data stops producing new categories (4). The most-cited empirical benchmark for what saturation looks like in practice is Guest, Bunce, and Johnson's study of 60 interviews, which found that the great majority of thematic codes appeared within the first dozen or so interviews, after which new codes became rare (5). I'm borrowing that logic here and applying it to question categories instead of interview themes: if, after a pilot sample of 800–900 questions, every cell in the matrix already contains at least one real question and no new categories are appearing, that's evidence the matrix is comprehensive enough to be trusted on the rest of the dataset.
That's what the pilot sample showed: once the sample passed roughly 800–900 questions, the rate of new-category discovery flattened, and no cells remained empty. The chart below is my own plot of that curve — new categories discovered on the y-axis, cumulative questions reviewed on the x-axis.
One caveat worth restating: saturation on a pilot sample from this dataset shows the matrix is comprehensive for this collection of American FAQ questions. It's a reasonable basis for expecting the rest of the 17,400 pairs to fit the same matrix — that's the standard inference saturation analysis licenses — but it isn't a proof that no English question could ever fall outside the grid, and it hasn't been tested yet against non-FAQ question sources or non-U.S. English.
What This Actually Shows?
Taken together, the test supports two claims, at two different confidence levels:
● Empirical claim: for the dataset tested, real Wh-questions consistently mapped onto cells in the do/be/happen × Wh-word × mood matrix, and the categorization stabilized well before the full dataset was reviewed. This is the part backed directly by the experiment above, with the caveats already noted (single-pass LLM coding, one search API, U.S. English FAQ content).
● Working hypothesis: that a comprehensive Wh-question matrix, applied to any piece of English text, can be used to enumerate every logically possible question that text hasn't yet answered — and that answering those gaps with specific numbers is a viable GEO tactic. This follows from combining the matrix result above with the published GEO research cited earlier; it's the connective argument of the article rather than something the experiment tested directly.
It leaves one problem unsolved. A real topic can generate dozens of theoretically valid unanswered questions — for example, for a used-car dealership, the where/move/indicative cell might expand into "Where can you take the car for a test drive?" With 50 or more valid candidates, which question should actually be asked, and answered, next?
What's Next: Picking the Question That Matters Most?
That's the problem I'm working on now — ranking the theoretically valid questions a matrix like this generates, so that the next piece of content answers the one question most likely to matter. That's a separate build, and a separate post. Let me know if it's something you'd want to read.
References
- Aggarwal, P., Murahari, V., Rajpurohit, T., Kalyan, A., Narasimhan, K., & Deshpande, A. (2024). GEO: Generative Engine Optimization. In Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining (KDD '24), 5–16. https://doi.org/10.1145/3637528.3671900
- Vendler, Z. (1957). Verbs and times. The Philosophical Review, 66(2), 143–160.
- Levin, B. (1993). English Verb Classes and Alternations: A Preliminary Investigation. University of Chicago Press.
- Glaser, B. G., & Strauss, A. L. (1967). The Discovery of Grounded Theory: Strategies for Qualitative Research. Aldine Publishing Co.
- Guest, G., Bunce, A., & Johnson, L. (2006). How many interviews are enough? An experiment with data saturation and variability. Field Methods, 18(1), 59–82.
Top comments (0)