BlameContext - AI Context Injector for git blame and Code History

Run 'git blame' and see not just who changed a line, but WHY: the linked PR description, the related issue, the commit message context. Turns cryptic blame output into actionable understanding.

𝕏 Post Reddit HN

Difficulty

beginner

What is it?

Developers see a weird line of code and run git blame to find 'this was added 6 months ago by bob' but no context on WHY. BlameContext lives in your terminal and augments git blame output by fetching the PR description, linked GitHub issues, related commits, and team Slack discussion (optional). When you hover over a line or run 'blame-context path/to/file:line', it returns: the commit message, PR title and description, issue context if linked, and (optionally) the Slack thread where it was discussed. Monetize via: free tier (GitHub API only, public repos), $9/month pro (private repos + Slack threading + commit log depth). Why 100% buildable right now: GitHub API is rock-solid, Claude can summarize PR descriptions and issues in seconds, and terminal UI via Node.js is trivial. No model training needed — pure prompt engineering on existing GitHub data.

Why now?

Developers are consolidating on GitHub and struggling with code context during onboarding and refactoring. Claude's API (claude-haiku) is now cheap enough — roughly $0.001 per blame query — for per-query summarization economics to work. CLI developer tools are having a renaissance driven by AI-augmented terminal workflows (tools like gh, lazygit, and delta have all hit mainstream adoption recently).

▸git blame augmentation with PR and issue context (Implementation: GitHub API to fetch PR, Claude to summarize)
▸Terminal output formatting (use chalk for colors)
▸Slack thread linking optional
▸Local caching to avoid API quota exhaustion

Target Audience

Software engineers at small teams (5–30 people) doing active refactoring or code reviews. ~200k developers using git blame weekly.

Example Use Case

Alex, an engineer at a 15-person startup, is reviewing a function and sees a weird guard clause. She runs 'blame-context -f src/auth.js -l 42'. The tool returns: the commit message 'fix: add session hijacking check', the PR description 'fixes #847 (security issue)', and the linked issue description. She understands the context instantly instead of scrolling through history.

User Stories

▸As a developer doing code review, I want to understand WHY a line exists, so that I make informed review comments.
▸As a junior engineer, I want instant context on unfamiliar code, so that I ramp up 40% faster.
▸As a tech lead, I want my team to understand code history, so that I reduce repeated mistakes.

Acceptance Criteria

CLI: done when user can run 'blame-context -f file.js -l 42' and get output. GitHub API: done when PR description and issue title are fetched correctly. Claude: done when PR/issue text is summarized to 2–3 sentences. Caching: done when second query for same commit returns result in under 100ms. Billing: done when pro tier users can parse private repos and free tier users get API error.

Is it worth building?

$9/month × 70 users = $630 MRR at month 3. $9/month × 200 users = $1,800 MRR at month 6.

Unit Economics

CAC: $3 via organic npm and Twitter. LTV: $108 (12 months at $9/month). Payback: 2 weeks. Gross margin: 85%.

Business Model

Freemium CLI tool.

Monetization Path

Free: public GitHub repos, basic blame context. Pro: private repos, Slack linking, historical depth.

Revenue Timeline

First dollar: week 3 via pro plan (realistic given npm discovery lag). $200 MRR: month 3 (roughly 22 paid users via organic npm and Twitter). $800 MRR: month 6 (roughly 89 paid users). $2k MRR: month 12 (roughly 222 paid users, requires active marketing and ProductHunt launch).

Estimated Monthly Cost

Claude API: $15, Stripe fees: ~$5, domain: $1. Total: ~$21/month at launch (very lean).

Profit Potential

Viable at $2k–$5k MRR as a side project; tough for full-time (high churn on small audience).

Scalability

Medium — can expand to VS Code extension, JetBrains plugin, and team analytics on code churn.

Success Metrics

Week 1: 80 npm installs (realistic for a developer tool with a demo tweet). Week 2: 5 pro conversions (6% paid conversion from installs is achievable for a niche CLI). Month 2: 40% monthly retention (developer CLI tools have high churn; 40% is honest for a $9 tool without a team plan).

Launch & Validation Plan

Post in dev communities (Hacker News, r/webdev, Dev.to), recruit 8 beta testers from Twitter and Reddit, measure daily activation.

Customer Acquisition Strategy

First customer: tweet with GitHub link showing demo of blame-context on a real repo, invite DMs for free month. Ongoing: ProductHunt (Apps), npm discovery, Hacker News, Dev.to, Twitter threads on debugging workflows.

What's the competition?

Competition Level

Low

What's the roadmap?

Feature Roadmap

V1 (launch): blame + PR/issue context, caching, Stripe gating. V2 (month 2-3): Slack thread linking, git history graph, custom formatting. V3 (month 4+): VS Code extension, JetBrains plugin, team dashboards.

Milestone Plan

Phase 1 (Week 1): CLI scaffold, git blame parsing, GitHub API integration, Claude summarization (MVP: blame + PR context working). Phase 2 (Week 2): Stripe billing, caching, npm publishing, documentation. Phase 3 (Month 2): ProductHunt launch (if relevant), 10+ paid users, performance tuning.

How do you build it?

Tech Stack

Node.js CLI, GitHub API (@octokit/rest), Claude API for summarization, Stripe for billing, better-sqlite3 for caching — build with Cursor.

Suggested Frameworks

Time to Ship

2 weeks

Required Skills

Node.js CLI, GitHub API, Claude API, terminal UI.

Resources

GitHub API docs, Octokit library, Node.js CLI tutorial, Stripe CLI.

MVP Scope

Node.js CLI entry point, GitHub API integration, Claude summarization, local SQLite cache, Stripe billing gating, npm package publish.

Core User Journey

Install npm package -> run blame-context -f file.js -l 10 -> see PR + issue context in terminal -> pay for pro tier.

Architecture Pattern

User runs CLI command -> parse git blame output locally -> fetch GitHub PR/issue via API with caching -> Claude summarizes -> format terminal output -> optional Slack lookup -> display to user.

Data Model

Installation has one GitHubAuth. BlameQuery has one GitHubCommit, one PRContext, one IssueContext. CacheEntry stores recent queries.

Integration Points

GitHub API for PRs/issues, Claude API for summarization, Stripe for billing, Slack API optional, npm registry for distribution.

V1 Scope Boundaries

V1 excludes: VS Code extension, JetBrains plugin, Slack threading, team analytics, custom AI training, git history graph visualization.

Success Definition

A developer installs via npm, runs blame-context on a private repo, sees PR and issue context, pays $9/month, and uses it 3+ times per week.

Challenges

GitHub API rate limits (60 unauthenticated, 5000 authenticated). Slack integration requires workspace approval. Teams may not want to expose PR descriptions to CLI for security reasons.

Avoid These Pitfalls

Do not parse 'git blame' human-readable output with regex — use 'git blame -p' (porcelain mode) which gives structured key-value output and is stable across git versions and locales. Do not use GitHub's commit-to-PR API on forked repos — it only works on the base repo; always resolve the remote origin URL first and handle fork scenarios gracefully. Do not call Claude for every single blame line if a user passes a range — deduplicate by commit SHA so 10 lines changed in one commit only trigger one Claude call. Do not store GitHub tokens in SQLite or plaintext config without warning the user — instruct them to use a GitHub fine-grained token scoped to 'read:repo' only, not a classic PAT with broad permissions. Do not assume PR descriptions contain useful context — many PRs have empty bodies; detect this and fall back to displaying only the commit message rather than sending empty text to Claude and wasting tokens. Do not silently fail when the commit SHA has no associated PR (e.g. direct pushes to main) — display the raw commit message clearly and explain why no PR context was found. Do not hardcode GitHub.com API URLs — some teams use GitHub Enterprise with custom hostnames; make the base URL configurable via GITHUB_API_URL env variable from day one.

Security Requirements

Auth: GitHub token (user provides, stored locally in .env). Rate limiting: 100 API calls per hour per user via Stripe webhook. Input validation: file paths must be within git repo. Data: no storage of PR/issue text beyond cache; delete cache on --clear flag.

Infrastructure Plan

Hosting: npm registry (distribution only). Local: SQLite cache in ~/.blame-context/. CI/CD: GitHub Actions for npm publish on tag. Monitoring: error reporting to Sentry optional.

Performance Targets

Expected load: 100 DAU, 500 CLI commands/day. GitHub API latency: under 2 seconds. Claude API latency: under 3 seconds. Terminal output: instant. Cache hit rate: 60%+ within a team.

Go-Live Checklist

☐GitHub API: tested with public and private repos
☐Claude API: summarization tested on 20 real PRs
☐Stripe: test billing processed
☐npm package: published and installable via 'npm install -g blame-context'
☐Docs: README with examples
☐3+ beta users: sign-off on accuracy
☐Rollback: process for reverting npm version
☐Launch: ProductHunt post (maybe), Twitter thread with demo GIF, r/webdev post.

How to build it, step by step

1. Scaffold the project: 'mkdir blame-context && cd blame-context && npm init -y', set 'bin': {'blame-context': './src/index.js'} in package.json, add '#!/usr/bin/env node' shebang to src/index.js. 2. Install real dependencies: 'npm install @octokit/rest @anthropic-ai/sdk better-sqlite3 chalk commander stripe dotenv'. 3. Build the CLI entry point with commander: define 'blame-context -f <file> -l <line>' command, parse --file and --line flags, validate that the path exists inside a git repo using 'git rev-parse --show-toplevel'. 4. Parse git blame output using 'git blame -p <file> -L <line>,<line>' (porcelain format) via child_process.execSync — extract the 40-char commit SHA, author name, and timestamp from the structured porcelain output instead of regex-ing human-readable output. 5. From the commit SHA, use GitHub Search API ('GET /search/issues?q=<sha>+type:pr') via @octokit/rest to find the PR that introduced that commit; fall back to 'GET /repos/{owner}/{repo}/commits/{sha}/pulls' if available on the repo. 6. Fetch the matched PR's body and linked issue numbers (parse 'closes #N' / 'fixes #N' from PR body with a simple regex), then fetch each linked issue via 'GET /repos/{owner}/{repo}/issues/{issue_number}'. 7. Send PR title + body + issue title + body to Claude (claude-haiku) with a prompt like: 'Summarize in 2-3 sentences why this code change was made, based on: [PR and issue text]'. Use max_tokens:150 to keep costs low. 8. Initialize better-sqlite3 at ~/.blame-context/cache.db with a table: (sha TEXT PRIMARY KEY, summary TEXT, pr_url TEXT, issue_url TEXT, cached_at INTEGER). Check cache before any API call; skip Claude and GitHub calls entirely on cache hit. Set TTL of 30 days. 9. Gate private repo access by checking Stripe subscription status: on first run, store a Stripe customer ID in ~/.blame-context/config.json; call 'stripe.subscriptions.list' to verify active pro plan before calling @octokit/rest with the user's GitHub token for private repos. 10. Format terminal output with chalk: commit SHA in gray, PR title in bold white, Claude summary in cyan, issue URL in blue underline, author + date in dim. Test the full flow against 3 real public repos (e.g. expressjs/express) before publishing. 11. Publish: add 'files': ['src'] to package.json, run 'npm publish --access public', verify 'npx blame-context' works from a clean environment.

Generated

March 29, 2026

Model

claude-haiku-4-5-20251001 · reviewed by Claude Sonnet

← Back to All Ideas