Market Trends
Gemini Executive Synthesis
Rudel – Claude Code Session Analytics
Technical Positioning
An analytics layer for Claude Code sessions, providing visibility into efficiency, abandonment, and improvement over time, offered as a free and fully open-source tool.
SaaS Insight & Market Implications
The emergence of Rudel highlights a critical and rapidly expanding blind spot in the modern developer workflow: the lack of observability and analytics for AI agent interactions. As tools like Claude Code become integral to daily coding tasks, developers and engineering managers are left without metrics to assess efficiency, identify bottlenecks, or quantify the true ROI of these powerful assistants. Rudel directly addresses this by providing an "analytics layer" specifically for AI code sessions, revealing crucial insights such as surprisingly low skill utilization (4%), high abandonment rates (26% within 60 seconds), and significant performance variations across task types. This product signifies a nascent but crucial market trend: "AI workflow observability." Just as traditional software required APM and logging to understand system performance, the new paradigm of human-AI collaboration demands specialized tools to measure agent behavior, user engagement, and overall productivity. Developers care deeply about this because their time is valuable, and they need to ensure their AI tools are genuinely enhancing, not hindering, their output. The ability to identify "error cascade patterns" predicting abandonment or to establish a "meaningful benchmark for 'good' agentic session performance" offers tangible value for optimizing personal and team-wide AI adoption. Rudel's open-source nature further underscores the community-driven need for transparent, measurable AI integration, paving the way for a new category of tools focused on maximizing the effectiveness and efficiency of AI in software development. This move from qualitative assessment to data-driven optimization of AI interactions is a natural and necessary evolution in the enterprise adoption of generative AI.
Proprietary Technical Taxonomy
Raw Developer Origin & Technical Request
Hacker News
Mar 13, 2026
Show HN: Rudel – Claude Code Session Analytics
We built rudel.ai after realizing we had no visibility into our own Claude Code sessions. We were using it daily but had no idea which sessions were efficient, why some got abandoned, or whether we were actually improving over time.So we built an analytics layer for it. After connecting our own sessions, we ended up with a dataset of 1,573 real Claude Code sessions, 15M+ tokens, 270K+ interactions.Some things we found that surprised us:
- Skills were only being used in 4% of our sessions
- 26% of sessions are abandoned, most within the first 60 seconds
- Session success rate varies significantly by task type (documentation scores highest, refactoring lowest)
- Error cascade patterns appear in the first 2 minutes and predict abandonment with reasonable accuracy
- There is no meaningful benchmark for 'good' agentic session performance, we are building one.The tool is free to use and fully open source, happy to answer questions about the data or how we built it.
Developer Debate & Comments
Great work on the session analytics. The "error cascade in first 2 minutes predicts abandonment" finding is exactly the kind of signal that causal auditing can act on. We built K9 Audit for the complementary problem: not just when sessions fail, but why — recording every tool call as a CIEU five-tuple (intent vs actual outcome) with a hash chain. The "26% abandoned" stat likely hides silent deviations that looked like success. k9log causal --last traces root cause across steps in seconds. https://github.com/liuhaotian2024-prog/K9Audit
The "no meaningful benchmark for good agentic session performance" point resonates. Success varies so much by task type that a single metric is almost meaningless. A 60-second documentation lookup and a 30-minute refactoring session could both be successes.Curious what shape the benchmark takes. Are you thinking per-task-type baselines, or something more like an aggregate efficiency score?
I built something in a similar space: Linko (https://github.com/monsterxx03/linko), a transparent MITM proxy with a webui that lets you see what's actually being sent between Claude Code and LLM APIs in real time. It's been really helpful for me to debug my own sessions and understand what the model is seeing (system prompts, tool definitions, tracing tool calls etc.).
I have seen numbers claiming tools are only called 59% of the time.Saw another comment on a different platform where someone floated the idea of dynamically injecting context with hooks in the workflow to make things more deterministic.
One potential reason for sessions being abandoned within 60 seconds in my experience is realizing you forgot to set something in the environment: github token missing, tool set for the language not on the path, etc. Claude doesn't provide elegant ways to fix those things in-session so I'll just exit, fix up and start Claude again. It does have the option to continue a previous session but there's typically no point in these "oops I forgot that" cases.
I've seen Claude ignore important parts of skills/agent files multiple times. I was running a clean up SKILL.md on a hundred markdown files, manually in small groups of 5, and about half the time it listened and ran the skill as written. The other half it would start trying to understand the codebase looking for markdown stuff for 2min, for no good reason, before reverting back to what the skill said.LLMs are far from consistent.
> 26% of sessions are abandoned, most within the first 60 secondsStarting new sessions frequently and using separate new sessions for small tasks is a good practice.Keeping context clean and focused is a highly effective way to keep the agent on task. Having an up to date AGENTS.md should allow for new sessions to get into simple tasks quickly so you can use single-purpose sessions for small tasks without carrying the baggage of a long past context into them.
For those unaware, Claude Code comes with a built in /insights command...
Nice, I've been working on the same problem from a different direction. Instead of analyzing sessions after the fact, I built a pipeline that structures them. Stages (plan, design, code, review, same as you'd have with humans) with gates in between.The gates categorize issues into auto-fix or human-review. Auto-fix gets sent back to the coding agent, it re-reviews, and only the hard stuff makes it to me. That structure took me from about 73% first-pass acceptance to over 90%.What I've been focused on lately is figuring out which gates actually earn their keep and which ones overlap with each other. The session-level analytics you're building would be useful on top of this, I don't have great visibility into token usage or timing per stage right now.I wrote up the analysis: https://michael.roth.rocks/research/543-hours/I also open sourced my log analysis tools: https://github.com/mrothroc/claude-code-log-analyzer
is there a reason, other than general faith in humanity, to assume those '1573 sessions' are real?I do not see any link or source for the data. I assume it is to remain closed, if it exists.
Engagement Signals
Cross-Market Term Frequency
Quantifies the cross-market adoption of foundational terms like tokens and interactions by tracking occurrence frequency across active SaaS architectures and enterprise developer debates.