Setting the file. One moment. Running Work Transitions
- Commits made during the session (timestamps, messages, changed files)
- Diffs showing actual code changes and their scope
- Branch activity and merge patterns
- File modification frequency and complexity
- Number of files modified/created/deleted
- Lines of code added/removed
- Commit frequency and granularity
- Commit message quality and clarity
~/.claude/projects/{project-dir}/{session-id}.jsonl - Claude Code native session logs (JSONL format)
- Project directory is calculated by transforming absolute working directory:
$(echo "${PWD}" | sed 's/\//\-/g')
- Example:
/Users/user/project becomes ~/.claude/projects/-Users-user-project/
- Tool usage patterns (which tools were called, frequency, success rates)
- Error messages and retry patterns
- Decision-making rationale in responses
- Repeated tool calls suggesting exploration or confusion
- Error recovery patterns
- Context switches and task transitions
- Clarification requests and user interactions
- Test coverage changes (new tests added, coverage percentages)
- Code quality indicators (complexity, duplication, adherence to standards)
- Documentation updates (README, inline comments, API docs)
- Build and compilation status
- Test-to-production code ratio
- Compilation success/failure
- Adherence to project coding standards
- Documentation completeness
- Session goals and whether they were achieved
- User satisfaction with outcomes
- Pain points or friction during the session
- Specific examples of what worked well or poorly
- Direct prompting: “What were your goals for this session?”
- Targeted questions: “Which parts of this session were most/least effective?”
- Outcome validation: “Did the implementation meet your expectations?”
What to Examine (when applicable):
- Which sub-agents were invoked during the session
- Task handoffs between Claude and sub-agents
- Sub-agent success rates and output quality
- Communication clarity in agent instructions
- Invoke sub-agents with retrospective prompts
- Ask about instruction clarity, tool availability, context sufficiency
- Gather suggestions for improved coordination
- Compilation succeeds without errors
- Tests pass with appropriate coverage
- Code follows project standards and patterns
- Security considerations properly addressed
- Minimal rework or backtracking
- Efficient tool usage (right tool for the task)
- Clear progression toward stated goals
- Effective user-Claude communication
- Applying lessons from earlier in session
- Recognizing and correcting mistakes
- Adapting approach based on feedback
- Discovering and using existing patterns
- Compilation failures or test failures
- Deviations from project architecture/style
- Security vulnerabilities introduced
- Missing or inadequate documentation
- Repeated failed attempts at same task
- Excessive tool calls without progress
- Misunderstanding requirements (multiple clarifications)
- Creating new patterns when existing ones should be used
- Ambiguous instructions leading to wrong implementations
- User frustration or confusion
- Missing context causing incorrect assumptions
- Inadequate status updates or progress visibility
- Duration: Total time from session start to completion
- Task Count: Number of distinct tasks/subtasks completed
- File Impact: Files created, modified, deleted
- Code Volume: Lines added, removed, net change
- Compilation Rate: % of time code compiled successfully
- Test Coverage: Coverage percentage change during session
- Rework Rate: % of changes that required revision
- Standard Compliance: Adherence to project coding standards
- Tool Success Rate: % of tool calls that succeeded on first attempt
- Context Switches: Number of major topic/task transitions
- Clarification Rate: User questions per task completed
- Completion Rate: % of stated goals fully achieved
- Satisfaction: User-reported satisfaction (if gathered)
- Friction Points: Number of reported pain points
- Value Delivered: User assessment of outcome usefulness
- Would Repeat: User willingness to use approach again
- Successful Approaches: What techniques led to good outcomes?
- Problematic Patterns: What approaches caused issues?
- Reusable Solutions: What can be extracted for future use?
- Context-Specific Learnings: What only applies to this project/task type?
- Instruction Clarity: Were instructions clear and actionable?
- Context Sufficiency: Was enough context provided upfront?
- Feedback Loops: How well did iterative feedback work?
- User Engagement: Appropriate level of user involvement?
- Architecture Alignment: Proper use of established patterns?
- Code Quality: Maintainable, readable, well-structured code?
- Testing Rigor: Appropriate test coverage and quality?
- Security Awareness: Proper handling of security considerations?
- Executive Summary: High-level overview of session outcomes
- Quantitative Metrics: Data-driven assessment of performance
- Qualitative Insights: Pattern analysis and learnings
- Action Items: Specific, prioritized improvements for future sessions
- Every recommendation should be specific (not vague)
- Include evidence from session data to support claims
- Provide implementation guidance for improvements
- Prioritize based on impact and feasibility
- Users: Want to know if goals were met, what to improve
- Future Claude sessions: Need actionable patterns to replicate or avoid
- Marketplace consumers: Need to understand value and use cases
- Plugin developers: May extend or integrate with other tools
This context provides a comprehensive framework for analyzing Claude Code sessions systematically and generating valuable retrospective insights.