Back to Ideas
Observation Post
Humans & OrganizationsSystems ThinkingCognitive AbstractionFuture of Work

The Flynn Effect and the Age of AI

A historical perspective on human intelligence in environments of rising abstraction.

8 min read
Conceptual blueprint mapping The Flynn Effect and the Age of AI

Last week I asked which camp you're in when it comes to AI. The responses were split almost exactly three ways.

I've been sitting with that. So I went looking for a framework that might explain why all three camps exist and why none of them feel entirely wrong. I found it in a book I read a while back: Range by David Epstein.

Here's the idea that stuck with me.

Throughout human history, every time technology introduced a new layer of abstraction, human cognition adapted to meet it. Not just in behavior. In measurable intelligence.

This is called the Flynn Effect. IQ scores have risen roughly three points per decade across more than 30 countries throughout the 20th century. The gains are so large that by today's standards, our great-grandparents would appear cognitively impaired if the tests weren't periodically re-standardized. The tests keep getting harder because humans keep getting better.

But here's what makes it interesting. The gains aren't in general knowledge or vocabulary or arithmetic. They're almost entirely in abstract reasoning. Pattern recognition. Seeing connections across systems. Moving fluidly between categories that have no obvious relationship.

Why? Because each new layer of technology demanded a new kind of thinking. We moved from working with physical things to working with symbols. From symbols to code. From code to systems. At every step, the humans who thrived weren't the ones who mastered the previous layer. They were the ones who could reason across layers.

That's Epstein's core argument for generalists. In a world of wicked problems, where the rules aren't clear and feedback isn't immediate, the ability to draw on knowledge from different domains isn't a weakness. It's the actual edge.

Specialists dominate in kind environments. Chess, golf, narrowly defined technical problems where the rules are fixed and feedback is fast. But most enterprise problems aren't kind. They're messy, contextual, and constantly shifting. That's where range wins.

Now apply this to the AI question.

Camp two's argument is essentially the Flynn Effect argument. Abstraction layers have always shifted what humans do. Assembly to high-level languages didn't eliminate developers. It created more of them, doing more interesting work. AI is just the next abstraction. Humans will adapt, move up the stack, find new ways to contribute.

I think they're right. But I think they're only half right.

The Flynn Effect shows that humans got better at abstract reasoning as the world got more abstract. But what it doesn't show is that humans got better at knowing when to slow down. At catching the edge case that matters. At understanding the consequence of the action they're approving at machine speed.

The abstraction layer argument assumes that moving up the stack is always a good thing. But in enterprise AI, the higher you go, the more opaque the decisions beneath you become. You're not writing every line anymore. You're not even reading them. You're reviewing a recommendation generated by a system you didn't build, trained on data you didn't curate, executing actions you may not fully understand.

Generalists thrive when they can reason across domains. But that requires actually engaging with the problem. The failure mode I keep seeing isn't a lack of range. It's a lack of time and context to apply it.

So where does that leave us?

I think the Flynn Effect gives camp two a genuinely strong foundation. Human cognition has always risen to meet new abstraction layers. There's real historical evidence for optimism.

But the thing that made humans adapt wasn't just exposure to new tools. It was being forced to actually reason with them. To understand them deeply enough to know when they were wrong.

If AI removes that forcing function, the abstraction layer argument breaks down. We don't move up the stack. We just get further from the ground.

That's the version of this I can't stop thinking about.