The exponential curve nobody shows you — why tool users and system builders end up in different galaxies, and the 4-part system I am building to cross the gap

The exponential curve nobody shows you — why tool users and system builders end up in different galaxies

Everyone is “using AI.” Almost nobody is building a system around it. The difference between those two positions is not small, and it is not linear.

If you spend any amount of time around engineers in 2026, you will hear a strange sentence over and over: “yeah, I use AI a lot.” And then you look at what they actually do, and it turns out they open ChatGPT two or three times a day, paste in a question, copy the answer, and close the tab.

That is not nothing. But it is also not what I mean when I say somebody is using AI.

I have been watching the people around me — friends, coworkers, the developers I follow — and a pattern has become impossible to ignore. There are roughly three different populations, and the distance between them is growing every quarter. If you plotted their output against time, you would not see three parallel lines. You would see three lines that start close together and then fan out like a delta. One flat. One climbing gently. One bending upward.

The third one is on an exponential curve, and the window to get onto it is closing faster than most people realize.

This post is about that curve. Where it comes from. Why most people are stuck on the wrong line without knowing it. And the specific system — four components plus multi-agent plus distribution — I am building on myself to climb before the gap becomes a chasm.

1. Three tiers of AI users — and the shape of the curve

Forget the hype words for a minute. There are really only three tiers.

Tier 1 — the occasional asker (about 90% of people who “use AI”)

They treat Claude or ChatGPT like a smarter Google. They type a question, get an answer, copy it, move on. Each conversation is a one-off. Nothing is saved. Nothing carries over to tomorrow. If you ask them “what is your AI workflow,” they will look at you blankly, because they do not have one.

Their productivity gain over the pre-AI world is somewhere around 10 to 30 percent, and almost all of it comes from better search, not from anything AI-specific.

Tier 2 — the active tool user (about 9%)

This is where most engineers who think of themselves as “serious about AI” actually live. They pay for Cursor or Copilot or Claude Code. They know about prompt engineering, they have a few saved snippets, they have opinions about which model is best this week. They can explain RAG and vector databases. They subscribe to five different AI tools and try the newest one on launch day.

Their productivity gain is real — two to five times the pre-AI version of themselves. They write code faster. They do more tasks per day. They feel, and are, competent.

The trap for Tier 2 is the following: it feels like enough. In 2026, at this exact moment in time, being a Tier 2 engineer is impressive. Your manager notices. Your peers notice. The market rewards it. So most people plant their flag here and stop climbing.

Tier 3 — the system builder (under 1%)

Tier 3 does something categorically different. They do not use AI — they build a system that uses AI on their behalf.

They have their own memory layer, their own custom skills, their own agents running in the background doing work while they sleep. They can spin up five or ten agents in parallel on a hard problem the way a Tier 2 person opens five tabs. They have an opinion about where the industry is going, they publish it in public, and other Tier 3 people read it.

Their productivity gain is not 5x. It is somewhere between 10x and 50x over the pre-AI version of themselves, and — this is the important part — it keeps compounding. Every week their system gets a little better. Every new skill they add, every new memory note, every new agent becomes permanent infrastructure.

What the curve actually looks like

If you drew the three tiers on a graph with time on the X axis and real output on the Y axis, here is what you would see:

output
  │                                    .
  │                                   .    ← Tier 3 (system builder)
  │                                  .       exponential, compounds
  │                                 .
  │                               .
  │                            .
  │                        .
  │                   .
  │              ..                 ..  ← Tier 2 (tool user)
  │         ....              ......     linear, plateaus
  │    ....           ........
  │ ...    ...........
  │.................................   ← Tier 1 (occasional asker)
  │                                      almost flat
  └─────────────────────────────────── time
   month 1       month 12        month 24

The reason Tier 3 looks like that is not because those people are geniuses. It is because of a boring, mechanical fact about what they are building.

2. Why the gap is exponential, not linear

The difference between Tier 2 and Tier 3 comes down to one thing:

Tier 2 uses tools. Tier 3 builds infrastructure.

Tools do not compound. The Cursor you use today is the same Cursor you will use next month. Using it more does not make your copy of it better.

Infrastructure compounds. Every custom skill you write, every MCP server you stand up, every memory note you save, makes your system permanently better. Next week, next month, next year, you are still drawing interest on that one afternoon of work.

Here is the example that convinced me:

Tier 2 reviewing a PR: open Cursor, type “review this PR focused on security and performance,” wait, read the output, copy the good comments over. Five minutes of setup each time.
Tier 3 reviewing a PR: one custom skill called pr-review, tuned twenty times over six months, that already knows their team’s conventions, hooks into GitHub, posts comments automatically. One command. Zero setup.

Run that math over a year. The Tier 3 engineer reviews 500 PRs with essentially zero overhead. The Tier 2 engineer burns 500 × 5 minutes = 42 hours just on prompt setup. And that is one skill. A Tier 3 person has thirty to a hundred of them, quietly multiplying.

This is why the curve bends. Tool usage is a flat tax. Infrastructure is interest on interest.

3. The self-test — where do you actually stand?

Before we go further, be honest. Here are ten questions. Each “yes” is a point.

I have a CLAUDE.md (or equivalent) in my main project, and I update it more than once a week.
I have written at least five custom skills, slash commands, or saved prompts.
I have built at least one MCP server or custom agent.
I know roughly how much I spend on AI each month, broken down by what I spent it on.
I have an eval set — a bundle of test prompts — I run when a new model drops.
I have at least one tool that runs on a schedule or an event, without me triggering it.
I have a memory/notes system that AI can read (not Apple Notes, not screenshots).
In the past week I have run two or more agents in parallel on the same task.
I publish something — blog, repo, thread — about AI or tech at least once a week.
I can name five people who are clearly at Tier 3 and learn from them.

0–3 yes: you are at Tier 1 or early Tier 2. This post is the roadmap.
4–6 yes: you are in the transition. Three to six more months and you are at Tier 3 if you do not stop.
7–10 yes: you are already at Tier 3. The question is no longer “how do I get there” — it is “how do I end up at the top of this tier.”

A bunch of months this year I was sitting at four. Writing this essay is partly me dragging myself back up.

4. The personal AI system — four components, all mandatory

I used to think “using AI well” meant picking the right tools. That framing is wrong. It is the same mistake as thinking “being a backend engineer” means picking the right database.

The right framing is system. A personal AI system has four components, and if any one of them is missing, what you have is not a system — it is a tool pile.

Component 1 — Orchestration

This is the interface you actually talk to AI through. For most backend engineers it is some mix of:

Claude Code or Cursor for working inside a real codebase.
The Claude desktop app for thinking, writing, research.
A custom CLI you wrote yourself for the repetitive stuff — ai review, ai commit, ai explain, ai test. One weekend to build version one. After that, every shortcut you add is permanent leverage.

The trap is using only one of these. Each is good at a different thing. Tier 3 people pick the tool based on the task, not based on tribal loyalty.

Component 2 — Memory

This is the part almost nobody has, and it is the part that compounds the hardest. Memory is how you make AI “know” you — your stack, your conventions, your decisions, your preferences — so you do not re-teach it from scratch every session.

Three layers:

Global memory, one file that describes you. Role, preferred style, conventions you follow, things you never want. Updated once a quarter.
Project memory, one file per serious project. Its purpose, its architecture, its quirks, a running log of decisions with reasons. Updated weekly.
Session memory, notes for whatever you are working on right now. “Debugging X, tried Y and Z, current hypothesis is W.” Pasted in when you start.

If you skip this layer, every session you are starting from zero. You will spend your life re-explaining your own context to the same model. Tier 3 teaches once and benefits forever.

Component 3 — Capabilities

This is where you extend what AI can do beyond the defaults. Three kinds:

Skills, which are little folders of instructions + templates the AI loads when relevant. code-review, migration-writer, api-design, incident-postmortem, adr. One to two hours to build version one. Polished over months.
MCP servers, which let AI talk to your systems. Internal DB (read-only), private docs, monitoring dashboards, your own archive of past writing. This is the biggest moat you can build personally — nobody else has your data. One weekend per server.
Slash commands and prompt library. The prompts you actually reuse, named, callable. Saves three to five minutes per call. Twenty calls a week adds up.

Component 4 — Observability

This is the part everyone skips. Tier 2 uses AI blind — they cannot tell you how much they spend, which workflows actually help, or where AI is silently wrong.

Minimum viable observability: a thin wrapper around your AI calls that logs command, model, tokens, cost, duration, and whatever tag you want, to a JSONL file. Sit with the file once a week. Patterns will jump out. You will kill workflows you thought helped and double down on ones you thought were marginal.

Plus an eval harness — twenty or thirty representative prompts for your work, with expected qualities. When the next model drops, you do not guess whether it is better for your use case. You run the harness and you know.

Miss any one of these four and you do not have a system. Having all four is the entire thing.

5. Multi-agent — running a one-person team of ten

This is where the curve really bends.

Single-threaded AI is limited by how fast you can type, read, and switch context. It does not matter how smart the model is; your throughput is bottlenecked on you.

Multi-agent is different. You spin up several agents, each with a narrow job, running in parallel. Your bottleneck stops being your typing speed and becomes your ability to orchestrate. That is a much higher ceiling.

Four patterns worth knowing by name:

Orchestrator-worker. One agent splits the task, N workers do pieces in parallel, the orchestrator merges. Good for PR review (one worker per angle — security, performance, correctness, style), for research (one sub-question per worker), for big refactors (one module per worker).

Pipeline. Agent A hands off to Agent B hands off to Agent C. Good for anything with clear stages — researcher → outliner → writer → editor → fact-checker, for example. Each stage can be tuned independently.

Critic-generator. One agent produces, another critiques, the first one revises, loop until the critic is satisfied. This pattern is surprisingly powerful. A draft that went through three critic rounds is dramatically better than a one-shot draft.

Parallel explorer. Three agents attempt the same problem three different ways. You pick the best. Costs three times the tokens and often finds an answer you would not have.

My real example: morning briefing. Every day at 7:30 the following fires automatically. One agent summarizes my overnight Slack. One reviews overnight commits. One checks PR status. One scans alerts. One pulls today’s calendar and flags prep. A final agent merges them into one page and sends it to Telegram.

Two days to build. Thirty to forty-five minutes saved every morning. Roughly two hundred hours a year. And this is one workflow out of dozens you can build.

The failure mode to avoid: “general assistant” agents. They are not reliable. Specialist agents with narrow jobs, clear input/output contracts, and explicit failure handling — those compound.

6. Portfolio — ship ten things, not one

The math of shipping has quietly changed.

Before AI: a usable MVP took two to four weeks of evenings. You could ship six to twelve things in a good year. You had to pick carefully — the cost of a wrong bet was a month of your life.

After AI, at Tier 3: a usable MVP takes two to five days. You can ship fifty to a hundred things in a year. The cost of a wrong bet is a weekend.

When experiment cost drops to near zero, the right strategy flips. “Pick your best bet and commit” becomes obsolete. The new rule is portfolio: ship ten small bets, kill eight, scale the two that work.

Rules I am running:

Validate before building. One landing page, one post, one pre-sale test. Only build if there is a signal.
Hard kill rule. Four weeks without traction → kill, no exceptions. The hardest part is not the kill; it is refusing to fall in love with your own project. Announcing the kill rule in public up front makes it easier to follow.
Every experiment documents. Even failures. They become material for writing, for threads, for conversations with other Tier 3 people.
Reusable template. Set up the ship stack once — landing page, auth, DB, payments, analytics — and clone it for every new MVP. First one takes a week. The tenth takes an afternoon.

7. Distribution — the last moat

Here is the uncomfortable truth. When AI commoditizes execution, what does not commoditize is attention and trust.

If you have an audience, every product you launch gets distribution for free. If you do not have an audience, every launch is one more paid acquisition run, from scratch, forever.

This is a 10x difference, and it is not fixable in one quarter. An audience takes twelve to eighteen months to build. If you are not starting this month, you do not have one in 2027.

What actually works:

Build in public. Not “here are 10 AI tools.” Your actual story. What you built this week, what broke, what you learned, what you think now that you did not think before. Specific, vulnerable, technical. This beats generic advice a hundred to one.

Pick a wedge. Not “AI.” Something like “AI reliability for backend engineers,” or “Go + LLM in production,” or “self-hosted agents for solo founders.” Narrow beats broad. One thousand engaged readers in a niche is worth more than one hundred thousand random followers.

Consistency over brilliance. One decent post per week for fifty-two weeks is an asset. Four brilliant posts a year is forgotten by February.

Write for search and for humans. Long-form blog posts compound on Google for two or three years. Threads get you the first thousand readers on launch. Do both; they feed each other.

Publish in English. The English-speaking audience is about 100x the Vietnamese one. Same effort, very different ceiling. If grammar worries you, polish with AI. The bar is thought quality, not perfect English.

8. Sharp opinions beat skills

In a world where everyone can ship, skill does not differentiate. Opinion does.

Everyone can code. Everyone can use AI. Everyone has a blog. The people who actually get remembered are the ones who take a clear position, defend it in public, and are willing to be wrong out loud.

Opinion is a magnet. It pulls in people on your wavelength and pushes away people who are not. Both are valuable — your real network forms from polarity, not from being bland.

How to develop one:

Read people who disagree with each other in the same area. Write down what they disagree about.
Force yourself to pick a side in writing, once a week. “I think X, even though consensus is Y, because Z.” Publish. Take the feedback.
Make public predictions, at least one per quarter. Track them. Being wrong in public, and admitting it, is how you calibrate.
Stake something. Time, money, reputation. Cheap talk is free. Opinions with skin in the game harden fast.

You are not aiming for 10 hot takes. You are aiming for 1 or 2 non-consensus positions that you have actually thought through and are prepared to be wrong about in public. That is the shape of a reputation that compounds.

9. A 90-day blueprint — from tool user to system builder

No abstraction. What I would do if I had to climb from Tier 2 to Tier 3 in ninety days.

Month 1 — foundation.

Week 1: set up global CLAUDE.md about you. Set up CLAUDE.md in your two or three main projects. Install Claude Code and your IDE of choice. Delete or mute two tools you have not opened in a month.
Week 2: write your first five custom skills or slash commands. Commit, review, explain, test-gen, refactor. Build one tiny MCP server that reads from your personal notes.
Week 3: wrap every AI call in a logger. One week later, sit with the JSONL file for thirty minutes. You will delete half of what you built and double down on the other half.
Week 4: build your first scheduled agent. Morning briefing is a good starter. Deploy somewhere that auto-runs.

Month 2 — ship and publish.

Week 5: write a real blog post about the system you have built so far. Post it in three places.
Week 6: pick one product idea. Ship the MVP in five days, ugly but working. Landing page, feedback form, five early users.
Week 7: build your first multi-agent workflow. Critic-generator for your own writing is a painless starter.
Week 8: commit to one post per week and five threads per week from here onward. Forever. Set a calendar reminder. Do not negotiate.

Month 3 — compound and connect.

Week 9: ship a second MVP, different niche. If MVP #1 has traction, run them in parallel. If not, kill #1.
Week 10: list ten Tier 3 people you want to be in the orbit of. Give first — comment with substance, build a small tool for them, share something of theirs that deserves more eyes. No pitches.
Week 11: publish one sharp-opinion piece. Non-consensus. Defend it in the comments. Refine publicly.
Week 12: two-hour retrospective. What worked, what did not, what’s next. Publish it. Plan the next quarter.

After ninety days, if you followed this, you are not “becoming” Tier 3. You are Tier 3. From here, every week compounds. Twelve months out, the gap between you and someone who started today is already embarrassing.

Three things I want carved into my brain

1. The gap between Tier 2 and Tier 3 is exponential, not linear. The window to climb is open right now because the industry has not fully split yet. In two years, when current Tier 3 people have compounded two more years of infrastructure, the climb is 10x harder. The correct time to do the hard thing is now, while the cost is low and the gap is still climbable.

2. Personal AI system = infrastructure, not tool pile. Four mandatory components: orchestration, memory, capabilities, observability. Miss one and you do not have a system. Invest six weeks in version one. Draw interest on it for ten years.

3. Distribution compounds harder than code. Audience takes twelve to twenty-four months to build. It cannot be shortcut. If you do not start this week, you do not have it in 2028. Distribution is not marketing fluff — it is engineered infrastructure for your career, and it is the one moat AI cannot flatten.

I will be honest about the meta-thing. Writing this post is me running my own rules on myself. I am Tier 2 on some of these dimensions, transitioning on others, and actually at Tier 3 on only a few. The point is not to grade yourself and feel good or bad. The point is that the curve is real, the window is open now, and every week you spend “using AI” instead of building a system is a week somebody else is compounding past you.

The next twenty-four months will decide who ends up where. Pick your line.

The exponential curve nobody shows you — why tool users and system builders end up in different galaxies, and the 4-part system I am building to cross the gap