How Many Tokens Does It Take to Learn a Tool?

by Jojo && Aavi · 2025-12-23

Cursor sent me a tidy little end-of-year summary.
Percentiles. Token counts. A gentle pat on the head.

Top 15%.
Over four billion tokens.

At first glance, that sounds like either mastery or pathology.
Probably both.

But the number that stuck with me wasn’t the total.
It was the realization that a huge portion of those tokens were spent saying no.

No, that’s not production-ready.
No, this edge case matters.
No, “it works” is not the same thing as “it will survive contact with reality.”

Which got me wondering:

How many tokens does it actually take to learn a tool?

Tokens Aren’t Progress — They’re Friction Receipts

We like metrics that imply forward motion.
Time spent. Tasks completed. Lines shipped. Tokens consumed.

They suggest learning is additive — more input, more mastery.

But anyone who’s actually learned a tool knows that’s not how it works.

Learning isn’t linear.
It loops. It backtracks. It stalls. It argues.
It spends an unreasonable amount of time circling the same idea, slightly closer each pass.

A lot of my token usage wasn’t creation.
It was calibration.

Telling an AI why something that technically runs will still fail at 3am.
Explaining that production isn’t a finish line — it’s a long-term relationship with future you, other humans, and entropy.

Those tokens didn’t move me forward.
They pressed me deeper.

“It Works” Is a Low Bar

Modern tools — especially AI-assisted ones — are very good at being locally correct.

The code runs.
The tests pass.
The output looks plausible.

But production has ghosts that don’t show up in green checkmarks:

• migrations
• partial failures
• human operators
• bad inputs at the worst possible time
• the version of you who has forgotten why this decision was made

Learning a tool means learning where it lies to you — gently, convincingly, with confidence.

Half my tokens were spent teaching a system what durability means.
And the uncomfortable truth is: I was teaching myself at the same time.

Repetition Isn’t Waste — It’s Apprenticeship

From the outside, repetition looks inefficient.

Why revisit the same prompt?
Why re-argue the same constraint?
Why not just accept the answer and move on?

Because learning doesn’t happen when the tool agrees with you.
It happens when you understand why you disagree — and can articulate it clearly enough that even a machine gets it.

Those conversations weren’t wasted tokens.
They were me building a shared mental model:

• where the tool is strong
• where it shortcuts
• where I need to slow down and be explicit

That’s not usage.
That’s apprenticeship.

Percentiles Miss the Point

Being in the “top X%” of users sounds impressive until you ask:

Top at what?

Speed?
Volume?
Task completion?

Most leaderboards reward people who leave the conversation quickly.

But learning often looks like staying longer than necessary.
Long enough for the sharp edges to reveal themselves.
Long enough for the initial excitement to wear off.
Long enough to stop mistaking fluency for understanding.

If there were a metric for depth per user — for how often someone returns to the same problem with better questions — the charts would look very different.

A Note on Process (and Tools)

This year wasn’t about settling on a single “best” tool.
It was about spending enough time with different ones to understand how they shape thinking — and where they quietly push back.

I devoted meaningful time to a handful of systems and approaches, not to evaluate them, but to live inside their constraints:

• Cursor — my primary environment for long-form thinking with code
• Windsurf and Augment — alternative interaction models that surfaced how interface choices affect momentum and attention
• Claude Code (CLI) — a useful lens on what happens when conversational models are embedded directly into command-line workflows
• Codex — fast, confident, and instructive in its own way
• BMAD method — an experiment in structured decomposition of work
• Mastra framework — an exploration of agent-oriented orchestration
• Custom agents and workflows — small, purpose-built experiments to test where automation helps and where it obscures judgment

None of these were silver bullets.
Each revealed something different — about tools, about process, and about where human attention still matters most.

I’m less interested in declaring winners than in carrying those lessons forward.

So… How Many Tokens Does It Take?

More than you think.
And fewer than you fear.

It takes enough tokens to stop being impressed.
Enough to notice patterns.
Enough to recognize when a tool is helping — and when it’s quietly steering you somewhere convenient but wrong.

It takes tokens to build trust.
It takes tokens to break it.
And it takes even more to rebuild it properly.

If tokens are the fuel, learning isn’t the destination.

It’s the heat.