Velocity — Token Production Rate

The velocity formula

Velocity is the ratio of output tokens to fresh input tokens. It answers a simple question: how much output am I generating per token of fresh context I provide? A velocity of 0.5 means you produce 1 output token for every 2 input tokens — the model is generating substantial output relative to your prompts. A velocity of 0.01 means you produce 1 output token for every 100 input tokens — most of your tokens are fresh context, not generated output.

input is the fresh context you provide each turn — new prompts, new instructions, new code snippets. Velocity captures how efficiently the model converts your fresh input into output, independent of cache reuse (which is what leverage measures).

What velocity measures

Velocity measures your output efficiency — how much output you produce per token of fresh input. It is the AI-coding analog of code-to-comment ratio, but measured in output tokens versus input tokens. Unlike lines of code, output tokens are a direct measure of the model’s productive work, not your typing speed.

Velocity is influenced by several factors: how specific your prompts are (targeted input produces more output per token), how much output you request per turn (prompt design), how much context you can reuse from cache (which reduces the input you need to provide), and the complexity of the task. Improving any of these increases velocity — but not all improvements are equal.

Why velocity is a secondary metric

The fundamental insight: high velocity without yield is fast waste. An operator who generates 10,000 output tokens from 50,000 fresh input tokens with no cache reuse has high velocity but low yield. They are burning input efficiently — good output ratio, but no context compounding.

This is why SigRank treats velocity as secondary. Yield is the headline because it measures the architecture of the cascade — whether signal is compounding. Velocity measures the output ratio of the cascade — how much output you get per input. Output without compounding is noise. Architecture without output is still signal (just less of it). The priority is architecture first, output ratio second.

Consider two operators. Operator A has a velocity of 0.3 with a yield of 50 (efficient cascade, moderate output ratio). Operator B has a velocity of 0.8 with a yield of 2 (high output ratio, wasteful cascade). Operator A is the better AI coder — their output compounds. Operator B is generating more output per input but burning context to do it. Velocity alone would rank B higher; yield correctly ranks A higher.

How velocity interacts with yield

Velocity and yield measure orthogonal dimensions. Yield measures cascade efficiency (output × cache reuse / input²). Velocity measures output efficiency (output / input). They share the output term but diverge everywhere else.

When velocity matters

Velocity matters most for throughput-oriented tasks where raw output volume per hour is the goal:

• Bulk code generation — generating boilerplate, scaffolding, or repetitive implementations where quality is uniform and volume is the bottleneck.
• Large refactors — applying a consistent transformation across many files or functions.
• Test suite generation — writing comprehensive test cases for an existing module.
• Documentation writing — generating API docs, README files, or inline comments across a codebase.

For precision tasks — debugging a subtle race condition, making an architecture decision, reviewing a security-critical change — yield matters more than velocity. These tasks reward careful, efficient cascades over raw throughput. Use velocity as a diagnostic to understand your working style, not as a target to maximize at the expense of yield.

How to improve velocity without sacrificing yield

• 1. Request larger outputs per turn. Instead of asking for one function at a time, request a complete module or feature. This increases output per turn without increasing input or breaking cache — both yield and velocity go up.
• 2. Reduce review-loop overhead. Time spent reviewing and editing between turns is input that doesn’t produce output. Trust the cascade — if your context is stable and your prompts are specific, the output quality is high enough to reduce round-trip edits.
• 3. Batch related requests. Instead of five sequential turns (“write the function,” then “add types,” then “add tests,” then “add docs,” then “add error handling”), batch them into one turn: “write the function with types, tests, docs, and error handling.” One turn, large output, same cached context.
• 4. Maintain cache continuity. Cache reads are faster than fresh input processing — high cache hit rate reduces model latency, which increases velocity. Context discipline improves both yield and velocity simultaneously.

FAQ

What is velocity in AI coding?

Velocity = output / input. It measures how many output tokens you produce per token of fresh input. High velocity means you’re generating substantial output relative to your input; low velocity means you’re spending most of your tokens on fresh context without proportional output.

Why is velocity a secondary metric?

High velocity without yield is fast waste. An operator generating high output per input with no cache reuse has high velocity but low yield — they are burning input efficiently. Yield measures efficiency; velocity measures output ratio. Output without compounding is just faster waste. Yield is the headline; velocity is context.

How does velocity interact with yield?

They measure orthogonal dimensions. You can have high yield and low velocity (efficient but deliberate — precision work) or high velocity and low yield (fast but wasteful — volume without context discipline). The best operators have both: efficient cascades that also produce a lot of output quickly.

When does velocity matter?

Velocity matters most for throughput-oriented tasks: bulk code generation, large refactors, test suite generation, documentation writing. For precision tasks — debugging, architecture, security review — yield matters more. Use velocity as a diagnostic, not a target.