📊 Insights Page — Feedback & Suggestions (Experimental Feature)

[shahariaazam]

Insights Page — Share Your Feedback (Experimental Feature)

We recently shipped the Insights page under Analytics. It analyses your Claude Code session JSONL files and surfaces productivity and efficiency metrics.

Before diving in, we want to be fully transparent: this is experimental. The formulas below are our first attempt at quantifying something inherently qualitative — how productively you are using Claude Code. They may not fit every workflow. We plan to iterate based on your feedback.

---

How the metrics are currently calculated

All metrics are computed by replaying the event stream of each Claude Code session JSONL file through a pipeline of independent processors.

Turn Count & Steps per Turn

A turn is counted each time a genuine user message arrives (non-sidechain, non-tool_result reply). A step is any non-skipped event in the session.

TurnCount       = number of genuine user messages
StepsPerTurnAvg = total events / TurnCount

Known limitations: programmatic tool responses that look like user messages could inflate the turn count; very short sessions (1 turn) are treated the same as long ones.

---

Autonomy Score (0–100)

This is the most experimental metric. It tries to capture how much Claude ran on its own between human interruptions.

logFactor = min(1.0, log(StepsPerTurnAvg + 1) / log(10))

if TurnCount <= 1:
    AutonomyScore = 100 × logFactor
else:
    AutonomyScore = 100 × (1 / TurnCount) × logFactor

AutonomyScore = clamp(AutonomyScore, 0, 100)

Interpretation: Fewer human turns + more steps per turn → higher score. A session where you sent one message and Claude ran 50 tool calls scores near 100. A back-and-forth conversation with many short turns scores low.

Known limitations: The 1/TurnCount factor drops fast — 2 turns gives 50×logFactor, 5 turns gives 20×logFactor. A long productive session with many turns still scores poorly. The log(10) normalization is arbitrary and the formula does not account for session intent (pair-programming naturally has many turns).

---

Tool Calls

ToolCallsTotal = count of tool_use blocks in assistant messages
ToolBreakdown  = per-tool counts  e.g. {"Bash": 40, "Read": 20}

The Top Tools chart shows the 10 most-called tools across all sessions in the selected period.

---

Tool Error Rate

ToolErrorCount = count of tool_result blocks where is_error: true
ToolErrorRate  = ToolErrorCount / total tool_result blocks
HasErrors      = ToolErrorCount > 0

Known limitations: is_error: true is set by Claude Code for certain tool failures, but not all failures set this flag. Some errors are silently retried and never appear in the stream.

---

Duration & Thinking Time

TotalDurationMs = timestamp(last event) − timestamp(first event)

For thinking time, the processor reads system{"subtype":"turn_duration"} events when present. When those are absent, it falls back to:

ThinkingTimeMs ≈ sum over thinking blocks of (len(thinking_text) × 0.5 ms/char)

The 0.5 ms/character fallback is a rough heuristic with no empirical basis.

Known limitations: TotalDurationMs includes idle time if you left a session open. ThinkingTimeMs is unreliable when turn_duration events are missing.

---

Cache Hit Rate

CacheHitRate = cache_read_input_tokens / (cache_creation_input_tokens + cache_read_input_tokens)

This comes directly from the usage field in assistant messages.

Known limitations: Sessions with no caching (e.g. very short sessions) show 0%, which may not indicate a problem.

---

Cost Estimate

Pricing tiers (per 1M tokens, sourced from Anthropic API pricing, February 2026):

Model tier	Input	Output	Cache write	Cache read
Opus	$5.00	$25.00	$6.25	$0.50
Sonnet	$3.00	$15.00	$3.75	$0.30
Haiku	$1.00	$5.00	$1.25	$0.10

The model is inferred from the model field on the first assistant message. Unknown models default to Sonnet pricing.

CostEstimateUSD = (inputTokens × inputRate
                 + outputTokens × outputRate
                 + cacheCreationTokens × cacheWriteRate
                 + cacheReadTokens × cacheReadRate) / 1_000_000

Known limitations: Pricing is hardcoded and will become stale. Batch API discounts, free tier, and enterprise pricing are not accounted for.

---

Conversation Depth

MaxConsecutiveToolCalls = longest unbroken run of tool_use blocks in a single assistant message
LongestAutonomousChain  = longest sequence of tool calls across the session without a genuine user message

---

Session Rhythm

AvgUserResponseTimeMs   = mean gap between last assistant event and next genuine user message
AvgClaudeResponseTimeMs = mean gap between a genuine user message and Claude's first reply

---

Overall Productivity Score (frontend only, 0–100)

Computed in the browser from the aggregated summary:

errorFreeRatio = (total_sessions - sessions_with_errors) / total_sessions

ProductivityScore = round(
  avg_autonomy_score       × 0.50
  + avg_cache_hit_rate×100 × 0.30
  + errorFreeRatio×100     × 0.20
)
ProductivityScore = clamp(ProductivityScore, 0, 100)

Weight rationale (highly arbitrary): Autonomy gets 50% because it captures the core use-case of Claude running long tasks independently. Cache efficiency gets 30% because it directly correlates with cost and speed. Error-free sessions get 20% as a quality signal.

Known limitations: The weights have no empirical grounding. A session with high autonomy but many errors still scores well. The formula heavily penalises interactive/pair-programming workflows.

---

What we would like to know

• Do any of these metrics feel misleading or wrong for your workflow?
• Is the Autonomy Score formula capturing what you expected? If not, what should "high autonomy" mean to you?
• Are the Productivity Score weights reasonable, or would you weight things differently?
• What metrics are missing that would help you understand your Claude Code usage better?
• Have you seen data that looks clearly wrong (e.g. a session scored 0 when you think it should be high)?

All feedback — including "this metric is useless" — is genuinely helpful. Drop a comment below! 👇

All planned work are available #101