DORA for AI-augmented engineering

Measure what your AI spend produces — not what it burns.

TIER is a self-hosted, open-source meter for the yield of AI-assisted engineering: quality-weighted outcomes per $1,000 of spend. Per team, over time.

TIER = Σ(outcome × quality) ÷ (AI cost in $ / $1,000)
= quality-weighted outcome points per $1,000 of spend

New to this? The short answer →

TIER · Q3 · by team
99
outcome points
per $1,000
of AI spend
TeamPointsCostTIERTrend
Payments318$1,940164▲ 11%
Platform205$1,610127▲ 6%
Growth96$2,88033▼ 14%
Illustrative data · deterministic, re-derivable from stored rows

The name is the thesis

TIER — Token Impact & Efficiency Ratio

A double meaning, on purpose. It is the ratio — impact over efficiency, shipped outcomes over dollars, computed and re-derivable. And it is the tier — one comparable grade for how well spend becomes real work, so you can finally compare on efficiency instead of usage.

T·I·E·R = Impact (quality-weighted outcomes) ÷ Cost (dollars of AI spend / $1,000)

The problem

Everyone is spending on AI. Almost no one can say what it bought.

Token budgets are being written into job offers. Consumption leaderboards are celebrated. And the honest answer to "what are we getting for it?" is still a usage chart.

01

The spend is real — the yield is invisible

Engineering leaders keep saying the same thing: "We gave everyone access. We have no idea what it's producing." The bill is precise. The return is a guess.

02

Every dashboard measures burn, not yield

Vendor consoles, usage exports, spend reports — they all answer "how much did we consume." None of them answer "what did the consumption buy."

03

We have run this play before

Cloud adoption measured adoption instead of efficiency, and by industry estimates roughly a third of cloud spend went to waste. Token spend is the same curve — earlier, and steeper.

04

TIER is the meter

It reads the spend your tools already emit, joins it to the outcomes your GitHub already produces, and divides. Self-hosted. Deterministic. Honest about its limits.

$250K

"If that $500,000 engineer did not consume at least $250,000 worth of tokens, I am going to be deeply alarmed."

Jensen Huang, NVIDIA — All-In Podcast, GTC 2026 week
4 months

Uber burned through its entire 2026 AI budget by April. Its COO: "that link is not there yet."

Fortune / MLQ, May 2026
19% slower

Experienced developers using AI were 19% slower on their own repos — while believing they were 20% faster.

METR randomized trial, 2025

This is the fourth time the industry has tried to measure engineering. The first three metrics were gamed and abandoned. Read the 60-year lineage — and why TIER is different →

How it works

A meter, not a model. Three moving parts.

No LLM sits in the scoring path. Same inputs, same score, re-derivable from the stored rows — a number you can defend in a leadership meeting.

Step 01 — denominator

Read the spend

Token counts your tools already emit — zero-config for Claude Code's session logs, an optional reverse proxy for other Anthropic- or OpenAI-shaped API traffic. Priced from a versioned reference table into exact integer micro-dollars.

Step 02 — numerator

Join the outcomes

Merged pull requests from the GitHub workflow you already run, size-weighted (xs → xl) and quality-adjusted. A git revert is detected by merge-commit SHA and discounts that outcome's credit automatically.

Step 03 — the ratio

Divide, deterministically

Summed, quality-weighted outcomes over summed dollars — per team, over time. Weighted aggregation, so a high-spend, low-output member can't hide behind an average.

What TIER never stores — the parser is an allowlist
✕Prompts & completions
✕Source code & file contents
✕Keystrokes & screenshots
✓Token counts & model names
✓Timestamps & message IDs
✓Branch-derived issue references

Unit — outcome points per $1,000 of spend. Ship 100 weighted points on $1,000 and you score 100. Spend $10,000 for the same work and you score 10. The same work for $250 scores 400.

The full method — how the score is computed →

Measured by TIER

We point the meter at ourselves.

TIER's own numbers, computed by TIER on the repository that builds it — including the part most tools would rather hide. Trailing 30-day window, as of 2026-07-21.

221
TIER — points per $1,000
$3,268
real AI spend, building TIER
152
merged PRs → 723 weighted points
$4.52
cost per outcome point

Snapshot: trailing 30 days to 2026-07-21. Re-derivable from the shipped evidence — the window moves, so the figure moves with it.

The TIER dashboard run on TIER's own repository — org TIER 221.4 points per $1,000, a Spend Leverage reading (plan-dependent), the name-free cost-composition retro, and complete capture fidelity on this repo. No individual developer is named.
Real output — TIER measuring the repo that builds it (name-free, org-level; a solo dogfood run, so provisional at 28% attribution coverage).

And 72.1% of that spend was unattributed — not yet tied to a merged issue, exactly as the board above reports it. We show our own waste, because that's the number that makes us spend better. Most dashboards would hide it.

Who it's for

Three buyers, three vocabularies, one number.

CFO / Finance

Put a yield next to the line item

One number per team per quarter — and Spend Leverage: your usage priced at list, over what you actually paid — about 1× on pay-as-you-go, higher on a flat plan. The figure that decides subscription vs. per-token, that nobody computes today.

Integer micro-dollar accounting · versioned price table · no data leaves
VP of Engineering

Compare teams by yield, not usage

Consumption rewards exactly the wrong behavior. TIER compares teams on outcome-per-dollar, trends it per quarter, and catches waste mechanically — unattributed spend drags the ratio; reverted work loses most of its credit.

Deterministic · weighted aggregation · no black box to defend
Staff Engineer

Run it, audit it, defend it

A single Go binary with 3 direct dependencies. Run it on a laptop in minutes; read the whole tree in an afternoon. Capture is zero-config for Claude Code — nothing leaves your infrastructure.

Open-source · fail-closed · self-hosted

See how each team uses TIER →

Get better, not graded

Grade the work, not the worker.

Every prior metric graded the developer — and got gamed within a review cycle. TIER grades the work: outcome per dollar. The same number, in the open — so it guides how you optimize spend, not how you judge people.

Every developer

See your own yield. Optimize your own spend.

tierd score --repo . shows your own outcome-per-dollar — privately, on your laptop. Then raise it: tighter issue attribution, the right model for the task, less exploratory burn. A coaching signal for you, first.

Managers & leads

Review the same number, together.

In opt-in developer mode a lead and their team see the same transparent yield — never a hidden score. Use it to spread the high-yield practices and steer where the token budget goes — to coach, not to rank.

Honest by design: yield reflects task mix and context, not raw talent — a senior untangling legacy code can score below a junior on greenfield. TIER is a lever for optimizing spend, and it ships its own guidance that it is not a performance-appraisal input.

Why you can trust the number

Built to be read by the people it measures.

The audience is skeptical engineering and finance leadership. They will read the source. So the argument is architecture, not "trust us."

Deterministic & re-derivable

No LLM in the scoring path. The same rows always produce the same score — recompute it yourself from the stored data.

No conversation content, ever

The parser is an allowlist: token counts, model, timestamps, issue refs. No prompts, no completions, no code. Verified in security review.

Self-hosted, single binary

One Go binary over a SQLite file. No clustering, no external datastore, no new data processor. The data never leaves the organization.

It ships its own criticism

A 28-scenario adversarial analysis of the formula — including how to game it — ships with the code. The anti-sales document, in the box with the sales document.

Honest note we volunteer: DORA has 39,000+ data points of validation; TIER is early. We win on the fact that nothing else measures this at all — and on being checkable.

Read the source. Run the meter.

Stop guessing what your AI spend produces.

Self-hosted, deterministic, open-source. Install it and get a cost attribution for your own repo in about two minutes.

$go install github.com/tiermetric/tier/cmd/tierd@latest && tierd score --repo .