Prompt Tracker: Turn Your Coding Sessions into a Star Wars Opening Crawl

What if your coding sessions looked like a Star Wars opening crawl? Prompts scrolling through time, color-coded by quality, with dramatic bubbles floating across a timeline like ships in hyperspace?

Prompt Tracker transforms your Claude conversation history into an entertaining, interactive visualization—part productivity tool, part time-traveling dashboard, part cinematic experience. Watch your prompting habits unfold like an epic saga, rate your greatest hits, and learn from your mistakes—all while having way more fun than you should with a JSON log file.

It's both informative (analytics on your AI usage), productive (build a library of your best prompts), and genuinely entertaining (watching your 3am debugging sessions visualized as a chaotic cluster of red bubbles is oddly satisfying).

The Problem: Lost Conversations

Claude Code stores every conversation in ~/.claude/history.jsonl. While this is great for persistence, it's terrible for:

• Learning from patterns: Which prompts led to the best outcomes?
• Finding past solutions: "I remember asking about Docker networking last month..."
• Tracking productivity: When do I have the most productive Claude sessions?
• Building a prompt library: Which prompting techniques actually work for me?

Your conversation history is a goldmine of data about how you work with AI. But without tools to analyze it, those insights remain buried.

The Star Wars Effect: Your Coding Sessions as Cinema

The core feature is an interactive D3.js timeline that transforms your workday into a cinematic experience. Picture the Star Wars opening crawl, but instead of "A long time ago in a galaxy far, far away," it's "A productive Tuesday in your terminal..."

[Video: /videos/prompt-tracker-demo.mp4]

Each bubble is a prompt floating through time:

• Size = Prompt length (that desperate 500-word debugging plea? You'll see it)
• Color = Quality (green stars ⭐️, red disasters 💀, gray unknowns ❓)
• Position = When you asked it (2am cluster? We've all been there)
• Swim lanes = Projects (watch them flow like parallel storylines)

The fun part? You can zoom into the chaos, pan across your day like a camera sweep, filter by project to see one saga at a time, and click any bubble to relive the moment—complete with a side panel where you can rate it from 1 to 5 stars.

It's like watching a replay of your coding session, but with production value.

Here's what it looks like in action:

[Cast recording: /casts/prompt-tracker-cli-demo.cast]

The CLI in action: checking stats, listing prompts, and generating timelines

The interactive timeline showing a day's worth of conversations

How It Works

Prompt Tracker is a single Python script (no dependencies!) that syncs data from Claude's history file into a local SQLite database:

# Sync your Claude history
./prompt-tracker sync

# Generate today's timeline (auto-opens in browser)
./prompt-tracker timeline 2025-10-02

# Or start a web server for interactive browsing
./prompt-tracker serve --port 8080

# Rate your favorite prompts
./prompt-tracker rate 42 5

# Search for specific topics
./prompt-tracker list --search "docker"

# Filter by project
./prompt-tracker list --project /Users/you/repos/myproject

# Find your best work
./prompt-tracker list --min-rating 4

# Export as JSON for custom analysis
./prompt-tracker list --format json

Web Interface Mode

The serve command launches a local web server that turns prompt browsing into a fully interactive experience:

./prompt-tracker serve --port 8080

This opens an interface where you can:

• Navigate between different dates with URL routing (/timeline/2025-10-02)
• Rate prompts directly in the browser with AJAX updates
• Filter and explore without regenerating static HTML files
• Keep the server running while you work, refreshing to see new prompts

Think of it as the difference between watching a movie on DVD (static timelines) versus streaming (live web interface).

The Database Schema

At its core, Prompt Tracker maintains two simple tables:

# Prompts table - imported from history.jsonl
CREATE TABLE prompts (
    id INTEGER PRIMARY KEY,
    timestamp INTEGER UNIQUE NOT NULL,
    display TEXT NOT NULL,
    project TEXT,
    created_at DATETIME
)

# Ratings and notes - your annotations
CREATE TABLE prompt_metadata (
    prompt_id INTEGER PRIMARY KEY,
    rating INTEGER CHECK(rating >= 1 AND rating <= 5),
    note TEXT,
    updated_at DATETIME
)

This separation means your annotations never touch the original history file—all ratings and notes stay local.

Real-World Use Cases

1. Building a Prompt Library

After rating hundreds of prompts, patterns emerge. I noticed my 5-star prompts often share characteristics:

• Specific context: "In this React app using TypeScript and Vite..."
• Clear success criteria: "The function should handle these three edge cases..."
• Example-driven: "Like this pattern we used in auth.ts..."

Now when I face a new problem, I search my highest-rated prompts for similar situations:

prompt-tracker list --min-rating 4 --search "typescript error handling"

This reveals my own best practices—not generic advice, but patterns that have worked specifically for my projects.

2. Debugging Prompt Engineering

Sometimes a prompt doesn't work. Was it too vague? Too specific? Missing context?

The timeline visualization makes this obvious. I can see:

• Clusters of low-rated prompts → I was struggling with something
• Long gaps between prompts → Complex task or Claude got stuck
• Rapid-fire sequences → Iterative refinement working well

Color-coding by rating reveals temporal patterns—are my morning prompts more effective than late-night ones?

3. Tracking Productivity Patterns

The 24-hour timeline shows when I'm most productive with Claude:

• Morning (9-11am): Complex architecture discussions
• Afternoon (2-4pm): Bug fixes and refactoring
• Evening (7-9pm): Experimental projects

This data-driven insight helps me schedule challenging work during high-effectiveness windows.

4. Knowledge Transfer to Memento

When I find a particularly valuable prompt, I can publish it to my Memento knowledge base:

prompt-tracker publish 42

This extracts the prompt and creates a Memento note with:

• The original prompt text
• Any ratings and notes I've added
• Timestamp and project context
• Tags for searchability

These notes become part of my long-term LLM memory, available in future Claude sessions.

The Architecture

Prompt Tracker embraces simplicity:

Single-file executable: The entire CLI is one Python script. No installation, no dependency hell—just chmod +x and run.

Zero dependencies for core features: SQLite is built into Python. JSON parsing is standard library. The CLI works anywhere Python 3.7+ exists.

Progressive enhancement: The timeline visualization loads D3.js from CDN. If you're offline, you still have full CLI functionality.

Local-first: Everything stays on your machine. No cloud services, no analytics, no data leaving your computer.

Statistics Dashboard

Beyond visualizations, Prompt Tracker provides statistical insights:

$ prompt-tracker stats

Total prompts: 1,247
Rated prompts: 89 (7.1%)
Average rating: 3.67

Rating distribution:
  ★☆☆☆☆    8  ████████
  ★★☆☆☆   14  ██████████████
  ★★★☆☆   31  ███████████████████████████████
  ★★★★☆   26  ██████████████████████████
  ★★★★★   10  ██████████

Top projects by prompt count:
  blog-automation: 156
  memento:        142
  appdaemon:      89

This reveals:

• How much you rely on Claude
• Whether you're consistently getting value (rating trends)
• Which projects generate the most questions
• Opportunities to improve (lots of 1-star prompts? time to refine your approach)

Advanced Features

Full-Text Search

SQLite's built-in text search makes finding past conversations instant:

# Find that Docker networking conversation from last month
prompt-tracker list --search "docker network" --date-from 2025-09-01

# All your highest-rated debugging sessions
prompt-tracker list --min-rating 4 --search "bug"

Notes and Context

Sometimes the prompt alone doesn't capture why it worked:

# Add context about what made this prompt effective
prompt-tracker note 42 "Great example of providing full error stack trace"

# Later, review notes on all your top prompts
prompt-tracker list --min-rating 4

Notes become a meta-layer of learning—documenting not just what you asked, but why it was effective.

Project Filtering

The timeline's project-based swim lanes let you focus on specific areas:

• Click a project name to filter the timeline
• See all conversations related to one codebase
• Compare prompt patterns across different projects

Word Cloud Analysis

Bonus: Prompt Tracker includes scripts for linguistic analysis:

# Generate word cloud from all your prompts
python create_wordcloud.py

# Technical terms only (filters out common words)
python create_technical_wordcloud.py

These visualizations reveal your vocabulary patterns—do you ask about "bugs" or "issues"? "functions" or "methods"? The language you use affects Claude's responses.

Implementation Highlights

Efficient Syncing

The sync operation uses SQLite's INSERT OR IGNORE to handle the append-only history file:

def sync(self, history_path):
    cursor = self.conn.cursor()
    new_count = 0

    with open(history_path, 'r') as f:
        for line in f:
            entry = json.loads(line)
            cursor.execute("""
                INSERT OR IGNORE INTO prompts (timestamp, display, project, pasted_contents)
                VALUES (?, ?, ?, ?)
            """, (entry['timestamp'], entry['display'], entry.get('project', ''), ...))

            if cursor.rowcount > 0:
                new_count += 1

    return new_count

The UNIQUE constraint on timestamp ensures no duplicates, and INSERT OR IGNORE makes re-running sync idempotent.

Interactive Timeline Generation

The timeline uses D3.js with a custom time scale:

// Map timestamps to 24-hour positions
const xScale = d3.scaleLinear()
    .domain([0, 24 * 60 * 60 * 1000])  // 24 hours in milliseconds
    .range([0, width]);

// Color by rating
const colorScale = d3.scaleLinear()
    .domain([1, 3, 5])
    .range(['#ff4444', '#ffaa00', '#44ff44']);

Each prompt becomes an SVG circle with zoom/pan support and hover interactions.

Getting Started

Installation takes 30 seconds:

# Clone and make executable
git clone https://github.com/charignon/prompt_tracker.git
cd prompt_tracker
chmod +x prompt-tracker

# Sync your history
./prompt-tracker sync

# Generate today's timeline
./prompt-tracker timeline $(date +%Y-%m-%d)

The timeline opens automatically in your default browser.

Integration with Existing Tools

Prompt Tracker complements other productivity tools:

With Memento: Export valuable prompts as Memento notes for long-term memory

With Git: The SQLite database can be version-controlled, synced across machines

With Analytics: Export data as JSON for custom analysis in R, Python, etc.

With Note-taking: Copy high-rated prompts into documentation, READMEs, guides

What I've Learned

After tracking 1,200+ prompts over several months:

Rating prompts immediately is crucial. Wait a day and you forget what made it good or bad. Rate right after you see the response.

The best prompts are specific. 5-star prompts average 3x longer than 1-star prompts. Context matters.

Patterns emerge unexpectedly. I didn't realize how often I ask about "testing patterns" until the word cloud showed it as my #2 topic.

Visual feedback changes behavior. Seeing red clusters on the timeline makes me more thoughtful about next prompts.

Knowledge compounds. Exporting prompts to Memento creates a feedback loop—Claude gets better context, leading to better prompts, which get added to Memento...

Future Directions

Ideas I'm exploring:

AI-powered clustering: Use embeddings to group semantically similar prompts, revealing topics beyond keyword matching

Prompt templates: Extract patterns from 5-star prompts to generate templates for common tasks

Collaborative learning: Anonymous sharing of highly-rated prompts to learn from the community

Conversation threading: Link related prompts across sessions to show how solutions evolved

Export to Claude: Feed your best prompts back into Claude as examples of effective communication

Conclusion

Who knew analyzing your prompting habits could be this entertaining?

Prompt Tracker proves that productivity tools don't have to be boring. By turning your Claude conversation history into a cinematic timeline—complete with color-coded bubbles, zoom controls, and Star Wars-level drama—it makes self-reflection actually fun.

You get the productivity benefits (learning from patterns, building a prompt library, tracking what works), the analytical insights (which topics dominate, when you're most effective, how your style evolves), and the sheer entertainment value of watching your 3am debugging sessions play out like an action sequence.

Every prompt is a tiny experiment. With Prompt Tracker, you don't just see which experiments succeed—you watch them unfold across time like chapters in an epic saga. And honestly? That's way more engaging than staring at a JSON file.

So go ahead: turn your coding sessions into cinema. Rate your greatest hits. Learn from your disasters. And maybe, just maybe, have some fun while becoming a better prompt engineer.

---

Prompt Tracker is open source at github.com/charignon/prompt_tracker. It's a single Python script with zero dependencies. MIT licensed—use freely and contribute improvements.