Skip to main content
skill CX Codex

productivity-score — Claude Code skill: rate your session productivity

Turns Agent Monitor metrics into a 0–100 productivity scorecard: session completion, cache efficiency, turn speed, tool success and cost.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add hoangsonww/Claude-Code-Agent-Monitor --skill productivity-score -a claude-code
Open on GitHub

What productivity-score does

The skill builds a score from five blocks, 20% each: how many sessions finish, how well tokens are cached, whether tools succeed, how fast turns go, and what it all costs. Numbers come from Agent Monitor endpoints — /api/analytics, /api/sessions?limit=100, /api/pricing/cost, /api/workflows/{sessionId}. Cache hit rate is total_cache_read / (total_cache_read + total_input); tool success compares PostToolUse against PreToolUse.

Output is a table with a letter grade from A+ down to F, then three strengths, three areas to improve with steps, and a period comparison when you ask for one. Pass a period as an argument: "today", "this week", "last 30 days", a session ID, or "compare".

Agent Monitor has to be running. Without its API the endpoints return nothing and there is nothing to score. Install works through npx skills add for Claude Code, Codex, Cursor, OpenCode and Gemini CLI; GitHub Copilot uses gh skill install.

What it helps with

  • see how many sessions end in errors or get abandoned
  • check whether prompt caching is actually paying off
  • spot tools that fail most often
  • compare this week's output with last week's
  • work out the cost of one completed session

Example prompts for the agent

  • Run the productivity score for today
  • Compare this week's productivity with last week
  • Score session <sessionId>

How to install productivity-score

1Skills CLI (Vercel)

npx skills add hoangsonww/Claude-Code-Agent-Monitor --skill productivity-score -a claude-code

2Manually: put the files in place

~/.claude/skills/productivity-score/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/productivity-score/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about productivity-score

How do I install productivity-score in Claude Code?

Run npx skills add hoangsonww/Claude-Code-Agent-Monitor --skill productivity-score -a claude-code. The skill file lands at ~/.claude/skills/productivity-score/SKILL.md.

What does productivity-score do?

It scores your work from 0 to 100 across five Agent Monitor metrics: session completion, token efficiency, tool effectiveness, velocity and cost. You get a graded table plus strengths and improvement areas.

What does the skill need to run?

A running Agent Monitor whose endpoints /api/analytics, /api/sessions, /api/pricing/cost and /api/workflows/{sessionId} respond. The metrics come from there.

Source text

SKILL.md · MIT
---
name: productivity-score
description: >
  Calculate a productivity score using actual Agent Monitor metrics —
  session completion rates, cache efficiency (cache_read vs input),
  compaction pressure (baseline tokens), turn velocity (turn_count /
  total_turn_duration_ms), tool success ratio (PreToolUse vs PostToolUse),
  and the workflow intelligence API's complexity and effectiveness scores.
---

# Productivity Score

Calculate a productivity scorecard from the Agent Monitor's real data.

## Input

The user provides: **$ARGUMENTS**

Options: "today", "this week", "last 30 days", a session ID, or "compare" for period comparison.

## Data Sources

| Endpoint | Returns |
|----------|---------|
| `GET /api/analytics` | Token totals (`total_input`, `total_output`, `total_cache_read`, `total_cache_write` — baselines pre-summed), tool_usage top 20, daily_events/sessions, event_types, sessions_by_status, agents_by_status, avg_events_per_session, total_subagents |
| `GET /api/sessions?limit=100` | Sessions with metadata JSON: `thinking_blocks`, `turn_count`, `total_turn_duration_ms`, `usage_extras` (service_tier, speed, inference_geo) |
| `GET /api/pricing/cost` | Total cost with per-model breakdown |
| `GET /api/workflows/{sessionId}` | 11 workflow datasets: stats, orchestration, toolFlow, effectiveness, patterns, modelDelegation, errorPropagation, concurrency, complexity, compaction, cooccurrence |

## Score Components (each 0–100)

### 1. Completion Rate (20% weight)
From `sessions_by_status`:
- `completed / (completed + error + abandoned) × 100`
- Bonus for high completed-to-active ratio
- Penalty for abandoned sessions (wasted work)

### 2. Token Efficiency (20% weight)
From analytics `tokens` (baselines are pre-summed into totals):
- **Cache hit rate**: `total_cache_read / (total_cache_read + total_input) × 100`
  - Above 60% = excellent, below 30% = poor
- **Output concentration**: `total_output / total_input` — 0.3–0.8 is balanced

### 3. Tool Effectiveness (20% weight)
From `event_types`:
- **Success ratio**: Count `PostToolUse` / Count `PreToolUse` — should be ~1.0; gap = tool failures
- **API error rate**: Count `APIError` / total events — should be near 0
- From workflow `effectiveness` data: subagent completion rates, task success per type

### 4. Velocity (20% weight)
From session metadata:
- **Turns per session**: average `turn_count` across sessions
- **Turn speed**: average `total_turn_duration_ms / turn_count` — lower = faster
- **Events per session**: from `avg_events_per_session` in analytics overview
- **Thinking depth**: average `thinking_blocks` — more thinking = more thorough (neutral metric)

### 5. Cost Efficiency (20% weight)
From pricing:
- **Cost per completed session**: `total_cost / completed_sessions`
- **Cost trend**: comparing current period to previous (decreasing = improving)
- **Model optimization**: sessions using expensive models (Opus) for tasks subagents handle with Haiku/Sonnet

## Overall Score

Weighted sum → letter grade:
- **A+** (95-100), **A** (90-94), **B+** (85-89), **B** (80-84), **C+** (75-79), **C** (70-74), **D** (60-69), **F** (<60)

## Output Format

```
═══════════════════════════════════════
  PRODUCTIVITY SCORE: 87/100 (B+)
═══════════════════════════════════════
  Completion Rate   ████████░░  80/100
  Token Efficiency  █████████░  92/100
  Tool Effectiveness████████░░  85/100
  Velocity          █████████░  88/100
  Cost Efficiency   █████████░  90/100
═══════════════════════════════════════
```

Then: top 3 strengths, top 3 improvement areas with actionable steps, and period comparison if available.

© hoangsonww · MIT · hoangsonww/Claude-Code-Agent-Monitor

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set20

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor