Two Years of Building With AI, in My Own Usage Logs

A personal note from Amir, the founder here. This one is written in the first person because the material is my own usage data, not the studio's work.

What do two years of my own AI usage logs actually show?

Three chapters. AI as a faster keyboard, then AI shipping whole products, then me running teams of agents. The logs put a number on each shift: 6.5 billion tokens across my entire history in Cursor, against 56.8 billion in Claude Code over about seven months. By September, roughly 80% of the API calls on my machine come from subagents I set up rather than from me typing.

I pulled the logs because I wanted to know whether the way my work feels different is actually different, or whether I just got used to new tools. It is different, and the shape of the difference surprised me.

Caveats first, because they matter. These are local logs only. Claude Code logs on this machine start in March 2026, so March through May are probably undercounted. Nothing from claude.ai or Cowork chats, nothing from Codex or Grok runs, nothing from other machines. Every dollar figure below is API list price, not what I paid.

Chapter one: AI as a faster keyboard

September 2024 through June 2025. Cursor, one model at a time, mostly Sonnet. The AI wrote functions and I steered line by line. It was genuinely faster than typing, and that was the whole value proposition.

Cursor did not even log token counts until May 2025. Before that I have about 9,000 events and $121 of on-demand spend, and no way to know how much context moved through them.

What I did not understand at the time is that this chapter has a ceiling built into it. If the model is a keyboard, my hands are still the bottleneck.

Chapter two: shipping whole products

July 2025 through March 2026. The unit of work went from function to feature to product. Smile PreVue, Howdy Dispatch and RunLink each got a FastAPI backend on Cloud Run, a Next.js dashboard on Vercel, and a Capacitor iOS shell.

July 2025 was the first big month at 1.38B tokens. Cursor peaked in October 2025 at 2.47B tokens and $420 of on-demand spend on top of the plan.

Then March 2026: 1.13B tokens and $812 billed beyond the subscription, running on Opus 4.6. That was the month I hit the ceiling, and it is also the first month with logged Claude Code sessions. The switch happened in April.

I want to be fair to Cursor here. It was the right tool for chapter two and I got two good years out of it. What ran out was not the product, it was my way of working inside it.

Chapter three: running agents

April 2026 to now. June was the month Claude Code passed the best Cursor month ever, at 3.63B tokens. August was 16.74B. The first fourteen days of September were 30.70B, about five times all of my Cursor usage combined.

Subagents were about 60% of API calls in August and about 80% in September. That single number is the clearest picture of what changed. I am not writing most of the code anymore. I am deciding what gets built, by whom, with what context, and then checking the result.

The shape of the work now: an architect session owns cross-repo contracts. Per-repo manager agents on Opus spawn Sonnet or Haiku workers. Nightly routines keep each repo's context file current so an agent starting cold does not have to rediscover the codebase.

All three apps went live on the App Store between July 18 and 20, 2026. A fourth product, Copiara, went from an idea to a running backend with 2,064 passing tests and 57 migrations in about a week, from July 30 to August 7. It is still in build. Then AI Clinical Notes and a simulation quality score both shipped for Smile PreVue between September 7 and 9.

What had to change in how I work

The volume is not the interesting part. What had to change for that volume to be safe is.

Documents became the source of truth. Every repo carries a contracts file that agents treat as law, a decisions log so rulings are never reopened, and a one-page status ledger. Agents read those before they read code. A nightly sync keeps the condensed context file current. This is the single highest-return change on the list, and it is also the least exciting.

Model tiering. Judgment at the top, cheap work at the bottom. On September 2 I made the rule explicit: Opus leads pick Haiku for bounded mechanical work and Sonnet for anything that crosses files or touches money, and no worker runs on Opus. Escalate Haiku to Sonnet on the first wrong-shaped result. That is a real methodology question, not a cost trick, and it is the core of our agent orchestration methodology.

Guardrails on AI output. Numbers reported by a worker get re-measured, never copied forward. Generated commentary can only cite facts an engine actually emitted, with a numeric grounding check. A grader's free text never flows back into a prompt. An image model swap needs a before-and-after visual check, because the first cutover regressed and got rolled back the same day.

A reusable blueprint. FastAPI and Postgres on Cloud Run, Next.js on Vercel, Capacitor for iOS, Firebase auth, Stripe, plus the project docs set. Packaged as a scaffolding skill, so a new product starts from a proven foundation instead of a blank repo.

Compliance-aware model choice. Patient data in Smile PreVue only touches providers under a HIPAA BAA, so image generation and clinical notes run on Vertex AI. That constraint decides the model before quality does.

Rules learned from real failures. Retarget a stacked PR before deleting its base. Never add an enum value in the same transaction as a deploy. As of September 14, agents commit on a named branch and a human pushes, because push to main is the deploy.

What it cost, and what the cost is made of

For comparison, the best Cursor month on record is 2.47B tokens in October 2025.

About $36,700 at list prices. I paid about $1,400, on a $200 a month plan over those seven months.

The composition is the part worth internalizing. Cache reads are 97 to 98% of the token volume and about 70% of the API-equivalent cost. Cache writes are about 25%. Output is about 5%.

Read that again. Almost none of the cost is the model writing. Nearly all of it is the model reading, over and over, the context I decided it should have. So the skill that compounds here is context triage: deciding what an agent gets to read, and what it never needs to read again.

By model over September 1 to 14: Opus 5 at 12.13B tokens and $8,269, Sonnet 5 at 16.44B and $3,741, Fable 5 and 5.1 at 2.10B and $1,705. The growth is mostly Sonnet workers, which is the tiering rule showing up in the bill.

What I still get wrong

A palette change that touches every logged-in page of Smile PreVue got merged without me looking at it first. There are also 36 pre-existing red tests still sitting on that backend's main branch.

Every guardrail in the section above exists because the fast path is genuinely tempting, and I take it more often than I would like to admit. The system is not a personality transplant. It is a set of places where I made it harder to skip the check.

The other honest note: for most of these seven months I have been learning faster than my own setup could keep up with. Every month the logs say the job changed again and I had to catch up to a system I built four weeks earlier.

What this means if you are starting now

If you run a team: the model is the cheapest part of this. The documents, the tiering, and the gates are the work, and unlike a clever prompt they transfer between products. We ship that way for clients and we will show you the actual harness.

If you are a person trying to learn: the curve above started with autocomplete in an editor. Two years is not a long time, and the first chapter is genuinely easy to start. That is what the 1:1 training door is for.

Are these numbers audited? No. They are my own local logs priced at API list rates, with the exclusions stated at the top.

How much of that volume is a person typing? Very little now. About 80% of calls come from subagents.

Does the flat plan really cover that? It did for me across seven months. Usage limits are real, and they shaped how aggressively I delegate.

If you want this built with you rather than explained at you, start a project.