We entered the third era of software development. The executors aren't human anymore. It's time to stop measuring people who aren't doing the work.

DORA was a revelation when it dropped. Finally — four numbers that told you if your team was actually shipping or just pretending to. Lead time. Deployment frequency. Change failure rate. Time to restore. Clean. Honest. Revolutionary for its time.

SPACE came later, added nuance. It said: productivity is multi-dimensional. It's not just output, it's satisfaction, communication, efficiency. A more humane framework. Also good for its time.

The problem? Their time is over. Both frameworks were designed around a silent assumption so obvious nobody bothered to write it down:

The human is the executor. The human writes the code. The human makes the commit. You measure the human, you measure the work.

That assumption is now false. And every dashboard still running on it is lying to you.

The three eras of software development

Era I The craftsman era: One dev, one editor, one terminal. You are the CPU. Metrics: lines of code, function points. Useless, but at least honest about what they were measuring.

Era II The DevOps era: Teams, pipelines, CI/CD. DORA and SPACE emerge. You measure flow, not code. A genuine improvement over everything before it.

Era III · now The executor era: Claude Code, Codex, Copilot, opencode, pi. The agent ships. You direct. Every prior metric framework breaks silently.

We didn't get a gentle transition. One day you're measuring commit frequency and it means "team velocity." The next, one developer prompts an agent 40 times in an afternoon and lands 200 commits. What does your DORA dashboard say? It says you're a 10x team. What it doesn't tell you: one of those 200 commits introduced a subtle concurrency bug that will take three days to find.

Why DORA breaks

Deployment frequency: Was a proxy for team activity. Now it's a proxy for agent speed. An idle dev with a noisy agent looks elite.

Lead time for changes: Collapses to minutes with agentic execution. The metric loses resolution exactly when you need it most.

Change failure rate: Still valid — but now you're measuring agent judgment, not human judgment. Different failure modes. Same number.

Time to restore: Agents also restore. Faster. But who directed the restoration? Was the resolution right or just fast?

The core issue: DORA metrics were meaningful proxies for human effort and team coordination. Agents invalidate the proxy. The number still changes — it just no longer means what you think it means.

Why SPACE breaks harder

SPACE is worse because it's explicitly about the human. Satisfaction. Performance. Activity. Communication. Efficiency. Every dimension assumes the developer is the one doing the doing.

But what's a developer's "activity" when their job is to write a clear prompt, review the output, and redirect the agent? Low keystrokes. Low commits directly authored. Possibly long pauses while the agent runs. By SPACE metrics, your best prompt engineer looks like your least productive employee.

SPACE was designed to humanize productivity measurement. In the executor era, it accidentally punishes the humans who are best at directing agents.

What actually needs to be measured now

If the human is the director of intent and the agent is the executor, the measurement layer needs to capture both — and understand the relationship between them. Four primitives matter:

• Prompt: Human intent, routed to an executor. The real unit of creative work.
• Commit: Execution output. Attributed to repo, branch, agent. Not just a count.
• LLM call: Tokens in, tokens out, cache ratio. The cost of execution — by model, by agent.
• Spec: Intent formalized. The leading indicator before the work even starts.

These four primitives form a graph. From that graph you can derive things DORA never could:

Spec written → Prompts issued → Tokens consumed → Commits landed

That's not a pipeline — that's an intent-to-execution trace. You can now ask: how many prompts did it take to get a spec into production? How token-efficient is this developer compared to last week? Which agent produces commits that survive the longest without rollback? Which repo has the worst prompt-to-commit ratio — and why?

None of those questions exist in DORA. None of them exist in SPACE. They're entirely new, and they're the questions that actually matter in the executor era.

The streak is back — but it measures something different

GitHub streaks became a cultural phenomenon because they captured something real: daily creative engagement. Then they became a joke, because people committed typo fixes at 11:58 PM to keep their streak alive.

In the executor era, a streak should measure intent consistency, not commit presence. Did you prompt today? Did you spec something? Did you push context into a session that produced real output? That's the signal. The commit is just the artifact of that signal having worked.

Local-first by default

One more thing the old frameworks got wrong: they assumed your data lives somewhere central. A dashboard. A JIRA. A GitHub organization. The executor era breaks that too — your most important work happens in terminal sessions on your local machine, spread across multiple agents, multiple repos, multiple branches, in the 30-minute window between your last meeting and dinner.

Any new productivity primitive has to be local-first. Captured in-process. Not a SaaS you have to configure and remember to open. Not a GitHub Action that only fires on push. Something that watches what you actually do, where you actually do it, and builds the record from the ground up.

The next generation of developer productivity measurement will be built at the PTY level, not the API level.

What comes next

DORA had a good run. SPACE made us think harder about what productivity even means for humans. But neither framework survived contact with the executor era.

We need a new primitives layer. One that treats the human as the director of intent, the agent as the executor, and the relationship between them — prompt quality, token efficiency, spec-to-commit ratio — as the actual signal worth measuring.

That's the framework worth building. That's the metric layer worth trusting.

I'm building it. It's called Covenant.

‍

Covenant — terminal-first telemetry for the executor era

Local SQLite. Zero cloud required. Captures prompts, commits, LLM calls, and specs — attributed to repo, branch, and context — so you can finally see what agentic development actually looks like from the inside.

‍