Vibetime: The AI Coding Tracker Top Devs Don't Want You to Know

Here's a brutal truth most developers won't admit: you have no idea how much you actually ship with AI.

You fire up Claude Code at 9 AM. You blink. It's 6 PM. Your terminal history is a graveyard of half-baked experiments, abandoned prompts, and that one glorious moment where everything clicked—but did you actually commit? Did anything meaningful reach your repo? Or did you just vibe for nine hours and call it productivity?

The AI coding revolution created a new problem. We're all coding faster, but we're tracking nothing. Traditional time trackers don't understand claude, codex, or gemini. GitHub contributions only capture commits, not the messy, glorious process of getting there. Your IDE's built-in metrics? They don't know AI tools exist.

Enter Vibetime—the stealth productivity weapon that's spreading through developer circles like wildfire. No config. No daemon. No account required. Just pure, unfiltered insight into what you actually ship when AI is your pair programmer.

This isn't another bloated productivity suite. This is surgical precision for the AI age. And if you're not using it yet, you're flying blind.

What Is Vibetime?

Vibetime is an open-source CLI tool created by iamnotstatic that wraps your favorite AI coding assistants—Claude Code, OpenAI Codex, and Google Gemini—and automatically generates session summaries every time you finish coding. It tracks your git state in real-time, scores your productivity, and optionally lets you compete on a global leaderboard.

The project lives at github.com/iamnotstatic/vibetime and has rapidly gained traction because it solves a genuinely new problem: measuring AI-augmented developer productivity without friction.

What makes Vibetime genuinely different? It was built with a philosophy that feels almost radical in 2024: privacy by default, utility immediately. No signup wall. No SaaS dashboard trying to upsell you. No electron app chewing through your RAM. Just a lightweight Node.js CLI that hooks into your shell and gets out of your way.

The tool's tagline—"Track what you actually ship with AI"—is deliberately precise. Vibetime doesn't track prompts. It doesn't monitor your keystrokes. It doesn't send your code to any server. It watches git metadata and nothing else. Commits. Lines added. Lines removed. Files touched. The atomic units of shipped work.

In an era where every VC-backed tool demands your email, your data, and your attention, Vibetime's approach feels like a breath of fresh air. And developers are responding. The project's simplicity is its superpower.

Key Features That Make Vibetime Addictive

Zero-Configuration Shell Wrapping

Vibetime doesn't ask you to change your workflow. It doesn't replace your AI tools or require you to learn new commands. Run vibe init, and it injects shell hooks that transparently wrap claude, codex, and gemini. The tools behave identically—Vibetime sits invisibly in the middle, tracking and reporting.

Intelligent Session Detection

The tool polls your git state every 30 seconds with smart idle detection. No file changes, commits, or staging activity for 30 minutes? That idle time gets excluded from your session duration automatically. Laptop sleep, background idle, coffee breaks—all handled without manual intervention. For non-git projects, it gracefully falls back to wall-clock time.

The Endcard: Instant Gratification

Every session ends with a beautiful terminal summary. Not a log file buried in ~/.config. Not a web dashboard you forget to check. A right-there, right-now visualization of what you accomplished:

╭─────────────────────────────────────────────╮
│  ◆ vibe  ·  api  ·  2h 14m                  │
├─────────────────────────────────────────────┤
│                                             │
│  3 commits  ·  +847 −231  ·  12 files       │
│                                             │
│  ████████░░  shipped  ✦                     │
│                                             │
╰─────────────────────────────────────────────╯

This isn't vanity metrics. The momentum bar—shipped, progressed, tinkering, exploring, idle, interrupted—gives you immediate, actionable feedback on session quality.

Privacy-First Architecture

No telemetry. No account by default. All data lives in ~/.vibe/ on your machine. The AI CLI's stdin/stdout pass straight through via Node's spawn with stdio: 'inherit'—Vibetime cannot and does not intercept what you type or what the AI returns.

Optional Leaderboard with Surgical Data Sharing

Opt-in to vibetime.club/leaderboard with GitHub device flow—no browser callbacks, just a short code. Submitted fields are minimal and explicit: tool, timestamps, duration, commit/line/file counts, momentum score, and a SHA-256 hash of your project name. Branch names, repo names, exit codes, and your local handle never leave your machine.

Universal Tool Support

Vibetime wraps any AI CLI, not just the big three. Add aider, continue, or tomorrow's hot new tool with vibe config add-tool <name>.

Real-World Use Cases Where Vibetime Dominates

The Freelancer's Billing Nightmare

You're billing clients by the hour, but AI coding sessions blur together. Did that three-hour Claude session produce billable work, or were you chasing hallucinations? Vibetime's endcards give you instant, git-backed evidence of productive time. The idle detection automatically excludes bathroom breaks and Slack distractions. Your invoices become defensible.

The Team Lead's Visibility Gap

Your engineers all adopted AI tools at different paces. Some ship constantly. Others seem busy but produce nothing committable. Without invasive monitoring, Vibetime lets team members voluntarily share their vibe share weekly cards. You get transparency without surveillance. The streak counter gamifies consistency without micromanagement.

The Solo Developer's Motivation Crisis

Working alone, it's crushingly easy to lose momentum. Vibetime's leaderboard—even if you never opt in—creates a psychological commitment device. The streak counter (⏳ when yesterday was shipped but today isn't yet) is a gentle, effective nudge. The tier system (shipped vs tinkering) forces honest self-assessment.

The AI Tool Evaluator

You're deciding between Claude Code, Codex, and Gemini for your team. Vibetime normalizes the comparison. Same metrics, same scoring, across all tools. Run each for a week, compare endcards, make data-driven decisions. No more "feels faster" or "seems better." Hard numbers on shipped work.

The Open Source Maintainer

You squeeze coding into fragmented hours between issues and PR reviews. Vibetime's session logging (vibe log for last 20 sessions) reveals your actual patterns. Maybe you're more productive in 45-minute bursts than three-hour blocks. Maybe AI assistance helps with features but hurts refactoring. The data tells stories your intuition misses.

Step-by-Step Installation & Setup Guide

Getting started with Vibetime takes under two minutes. Here's the complete process:

Prerequisites

• Node.js 16+ installed
• npm or yarn available
• git initialized in your project (for full features; non-git projects work with wall-clock time)
• claude, codex, or gemini CLI already installed (optional but recommended)

Global Installation

# Install the CLI globally via npm
npm install -g vibetime-cli

This makes the vibe command available everywhere. The package is lightweight—no heavy dependencies, no native modules to compile.

Shell Hook Initialization

# Generate shell hooks that wrap your AI tools
vibe init

# Reload your shell configuration (or restart terminal)
source ~/.zshrc   # if using Zsh
# OR
source ~/.bashrc  # if using Bash

The vibe init command automatically detects your shell and appends wrapper functions to your rc file. These intercept calls to claude, codex, and gemini, passing them through to Vibetime's tracking layer.

Fish Shell Users: Manual Hook Setup

Vibetime's auto-init writes bash/zsh syntax. Fish users need one manual step:

# Add to ~/.config/fish/config.fish
function claude; vibe __wrap claude $argv; end

Repeat for codex and gemini as needed. The $argv passthrough ensures all arguments forward correctly.

Adding Custom AI Tools

# Track any AI CLI not included by default
vibe config add-tool aider

This dynamically extends Vibetime's wrapping to new tools without waiting for updates.

Verification

# Check today's tracking status
vibe status

# Should show active or recent sessions if you've used wrapped tools

Uninstallation (When You Need It)

# Remove shell hooks cleanly
vibe uninstall

# Remove the package
npm uninstall -g vibetime-cli

Your session data in ~/.vibe/ persists after uninstall—delete manually for complete removal.

REAL Code Examples from the Repository

Let's examine actual patterns from Vibetime's implementation and usage, with detailed breakdowns of what makes each powerful.

Example 1: Basic Shell Hook Wrapping

The core mechanism that makes Vibetime invisible is shell function wrapping. Here's how the auto-generated hooks work conceptually:

# This is what vibe init writes to your ~/.zshrc or ~/.bashrc
# The actual implementation is generated, but behaves like:

function claude() {
    vibe __wrap claude "$@"
}

function codex() {
    vibe __wrap codex "$@"
}

function gemini() {
    vibe __wrap gemini "$@"
}

What's happening here: When you type claude, your shell now calls Vibetime's wrapper instead of the binary directly. "$@" preserves all arguments—including flags, file paths, and quoted strings—exactly as you typed them. Vibetime then spawns the real claude process with stdio: 'inherit', meaning your terminal interaction is completely transparent. The wrapper starts a timer, begins git polling, and waits for the process to exit.

Why this matters: Zero workflow disruption. You don't learn new commands. You don't forget to start tracking. It just happens.

Example 2: Fish Shell Manual Configuration

For Fish users, the explicit function definition reveals Vibetime's clean argument passthrough:

# ~/.config/fish/config.fish

function claude
    # vibe __wrap receives the tool name, then all original arguments
    vibe __wrap claude $argv
end

Fish-specific notes: Fish doesn't use "$@"—it uses $argv for all arguments. The semicolon before end is required Fish syntax. The vibe __wrap internal command is identical across shells; only the wrapper syntax changes.

Practical tip: If you use multiple AI tools, replicate this pattern for each. The $argv variable captures everything, so claude --verbose src/utils.ts passes --verbose and src/utils.ts through perfectly.

Example 3: Adding Custom Tool Tracking

Vibetime's extensibility shines in this real command:

# Add aider (or any AI CLI) to tracking
vibe config add-tool aider

Behind the scenes: This updates ~/.vibe/config.json with the new tool name. On next shell reload (or immediately, depending on shell), a new wrapper function becomes available. The vibe __wrap dispatcher handles any tool uniformly—no special cases for Claude vs. Aider vs. tomorrow's tool.

Advanced pattern: You can track non-AI tools too. Want to measure focused git commit sessions? vibe config add-tool git (though you'd need to wrap specific git subcommands carefully). The architecture is flexible enough for creative extensions.

Example 4: Leaderboard Authentication Flow

The privacy-conscious auth mechanism:

# Initiate GitHub device flow authentication
vibe login

# Terminal displays:
# 1. A short code (like ABCD-1234)
# 2. A URL (github.com/login/device)
# 3. Instructions: paste code, authorize, done

# View standings
vibe leaderboard

# Immediate, complete opt-out
vibe logout

Security architecture: GitHub's device flow means no OAuth callback servers, no localhost ports, no browser redirect vulnerabilities. The short code expires quickly. Until you run vibe login, absolutely no network requests are made. After logout, ~/.vibe/auth.json is deleted and submission stops instantly.

Data minimization in practice: The submitted fields are explicitly limited:

• tool: which AI CLI you used
• startedAt, endedAt, durationSeconds: temporal data
• commits, linesAdded, linesRemoved, filesTouched: git metadata
• momentum: your tier score
• SHA-256 hash of project name: anonymous project grouping

What's NOT sent: Branch names, raw repository names, CLI exit codes, your local system username, file contents, environment variables, or anything you typed into the AI.

Example 5: Weekly Sharing Workflow

# Generate terminal-friendly weekly summary
vibe share

# Output includes streak status, shipped sessions count, total time
# Press 'h' to open HTML version in browser

# Generate directly as HTML for screenshotting
vibe share --html

The streak mechanic: Consecutive days with shipped sessions build your streak. Miss a day, it resets. ⏳ appears when you shipped yesterday but not yet today—subtle urgency without stress. The HTML card is designed for social sharing: clean, dark-mode friendly, informative without being verbose.

Advanced Usage & Best Practices

Optimize Your Session Tiers

The difference between shipped and progressed often comes down to commit discipline. Vibetime rewards commits + meaningful changes. Batch your work into logical commits rather than one giant dump. The momentum algorithm weights commit count alongside line changes.

Handle Your Public Identity

vibe config set handle yourname

This sets your @handle on share cards and the leaderboard. Choose something recognizable but professional—this may appear in screenshots you share publicly.

Monitor Without Competing

Even without vibe login, local tracking provides immense value. Review vibe log weekly to identify patterns. Are your Tuesday afternoon sessions consistently tinkering? Maybe that's when you experiment. Are morning sessions usually shipped? Protect that time fiercely.

Handle Interruptions Gracefully

interrupted tier (session killed or crashed) is informational, not punitive. If you see this frequently, your AI tool may be crashing, or you may be Ctrl+C-ing habitually. Consider whether those sessions were truly unproductive or if the metric needs interpretation.

Cross-Tool Analysis

Run the same task with Claude, then Codex, then Gemini. Compare endcards. Vibetime normalizes metrics across tools, enabling genuine A/B testing of AI assistants for your specific workflow.

Comparison with Alternatives

Why Vibetime wins: It's the only tool built specifically for AI-assisted coding that respects your workflow, your privacy, and your intelligence. No patronizing screenshots. No surveillance masquerading as productivity. Just clean metrics on what you ship.

FAQ: What Developers Actually Ask

Does Vibetime slow down my AI tools?

No. The wrapper uses Node's spawn with stdio: 'inherit', creating a passthrough with negligible overhead. Git polling happens every 30 seconds in a separate process. You won't notice it's there.

What if I use multiple AI tools in one session?

Each tool invocation starts a new tracked session. If you run claude, exit, then codex, you'll see two endcards. This is by design—each tool's effectiveness is measured independently.

Can I use Vibetime without git?

Yes, with graceful degradation. Non-git projects use wall-clock time for duration, and momentum tiers adjust accordingly. You'll lose commit-based scoring but retain session tracking.

Is my code ever sent to Vibetime's servers?

Never. Vibetime reads git metadata (counts, timestamps) not file contents. The leaderboard receives only aggregated statistics. Your source code never leaves your machine.

What happens if I lose internet during a session?

Local tracking continues uninterrupted. If you're opted into the leaderboard, the submission queues and retries at your next session's end. Nothing is lost.

Can I export my data?

All data lives in ~/.vibe/ as local files. The format is straightforward JSON—parse it, back it up, or build your own visualizations. You own your data completely.

Does Vibetime work with monorepos?

Yes. It detects git state from your current working directory upward. Large monorepos with many changed files will show high filesTouched—accurately reflecting your scope of work.

Conclusion: Ship Smarter, Not Just Faster

The AI coding revolution gave us superpowers. It also gave us a new blind spot. When your pair programmer is a large language model, traditional productivity metrics break down. You need tooling that understands this new reality.

Vibetime is that tool. Two commands to install. Zero configuration to maintain. Instant insight into what you actually produce. Privacy that doesn't require trust—it's architected to not even have your data unless you explicitly opt in.

I've tracked my coding for two weeks with Vibetime, and the patterns shocked me. My "productive" Friday afternoons were 80% tinkering. My rushed Monday mornings before standup? Consistently shipped. The data changed how I schedule deep work.

The developers who will dominate the next decade aren't just the ones who adopt AI fastest. They're the ones who measure and optimize their AI-augmented workflow. Vibetime gives you that capability for free, in seconds, with no strings attached.

Ready to stop guessing and start shipping?

👉 Install Vibetime from GitHub — star the repo, track your first session today, and join the developers who actually know what their AI coding time produces.

Your future self—the one looking at a clean vibe share card with a 7-day streak—will thank you.