Early access — cascade metrics are real (derived from canonical token telemetry); the operator field is a curated seed. Learn more about the data
◈ Guide

How to Measure AI Coding Efficiency

Time-based metrics measure the clock, not the cascade. Here’s how to measure what actually matters: the four token pillars and your Υ Yield.

Why time-based metrics fail for AI coding

For decades, developer productivity was measured in time: hours logged, commits per hour, lines per day. Tools like WakaTime built entire businesses on the premise that more time at the keyboard equals more output. That model breaks the moment an AI agent enters the loop.

An AI-assisted session doesn’t follow the human clock. A well-structured 10-minute session with excellent prompt caching can produce more useful code than a 4-hour session that re-sends the same context from scratch every turn. The human spent less time — but the cascade was far more efficient. Time-based metrics reward the slow, verbose session and penalize the sharp, cache-rich one. They measure the wrong axis entirely.

The right axis is the token cascade: how input, output, cache-read, and cache-write flow through your session. That cascade is what SigRank measures — and it’s what this guide teaches you to measure yourself.

The four token pillars

Every AI coding session — whether in Claude Code, Cursor, Copilot, or Gemini CLI — produces four token counts. These are the only numbers you need:

Input

Fresh tokens you send to the model. Every new instruction, every re-pasted file, every prompt that isn’t served from cache. High input means you’re paying full price for context.

Output

Tokens the model generates back. Code, explanations, diffs. This is your gross signal — what you actually got from the session.

Cache-read

Cached tokens reused from prior context via prompt caching. High cache-read means the model already had your context loaded and didn’t need to re-process it. This is the hallmark of an efficient operator.

Cache-write

New tokens written to cache for future reuse. An investment: you pay now so the next turn is cheaper. High cache-write with rising cache-read on subsequent turns is a healthy cascade.

How to compute Υ Yield

The headline metric is Yield (Υ):

Υ = (cache_read × output) / input²

Yield rewards two things at once: cache reuse (high cache-read means you’re not re-sending context) and output efficiency (high output per fresh input means the model is productive, not churning). The input term is squared, so burning fresh input tanks your yield fast — which is exactly the behavior you want a metric to penalize.

A yield of 5,000 is solid. 50,000 is excellent. The top operators on the SigRank leaderboard push well into six figures. Your class tier (IGNITER → SEEKER → BUILDER → TRANSMITTER) is assigned from your yield and the cascade shape.

Tools to use

  • ccusage

    A CLI that reads Claude Code token usage from local logs and emits the four pillars as JSON. SigRank bundles it — you don’t need a separate install.

  • sigrank

    The SigRank CLI. Reads your logs on-device, computes yield + class tier, signs the snapshot with ed25519, and submits to the leaderboard. Also bundles tokscale and token-dashboard.

  • /score calculator

    A browser-based calculator at /score. Paste your ccusage JSON to see yield, class tier, and compression ratio instantly — no install required.

Step-by-step setup guide

  1. Step 1 — Install sigrank

    Run npm install -g sigrank for a global install, or npx sigrank to run without installing. This gives you ccusage, tokscale, and token-dashboard in one binary.

  2. Step 2 — Enroll your identity

    Run sigrank enroll. This generates an ed25519 keypair on your device. Your private key never leaves your machine; your public key is what signs submissions server-side.

  3. Step 3 — Read your cascade

    Run sigrank me (or ccusage --json). The scanner reads your local session logs and counts the four pillars across 7-day, 30-day, 90-day, and all-time windows. You see the full cascade before anything leaves your machine.

  4. Step 4 — Check your yield

    sigrank computes Υ Yield automatically. If you want a quick check without the CLI, paste your ccusage JSON into the /score calculator. You’ll see yield, class tier, and compression ratio instantly.

  5. Step 5 — Submit to the board

    Run sigrank submit. Only the four token integers (signed) are transmitted — never your prompts, never your code. The server re-scores authoritatively and assigns your class tier. Use sigrank submit --dry-run to inspect the payload before sending.

FAQ

Why do time-based metrics fail for AI coding?
Time-based metrics measure the human clock, not the AI token cascade. A 10-minute session with excellent cache reuse can outproduce a 4-hour session that burns fresh input tokens. Yield measures the cascade architecture, independent of wall-clock time.
What are the four token pillars?
Input (tokens you send), output (tokens the model generates), cache-read (cached tokens reused), and cache-write (new tokens written to cache). They describe the full token cascade of any AI coding session.
How is Υ Yield computed?
Υ = (cache_read × output) / input². It rewards cache reuse and output efficiency while penalizing fresh-input burn. High yield means signal is compounding; low yield means tokens are being burned.
Does sigrank read my prompt content?
No. The scanner reads token counts only — never the words of your prompts or replies. Only the four integers leave your machine, signed with ed25519.
What tools do I need?
Install the sigrank CLI (npm: sigrank), which bundles ccusage, tokscale, and token-dashboard. Or use `npx sigrank` without a global install, or paste your ccusage JSON into the /score calculator.

Next: How to Track Your Token Cascade →