How to Benchmark Your AI Coding Workflow

You've been coding with AI for months. Your sessions feel productive — the agent generates code, you review it, you ship. But “feels productive” is not a metric. The question every AI-assisted developer eventually faces is simple and uncomfortable: am I actually getting better at this, or am I just burning more tokens?

This guide walks through a complete, repeatable workflow for benchmarking your AI coding performance. Seven steps. One week per cycle. By the end you'll have a number — your yield (Υ) — that tells you whether your signal is compounding or your tokens are being burned, and a process for driving that number up.

What you'll need

• An AI coding workflow you already use (Claude Code, Cursor, Copilot, ChatGPT, Gemini — any of the 15+ supported platforms).
• Node.js 18+ on your machine (for the sigrank CLI).
• One week of normal coding to establish a baseline.
• The discipline to change one variable at a time.

Step 1 — Install the tools

The fastest path is a single command. The SigRank CLI bundles everything you need — ccusage for parsing local logs, tokscale for token scaling, and the Token Dashboard for visualization:

# No global install required — npx runs it directly
npx sigrank

# Or install globally for daily use
npm install -g sigrank

# Create your operator identity (one-time)
sigrank enroll

sigrank enroll creates your operator identity and generates an ed25519 keypair on-device. The private key never leaves your machine; the public key is what signs your snapshots. No account, no email, no cloud — your identity is cryptographic, not personal.

If you use Claude Code specifically, the bundled ccusage will find your logs automatically. For other platforms, SigRank's scanner detects the relevant log directories on its own. Run sigrank me --dry-run to see what it would parse before submitting anything.

Step 2 — Establish a baseline

This is the step most people skip, and it's the one that makes everything else work. Code normally for one full week. Do not optimize. Do not change your habits. Do not try to impress the tool. The goal is an honest picture of where you are right now.

At the end of the week, record your cascade:

sigrank me

# Example output:
# ┌──────────────────────────────────────┐
# │  Input:        1,240,000 tokens      │
# │  Output:         312,000 tokens      │
# │  Cache-read:     890,000 tokens      │
# │  Cache-write:    210,000 tokens      │
# │                                      │
# │  Yield (Υ):          14,237          │
# │  Cache hit rate:        80.9%        │
# │  Leverage:              0.72         │
# │  Class tier:          BUILDER        │
# └──────────────────────────────────────┘

Real example: A developer we'll call “Seeker-7” ran this after their first week. Their yield was 14,237 — solidly in the BUILDER tier, but their cache hit rate was only 53% and their input was unusually high at 1.24M tokens. The baseline told them two things: they were doing okay, and they were re-explaining context far more than they should be.

Write your baseline numbers down. You'll compare every future cycle against them.

Step 3 — Identify your weak pillars

Your yield is a composite of four pillars. To improve it, you need to know which pillar is dragging. Look at your baseline and ask:

Real example: Seeker-7's weakest pillar was cache hit rate (53%). Their input was high, but the root cause was the same — they were starting new sessions for every sub-task and re-pasting the same context each time. One problem, one fix.

Step 4 — Apply one fix at a time

This is the discipline that separates benchmarking from guessing. Change exactly one thing. If you tighten your prompts and restructure your sessions simultaneously, and your yield goes up, you won't know which fix drove it. If it goes down, you won't know which change hurt.

Pick the single highest-leverage fix from Step 3 and apply only that. For Seeker-7, the fix was: stop starting fresh sessions for each sub-task; work within one long session per feature so the cache builds. That's it. No prompt-tightening, no output-boosting, no other changes. One variable.

Step 5 — Re-measure

Code for another week under the new habit. At the end, run sigrank me again and compare to your baseline:

# Seeker-7, Week 2 (after session-structuring fix)
# ┌──────────────────────────────────────┐
# │  Input:          980,000 tokens  ↓21% │
# │  Output:         340,000 tokens   ↑9% │
# │  Cache-read:   1,120,000 tokens  ↑26% │
# │  Cache-write:    240,000 tokens  ↑14% │
# │                                      │
# │  Yield (Υ):          39,801   ↑180%   │
# │  Cache hit rate:        82.4%  ↑29pp  │
# │  Leverage:              1.14   ↑58%   │
# │  Class tier:       TRANSMITTER        │
# └──────────────────────────────────────┘

One fix. One week. Yield up 180%, cache hit rate from 53% to 82%, class tier jumped from BUILDER to TRANSMITTER. The numbers confirm the hypothesis: the problem was session fragmentation, and consolidating sessions fixed it. If the yield had stayed flat or dropped, the fix was wrong — revert and try the next-weakest pillar.

Don't re-measure after a single session. One good day doesn't prove a fix worked; one bad day doesn't prove it failed. The weekly cadence averages out session-level noise. Patience is part of the method.

Step 6 — Compare against the field

Your yield in isolation is just a number. Context comes from the leaderboard. Submit your snapshot and see where you stand:

# Submit your signed snapshot
sigrank submit

# Then check the board
sigrank board --window 30d

The leaderboard shows your class tier (IGNITER → SEEKER → BUILDER → TRANSMITTER and beyond), your global rank, and — critically — the pillar ratios of the top decile. If the top decile averages a 90% cache hit rate and you're at 82%, that's your next gap. If their leverage is 1.5 and yours is 1.14, that's the pillar to attack next cycle.

Real example: Seeker-7 hit TRANSMITTER after one cycle but ranked #847 globally. The top decile's leverage was 1.8 — theirs was 1.14. Next cycle's fix: increase cache depth by referencing larger shared context blocks early in each session, so the cache-read base grows faster than input.

Step 7 — Iterate

Benchmarking is not a one-time audit. It is a feedback loop. Each cycle: identify the weakest pillar, apply one fix, re-measure, compare. Over weeks, your yield climbs and your class tier rises. The developers at the top of the leaderboard didn't get there in one sprint — they got there by running this loop dozens of times, each cycle tightening their cascade by a few percent.

The developers who treat AI coding as a measurable skill — not a vibe — are the ones who climb. The loop is simple. The discipline is hard. Run it for a month and you'll know your cascade better than anyone who's been “just coding” for a year.