How dimensions are measured

Your overall score starts from equal base weights within your source, applies modest role-based adjustments, and rewards balanced strength across dimensions. A small quality adjustment based on correction rate applies when enough messages are available. Reference values shown below are engineer baselines and scale with inferred role. Each dimension explains what it measures, why it matters, how it's computed, and what to do to grow it.

Methodology version 3

Customization

What it measures.
Whether you configure your AI environment — CLAUDE.md, AGENTS.md, and MCP configs.

Why it matters.
The biggest leap from "user" to "operator" is when you start shaping the tool to your work, not the other way around.

How it's measured.
Sum of custom_mcp_config_writes and claude_md_writes (or agents_md_writes for Codex) over the rolling 30 days, log-normalized to a reference of 10. Skill file authorship is tracked separately under Custom Skills.

How to grow it.
Add a CLAUDE.md to your project that captures your conventions. Add one MCP server you'd use weekly.

Sources: Claude · Codex · Cowork · OpenCode · Cursor · Pi

Parallel Agents

What it measures.
Whether you're running multiple agents in parallel within a session or creating isolated worktrees for cross-process fan-out.

Why it matters.
Parallel orchestration is how senior operators compress hours into minutes — branching work across subagents and converging the results.

How it's measured.
Weighted blend of breadth (sessions with orchestration, log-normalized to a reference of 50), depth (parallel agent turns), and peak (max parallel agents in any session). Each signal uses its own role-scaled normalization. A small capped bonus is added when the scanner observes git worktree add commands. Worktree creation is treated as supporting evidence, not proof that another agent ran.

How to grow it.
Use the Agent tool to fan out independent subtasks. When two pieces of work don't depend on each other, launch them at the same time.

Sources: Claude · Codex · Cowork · OpenCode · Cursor · Pi

Background Work (was Context Leverage)

What it measures.
Whether you delegate work to run unattended — Cron, Task, or Monitor primitives.

Why it matters.
Senior operators don't sit and wait. They queue work, walk away, and come back to results.

How it's measured.
Sessions in which you used context-leverage tools (TaskCreate, ScheduleWakeup, CronCreate, Monitor, etc.), log-normalized to a reference of 80.

How to grow it.
The next time a subtask will take a while, schedule it via Task and switch contexts. Use Cron for nightly jobs you'd otherwise babysit.

Sources: Claude

Tool Breadth

What it measures.
How broadly you engage with skills and MCP servers.

Why it matters.
Skills and MCPs are how Claude Code reaches outside the conversation — into your tools, services, and data.

How it's measured.
Distinct count of skill_counts + mcp_server_counts in the 30-day window, log-normalized to a reference of 100.

How to grow it.
Install one MCP server you'd actually use weekly. Try a built-in skill you've been ignoring.

Sources: Claude · Codex · Cowork · OpenCode · Cursor · Pi

Planning

What it measures.
Structural follow-through on planning — a planning workflow followed by successful implementation, or a durable plan artifact — not every way you might plan.

Why it matters.
Plans cut rework. Power users front-load thinking and then act on it.

How it's measured.
A session earns credit when a planning signal — Claude's Plan agent, ExitPlanMode, Codex's native Plan Mode, or update_plan — is followed by a successful Write, Edit, or apply-patch in the same session and local date, or when the session writes a recognized plan artifact: a Markdown file under any plans/ directory at any depth (including .claude/plans/), or a PLAN.md or *-plan.md file. Qualifying sessions are log-normalized to a reference of 10. We never read plan content or judge plan quality, and we never upload artifact paths or transcript text — only the structural sequence is checked locally. Conversational planning without follow-through or an artifact is intentionally undercounted.

How to grow it.
Follow every plan with implementation in the same session, or write it down as a durable artifact under any plans/ directory (including .claude/plans/), or use PLAN.md or *-plan.md.

Sources: Claude · Codex

Repetition NEW

What it measures.
When you use a skill, do you go deep — or just try once?

Why it matters.
Repeat usage signals that a skill has become real practice, not a one-off experiment.

How it's measured.
Total invocations across skill_counts in the 30-day window, log-normalized to a reference of 20.

How to grow it.
Pick one or two skills and use them repeatedly across a week, instead of trying twenty different things once each.

Sources: Claude · Codex · Cowork · OpenCode · Pi

Custom Skills NEW

What it measures.
How many of your own custom skills you've authored and actively practice.

Why it matters.
Authoring a skill is one thing; making it part of your daily flow is the real signal. Writing your own automation and then using it repeatedly shows both investment and payoff.

How it's measured.
Blend of two signals, log-normalized to a reference of 8: the set of skill names you authored (detected via Write/Edit/apply_patch calls on ~/.claude/skills/<name>/... or ~/.codex/skills/<name>/... paths in your transcripts) intersected with your skill_counts keys, plus the summed practice counts for those authored skills. Namespace suffix-match applies: a plugin-installed skill named <plugin>:<name> still credits you if <name> matches a skill you authored locally and shipped back.

How to grow it.
Author a skill that automates a recurring task. Use it in real workflows. Share it back to your company plugin — the namespace suffix-match means you still get credit. Author another.

Sources: Claude · Codex · Cowork · OpenCode · Pi

Multi-Tasking NEW

What it measures.
How many concurrent sessions you run at peak — multi-tasking across distinct workstreams.

Why it matters.
Operators who run several workstreams at once are squeezing more value from the tool than serial users.

How it's measured.
Peak max_concurrent_sessions over the 30-day window, log-normalized to a reference of 15.

How to grow it.
Try Cowork or run two terminals. The next time you're blocked on one task, start the next.

Sources: Claude · Codex · Cowork · OpenCode · Cursor · Pi

Thinking Mode

What it measures.
Reasoning-block frequency per session.

Why it matters.
Reasoning blocks are where the model thinks before acting; high engagement maps to thoughtful operators.

How it's measured.
reasoning_blocks ÷ sessions, log-normalized to a reference of 20.

How to grow it.
Ask Codex to reason through edge cases before changing code.

Sources: Codex · OpenCode · Cursor · Pi

Schedule Reliability

What it measures.
How consistently your scheduled Cowork tasks actually run — reliability over time.

Why it matters.
Consistent scheduled tasks are the foundation of autonomous orchestration. Reliability compounds.

How it's measured.
Ratio of scheduled task completions to scheduled task definitions, log-normalized.

How to grow it.
Define more scheduled tasks and run them on a consistent cadence. Audit your scheduled tasks weekly — drop the ones you're not actually using.

Sources: Cowork

Queue Discipline

What it measures.
How actively you use Cowork's task queue — chaining work across runs.

Why it matters.
Chaining tasks in the queue multiplies Cowork's leverage — each run can feed the next.

How it's measured.
Queue event volume over the 30-day window, log-normalized.

How to grow it.
Cowork's queue lets you stack multiple tasks — try chaining work that builds on prior runs.

Sources: Cowork

Tracked but no longer scored

We removed these from the score because they were too easily saturated, didn't separate users in practice, or measured the wrong thing. We still capture the raw data so we can revisit if the user base diversifies.

• Prompt Efficiency — was constant 100 across users.
• Tool Diversity — saturated at the top of the cohort.
• Conversation Depth — saturated similarly.
• Basic Chat — measured the floor, not the ceiling.

Cowork

Cowork is a multi-workspace agent runner. When you run agents through Cowork, each session aggregates into your daily metrics like any other session.

Cowork sessions tend to score high on Parallel Agents (parallel agents are the default mode) and Custom Skills if you've authored Cowork-specific skills. Other dimensions are where Cowork operators usually find their next leverage.