The Nesting Doll Problem: Why the Smartest Thing You Can Do With AI Is Use Less of It
I had a conversation recently with someone I used to build alongside — a former collaborator who's spent the last stretch thinking hard about how AI actually changes work, not just how it decorates it. He said something that reorganized how I see the whole thing, and it started with his kids.
He's watched his older kids and his younger kids pick up the same tools and do completely different things with them. The older ones treat AI like a better version of something they already had — an Excel formula instead of typing numbers by hand, a faster way to do the job that already exists. The younger ones don't think about the task at all. They think: if this handles X and Y, then I'm free to go do Z. They're not optimizing the work. They're reframing what the work is.
That's the whole shift in one sentence. And once I heard it, I couldn't unhear it — because I could see exactly where I'd been doing the older-kid version without realizing it.
The box opened, and it was full of smaller boxes
Here's where it clicked for me. When you first start building with AI, you tend to reach for the biggest, smartest model for everything, because it's the smart one — why would you use anything less? That's tool-thinking. One hammer, every nail.
But the reframe isn't "use AI on more things." It's realizing that what you've actually opened is a Russian nesting doll. There isn't one big brain in there. There's a graduated set of them, each complete on its own, nested inside the next.
And the point of a matryoshka is that the smallest doll is whole. It's not a broken piece of the big one — it's finished, sufficient, sitting there ready. You don't crack open all seven dolls to answer "what's this person's email address." You reach for the little one. It's enough. The complexity only unpacks when the question actually earns it — when someone needs new data processed, or a genuinely complex analysis run, or a decision reasoned through.
So the real skill isn't horsepower. It's knowing which doll to stop at.
Why this is the actual takeaway, not a footnote
This sounds like a technical detail — token optimization, routing, the plumbing nobody writes about. And that's exactly why it matters.
Most of the conversation about AI right now is stuck on the biggest doll. Look what the smart layer can do. Look how it reasons. Everybody's staring at the outermost shell. Almost nobody's talking about the unglamorous part — the layer that reads a question, figures out how hard it actually is, and routes it to the smallest thing that can answer it well. A one-word factual lookup does not need a model built for multi-step reasoning. Burning your most powerful (and most expensive) layer on "what's the email address" is the tool mindset in disguise: maximum muscle, zero intent.
But here's the part that took me a beat to see, and it's where the whole thing gets interesting.
Something has to decide how deep to reach — and that decider is itself a doll. Before a question can be routed, something has to judge how hard it is. That judgment is a model call too. So the elegant move — the thing that makes the whole system work instead of just relocating the problem — is that the classifier is the smallest doll of all. A fast, cheap layer whose only job is to size the question, not answer it. It doesn't need to know the person's email; it just needs to recognize "this is a lookup, send it to the little one" versus "this needs real analysis, wake up the big one." You spend a sliver up front to avoid spending a fortune downstream. The intelligence is recursive: a doll whose entire job is choosing the doll. Once you see that, the architecture stops looking like a cost-saving trick and starts looking like actual design.
And the economics compound — they don't just add up. One misrouted "what's the email" to a top-tier model isn't a rounding error. It's the same overspend on every simple query, every day, across every user. Simple questions are the high-volume ones — they vastly outnumber the hard ones — so getting the cheap layer right is where the real money lives, precisely because nobody notices any single instance of it. Routing isn't a nice-to-have you bolt on later. It's the difference between a system that's viable to run at scale and one that quietly bleeds out one unnecessary token at a time.
And the cost was never only tokens — it's error surface. This is the part I'd underweighted most. A powerful model pointed at a trivial task doesn't just cost more; it hands a full reasoning engine room to over-think a question that had exactly one right answer. More capability aimed at a small job means more places for the answer to wander. Matching the layer to the task doesn't only save money — it shrinks the surface where things can go wrong. Smaller doll, simpler job, fewer failure modes. That's why deliberate architecture and reliability turn out to be the same conversation: the error rate on a well-scoped small layer, with a human checking the calls that matter, is a fraction of what you get from pointing your most powerful model at everything and hoping. Restraint isn't just cheaper. It's safer.
So the reframe is that the matching is the work. Not the muscle. You're not using less AI to be cheap — you're using it with intent, the right layer for the right question, and the judgment to tell them apart. That judgment is the thing worth building. And it's available right now, today, with the tools already on the table. It isn't a someday capability. It's a mindset you can pick up this afternoon.
That's what makes it the true takeaway. The flashy insight layer is real and it's useful — but it's not where the leverage is. The leverage is in the architecture: in deciding, deliberately, how deep to reach — and in building the small, cheap, almost invisible layer that makes that decision every single time.
Where this points next
Once you're thinking this way — picking the right doll per question instead of grabbing the whole set every time — something else opens up.
Right now, you're the one doing the matching. You look at the question, you decide how deep to go. But if a system can classify a question by how hard it is, it can also classify a situation by whether it's worth acting on. That's the jump from a dashboard you have to remember to check, to an agent that acts when the conditions are right.
Picture it: instead of someone happening to glance at a report and noticing a problem, the system itself notices — the conditions line up, the threshold is crossed — and it proposes the move. Not because someone prompted it. Because the moment called for it. The same instinct that tells the system "this is a small-doll question" can tell it "this is a moment that deserves a response."
That's the direction all of this is pointing. And it starts with something almost boringly simple: the willingness to not use the whole nesting doll every time.
The older-kid move is to make the existing job faster. The younger-kid move is to ask what the job even is anymore. Turns out the answer starts with knowing which doll to stop at.
