The Experiment That Changed How I Think About Readability
Somewhere around late August 2025, I rewrote a pillar page on enterprise data governance. The original was sitting at a Flesch-Kincaid Grade Level of 14.2. Dense. Lots of passive voice, long subordinate clauses, the kind of prose that makes you feel like you're reading a procurement memo.
Conventional SEO wisdom at the time was clear: simplify. Shoot for Grade 8. Write like you're explaining things to a smart teenager. Use short sentences. Cut jargon. Readability tools flash red if you go above Grade 10, and half the SEO Twitter sphere treats a high reading level as a technical error on par with missing alt text.
So I simplified. Ruthlessly. I got the piece down to Grade 7.9. Shorter sentences. Active voice. Simpler vocabulary. The Hemingway App loved it. I felt confident.
Within five weeks, organic traffic to that URL dropped 23%. Position moved from an average of 4.1 to 6.8. CTR fell from 4.3% to 2.9%. The page that had been earning featured snippet real estate for "enterprise data governance framework" lost the snippet entirely to a competitor page written at Grade 12.
That was the moment I started questioning everything I thought I knew about readability and search performance.
What Flesch-Kincaid Actually Measures (And What It Doesn't)
Flesch-Kincaid Grade Level was developed in 1975, calibrated against a corpus of U.S. Navy training materials. The formula is mechanical: it looks at average sentence length and average syllable count per word. That's it. It has no awareness of:
- Domain-specific vocabulary that readers in a niche actually expect
- Whether a longer sentence is long because it's badly written or because the concept requires nuance
- The difference between passive voice used carelessly versus passive voice used deliberately for precision
- Context — the same piece of text reads differently to a CTO than to a first-year analyst
The Flesch Reading Ease score (the inverse version, where higher is easier) has the same problem. These are blunt instruments. They were never designed for SEO. They were never validated against search behavior. Applying them as ranking proxies is a category error, and the SEO industry has been making it for years without much pushback.
I want to be precise here: I'm not saying readability doesn't matter. I'm saying that a single numeric score, applied uniformly across all content types and all audiences, is a poor model for predicting search performance. The relationship between reading level and ranking is not linear. It's not even monotonic. It's deeply dependent on intent cluster, audience sophistication, and competitive context.
That framing is the foundation of everything I'm about to show you.
The Data: 47 Pages, Six Months, Surprising Deltas
Between October 2025 and late March 2026, I ran a structured experiment across 47 pages on three separate sites. The sites covered enterprise SaaS, personal finance, and B2B professional services. I deliberately kept the niche distribution uneven — 24 pages from SaaS, 14 from finance, 9 from professional services — because I wanted to see whether the patterns held across different audience types.
The methodology was not a randomized controlled trial. I want to be honest about that. SEO experiments almost never are. I used a staggered rollout: I rewrote reading level (and only reading level, leaving intent signals, internal linking structure, and schema untouched) on batches of four to six pages at a time, tracked performance in GSC and a third-party rank tracker over 30-day windows, and compared against a holdout set that I left unchanged.
Some pages I rewrote to simplify. Some I rewrote to increase complexity. A handful I tested in both directions, sequentially. The full dataset is in a private Notion workspace I'm not sharing publicly, but the aggregate findings are what matter here.
CTR and the Grade Level Mismatch
Here is something I did not expect: for pages in positions 3 through 8, simplifying reading level from above Grade 12 to Grade 8-9 produced measurable CTR increases in only 6 of 18 tested cases. In 9 cases, CTR was essentially flat (within margin of noise). In 3 cases, CTR declined.
The 3 cases where CTR declined were all in the enterprise SaaS cluster, targeting queries where the user intent was clearly expert-level research. Queries like "SOC 2 Type II audit preparation timeline" and "zero-trust architecture implementation phases." When I simplified the title and meta description to match the simpler body text, impressions stayed stable but CTR dropped. My hypothesis: searchers on those queries are pattern-matching for sophistication signals in the SERP. A dumbed-down snippet reads as a low-authority result to someone who already knows the domain.
This is a mechanism that the Grade 8 orthodoxy completely ignores.
Dwell Time Didn't Behave the Way I Expected
Dwell time — or more precisely, the signal Google infers from short returns to the SERP versus extended engagement — was the metric where I saw the most variance.
On the personal finance pages, simplification consistently helped. Pages on topics like "how to open a Roth IRA" and "what is a high-yield savings account" showed dwell improvements of 18–34% after moving from Grade 11 reading level to Grade 7. That's not surprising. Those queries attract users who are genuinely new to the concept. They don't want jargon. Simple language is a feature, not a concession.
But in the professional services cluster, the opposite happened. A page on "M&A due diligence checklist for mid-market transactions" that I simplified to Grade 8.3 saw dwell time fall 27% over a 30-day window. Users were landing on it, scanning, and leaving faster. The page felt too thin for their needs. Complexity, in that context, was a trust signal. Oversimplifying read as underqualified.
The finance pages split almost exactly down the middle. Consumer-facing queries: simpler won. Business-facing or compliance-adjacent queries: simpler hurt.
Position Delta Across Clusters
Position changes were the hardest to attribute cleanly, because so many other variables affect ranking over a 30-day window. But across the full 47-page set, the clearest pattern was this: pages where I increased reading level to match the complexity of the top-ranking competitors gained position more reliably than pages where I decreased reading level to hit a generic target.
Average position delta for pages where I increased reading level to competitive parity: +1.7 positions (gain).
Average position delta for pages where I decreased reading level to hit Grade 8-9: +0.3 positions (noise-level).
Average position delta for holdout pages: +0.4 positions (likely a rising tide from seasonal and authority effects).
The simplification group barely outperformed doing nothing. The complexity-matching group outperformed doing nothing by a factor of roughly four. That finding has fundamentally changed how I scope readability work in 2026.
Two Things I Believe That Most SEOs Won't Say Out Loud
I'm going to plant two flags here. Both will get pushback.
Contrarian Take 1: Grade 8 Is a Cargo Cult
The Grade 8 readability target spread through the SEO industry not because of empirical search performance data, but because it sounded reasonable and was easy to measure. It came from content marketing traditions (newspaper readability studies, general audience writing guides) that were never about search ranking. Someone cited it, other people repeated it, it ended up in content briefs across thousands of agencies, and now it's treated as settled science.
It is not settled science. There is no peer-reviewed study showing that Grade 8 reading level causes improved Google ranking. There is no leaked quality rater data establishing it as a ranking criterion. There is a lot of correlation-hunting that doesn't properly control for the fact that simpler content tends to target simpler (higher-volume, less competitive) queries, which naturally rank more easily for other reasons entirely.
I've read the [Google Search Central documentation on content quality] carefully. Reading level as a score is never mentioned. What is mentioned is usefulness, expertise, and meeting user needs. Those things correlate with appropriate reading level in context-dependent ways. They do not reduce to a single number.
Treating Grade 8 as a universal target is cargo cult SEO. We're performing a ritual because it looks like something that works, not because we've verified the mechanism.
Contrarian Take 2: Making Expert Content Simpler Can Destroy Its EEAT Signal
Google's EEAT framework (Experience, Expertise, Authoritativeness, Trustworthiness) has been central to quality assessment since the expanded definition rolled out in late 2022 and has been increasingly operationalized in the 2024-2026 algo cycles. One of the ways expertise signals manifest in content is through command of domain vocabulary.
When you strip that vocabulary out to hit a Flesch-Kincaid target, you may be simultaneously removing the linguistic markers that quality raters (and, by extension, the systems trained on their behavior) use to identify expert content.
I'm not saying to write jargon for jargon's sake. I'm saying that "immunocompromised patients with comorbid conditions" carries a different expertise signal than "people who are sick with more than one problem," and that difference is not irrelevant to ranking on medical queries. Same logic applies to legal content, financial content, technical documentation, and any YMYL-adjacent topic.
The industry underweights this. A lot. See also: [our deep dive on EEAT signals in technical content].
The Mistake I Made on the Finance Cluster
I need to own something here.
In November 2025, I applied simplification too aggressively to five pages in the personal finance cluster covering tax-loss harvesting and wash sale rules. My reasoning: these are consumer-facing topics, the target user is not a CPA, Grade 8 should work fine.
It did not work fine.
I overwrote precise, technically accurate language with simplified approximations. "Substantially identical securities" became "similar investments." "Disallowed loss" became "the loss you can't use." The resulting text was easier to read and substantially less accurate. Two finance editors flagged it in a review. One of the simplified explanations was technically wrong in a way that could have given a user a false impression about IRS rules.
I had to rewrite those five pages again, this time finding a middle path: clear sentences, accessible structure, but with the precise legal and tax vocabulary kept intact where it was doing necessary work. The final reading level landed around Grade 10-11, which is higher than my original simplification target but lower than the original drafts.
Performance after that second rewrite: three of the five pages recovered to near their pre-experiment positions. Two are still below baseline, which I attribute to a competitive shift in that SERP rather than the content change.
The lesson I took from this: reading level decisions have to be made at the vocabulary level, not just the sentence structure level. You can write long, complex sentences and be appropriate. You can write short sentences and be imprecise in ways that undermine both user trust and topical authority. See also: [the content accuracy framework we use for YMYL pages].
The DRIFT Framework for Readability Decisions
After running this experiment and making the mistakes above, I built a decision framework I now use every time someone brings up readability in a content brief. I call it DRIFT.
D — Domain Vocabulary Baseline. Before touching reading level, inventory the core vocabulary of the topic. What words do authoritative sources in this niche use? What do top-ranking competitors use? This is your floor. You do not simplify below it.
R — Reader Sophistication Profile. Who is actually landing on this page? Not who you wish was landing on it. Use GSC query data to infer intent and sophistication. "What is X" queries signal novice. "X vs Y for enterprise use case" queries signal practitioner. Match the register to the actual audience, not a hypothetical one.
I — Intent Cluster Mapping. Map the target query to an intent cluster: informational/novice, informational/practitioner, transactional, navigational, or investigational. Each cluster has a different readability sweet spot. Informational/novice: simplify freely. Investigational (the "I'm deep-researching a serious decision" cluster): do not simplify. Transactional: clarity matters more than grade level.
F — SERP Fingerprint. Open the top 10 results for your target query and run them through a readability scorer. What is the average reading level of pages in positions 1-3? That is your competitive context. If you're trying to rank in a SERP where every top result is at Grade 12, and you're bringing Grade 7, you may be signaling to both users and algorithms that your content is less thorough.
T — Trust Vocabulary Preservation. Identify any vocabulary that functions primarily as a trust signal in your domain: legal terms in legal content, clinical terms in medical content, financial terms in financial content. These stay. You can add plain-language explanations alongside them. You do not replace them.
DRIFT is not a formula. It doesn't produce a single target grade level. It produces a decision: which direction should I move this page's reading level, by how much, and what am I explicitly protecting? That's a more honest representation of what the decision actually involves. For more on how I integrate this into content briefs, see [our content strategy workflow documentation].
Python Tooling: How I Actually Score Pages Now
I stopped relying on single-metric readability tools somewhere around January 2026. The workflow I use now pulls five metrics simultaneously and looks at the pattern, not just Flesch-Kincaid. Here's the core of the scoring script.
First, install the dependency:
pip install textstat beautifulsoup4 requestsThen the main scorer:
import textstat
import requests
from bs4 import BeautifulSoup
def extract_body_text(url):
"""
Fetch a URL and extract visible body text,
stripping nav, footer, and aside elements.
"""
response = requests.get(url, timeout=10)
soup = BeautifulSoup(response.text, "html.parser")
for tag in soup(["nav", "footer", "aside", "header", "script", "style"]):
tag.decompose()
return soup.get_text(separator=" ", strip=True)
def score_readability(text):
"""
Return a dict of five readability metrics.
No single metric is treated as authoritative.
"""
return {
"flesch_kincaid_grade": round(textstat.flesch_kincaid_grade(text), 2),
"flesch_reading_ease": round(textstat.flesch_reading_ease(text), 2),
"gunning_fog": round(textstat.gunning_fog(text), 2),
"smog_index": round(textstat.smog_index(text), 2),
"coleman_liau": round(textstat.coleman_liau_index(text), 2),
"avg_sentence_length": round(textstat.avg_sentence_length(text), 2),
"syllable_count_per_word": round(
textstat.syllable_count(text) / max(textstat.lexicon_count(text), 1), 3
),
}
def compare_to_serp(target_url, competitor_urls):
"""
Score target page and competitors.
Return target scores and SERP average for each metric.
"""
target_text = extract_body_text(target_url)
target_scores = score_readability(target_text)
serp_scores = []
for url in competitor_urls:
try:
text = extract_body_text(url)
serp_scores.append(score_readability(text))
except Exception as e:
print(f"Failed to score {url}: {e}")
if not serp_scores:
return target_scores, {}
serp_averages = {
metric: round(
sum(s[metric] for s in serp_scores) / len(serp_scores), 2
)
for metric in serp_scores[0]
}
return target_scores, serp_averages
# Example usage
if __name__ == "__main__":
target = "https://example.com/enterprise-data-governance-framework"
competitors = [
"https://competitor-one.com/data-governance",
"https://competitor-two.com/governance-framework",
"https://competitor-three.com/enterprise-governance",
]
my_scores, serp_avg = compare_to_serp(target, competitors)
print("Target page scores:")
for k, v in my_scores.items():
print(f" {k}: {v}")
print("\nSERP average scores:")
for k, v in serp_avg.items():
delta = round(my_scores.get(k, 0) - v, 2)
direction = "above" if delta > 0 else "below"
print(f" {k}: {v} (target is {abs(delta)} {direction} SERP avg)")What this gives me is a gap analysis, not a target. If my FK grade is 8.1 and the SERP average is 12.4, that gap is a hypothesis: am I underperforming because I'm too simple, or is there another explanation? I don't assume reading level is causal. I treat a large gap as a prompt to investigate, not a to-do item to close automatically.
The Gunning Fog index is particularly useful because it penalizes complex words (three or more syllables) specifically, which maps more cleanly onto jargon density than Flesch-Kincaid does. SMOG is good for medical content because it was validated against health communication research. Coleman-Liau weights characters per word rather than syllables, which makes it behave differently on technical strings and acronyms — useful for SaaS content where "API," "SDK," and "SLA" show up constantly.
No single metric. Pattern matching. That's the workflow. For how I integrate this into a full content audit pipeline, see [our technical content audit process].
Audience-First, Algorithm-Second
I want to resist the framing that everything I've described is ultimately about gaming an algorithm. It's not.
The reason reading level matters for SEO in 2026 is the same reason it has always mattered for communication: mismatch between the complexity of a message and the background of the audience creates friction. Friction causes users to disengage. Disengagement produces behavioral signals. Those signals inform ranking systems.
The algorithm is measuring something real. When a page written at Grade 14 serves a novice audience badly, the resulting user behavior genuinely reflects that the page failed. When a page written at Grade 7 serves an expert audience content they already know, the resulting user behavior also genuinely reflects failure. The algorithm is not the arbiter of writing quality. It's an imperfect mirror of user satisfaction.
So the question is never "what grade level does Google want?" The question is "what reading level serves this specific audience for this specific query at this specific stage of their decision process?" Answer that question well and the algorithmic outcome tends to follow. Answer only the algorithmic question (what number should I hit?) and you get the result I got in August 2025: a page optimized against a proxy that moved in the wrong direction on every real metric.
The research on this from the [Nielsen Norman Group's work on expertise and content comprehension] is clear: expert users consistently prefer content that matches their vocabulary and expects prior knowledge. Forcing experts to wade through over-explained basics is a trust and attention cost. They leave. The data I collected is consistent with this.
None of which means complexity is always better. Novice users are real. Consumer-intent queries are real. Grade 8 is genuinely appropriate for a meaningful portion of the content that gets published online. The error is universalizing it.
So Where Does This Leave Us?
Six months of deliberate experimentation across 47 pages did not give me a clean answer to replace Grade 8 with Grade X. That's not how this works.
What it gave me was a set of more honest questions:
Who is this page actually for? Not abstractly — specifically. What does GSC query data suggest about where they are in the learning or buying process? What vocabulary do they arrive expecting to see?
What does the competitive SERP look like, not in terms of domain authority or backlinks, but in terms of how the top-performing content is written? What register is winning? Is there a gap, and is that gap an opportunity or a warning sign?
What vocabulary in this topic space carries trust signals that I cannot afford to remove in the name of simplification?
And the hardest question: am I simplifying because it serves the user, or because a content brief told me to hit a number?
The Grade 8 target is not useless. It's a reasonable starting assumption for high-volume informational content targeting general audiences. But it became a default applied thoughtlessly across content types where it had no business being a default. The damage from that is real: pages that underperform their potential, expert audiences served thin content, EEAT signals quietly eroded one simplified paragraph at a time.
My current default is competitive parity plus audience calibration. Understand the SERP. Understand the reader. Protect the vocabulary that does necessary work. Then move from there. The DRIFT framework is how I operationalize that. The Python tooling is how I measure it. The 47-page experiment is why I take it seriously.
If you've been applying Grade 8 universally, I'd suggest running the SERP fingerprint step — just that one step — on your next ten target queries. Check where you land relative to the pages actually ranking. The results may be instructive. They were for me.
