Install

Tracking code by Claude

Know who wrote every line. AI or human.

Blamely is a local-first CLI that traces every line of your codebase to a person or an AI assistant, line by line, across your entire git history. No cloud, no account, nothing leaves your machine.

curl -sSL https://blamely.ai/blamely-mac-install.sh | bash
  • Verified install
  • No account required
  • Runs entirely on your machine

Or a native installer: .dmg macOS · Apple Silicon .exe Windows installer .rpm Linux · x86_64

PaymentService.ts blamely · tracking
1import { Stripe } from 'stripe'you
2 
3export class PaymentService {you
4 private stripe: Stripeyou
5 
6 // charge a customer and record itclaude
7 async charge(amount: number) {claude
8 return await this.stripe.charges.create({ amount })claude
9 }claude
10 
11 refund(id: string) {copilot
12 return this.stripe.refunds.create({ charge: id })copilot
13 }you
14}you
AI · Claudemodelclaude-opus-4-8kindchataccepted byyou · 2 min ago

$ git commit -m "add refunds"

AI 55% (6)Human 45% (5)

claude 4 (claude-opus-4-8) · 4.2k in / 890 out tok

copilot 2 (completion)

Attributes code written with
  • Claude
  • Cursor
  • Copilot
  • Codex
  • Gemini
  • Devin
  • OpenCode
VS Code, JetBrains, Cursor, Antigravity and Devin
5 editors
Every model your assistants run is told apart
Any model
Attribution granularity, not a per-file guess
Per line
Of your code sent to a server
0 bytes
How it works

From prompt to production, every line is traced.

A developer’s intent flows through their AI tools into the codebase. Blamely records who, or what, wrote each change, then attaches it to the commit.

  1. 1

    It watches, locally

    The CLI runs a small background daemon that records what your AI tools write, as they write it. Nothing is uploaded.

  2. 2

    It matches at commit

    When you commit, each changed line is matched to the edit that produced it: an assistant and its model, or you.

  3. 3

    It notes the commit

    The result is one JSON note on the commit, under refs/notes/blamely. It travels with the repository when you push notes.

Supported tools

Works with the AI coding tools you already use.

Blamely finds the assistants installed on your machine and follows each one in its own way: a hook, a plugin, its logs. Whichever wrote a line, the commit says so, with the model it ran.

In your editor

See who wrote it, as you read it.

Blamely runs inside your editor: a gutter beside every line, a panel for changes and history, and a status bar for the file in front of you. No context switch, no guesswork.

  • Per-line gutter marksOrange for a person, blue for an AI, with the assistant that generated the line.
  • Hover for provenanceWhen it was written, by which model, and who accepted the suggestion.
  • A panel and a status barChanges and history beside your code; the current file’s split in the status bar.
Install the plugin
web-site — Blamely
BlamelyAI: 751 · 24 · 98%Human: 12 · 3 · 2%claude-sonnet · 4 s
The output

Every commit, fully attributed.

Run blamely report --html and a self-contained dashboard opens for any commit: AI against human, per tool, per file. One local HTML file, no cloud.

$ blamely report 1807830b --html self-contained · local

Attribution

71.4%AI authored

AI · 5 lines Human · 2 lines

Generation

completion42.9%
human28.6%
chat14.3%
cli14.3%

Tools

Claudeclaude-opus-4-8kept 1/1 · 100%
Codexgpt-5.5kept 1/1 · 100%
Copilotcompletion2 suggested → 3 kept

File ranges · welcome.html

L56codexgpt-5.5 · cli
L57claudeclaude-opus-4-8 · chat
L59human
L60-62copilotcompletion
L64human

Tokens

in 13.0kout 431cache 67.5k

Open the full example

blamely report · main

payments-service

142 commits · 8 contributors · 30 days

68%AI

32%Human

  • JDJordan D.2,418
  • AKAïsha K.3,902
  • RMRavi M.1,760
  • SLSofia L.4,127
Across history

Measure AI adoption with evidence.

Blamely reads the attribution out of git history and rolls it up by file, author and time. Know your real AI-to-human ratio from what was committed, not from a survey.

  • Team and repository rollupsThe AI share per contributor, file and directory, over any window.
  • Stored in git, not in a siloAttribution lives in git notes: portable, auditable and yours.
What you get

Built for the way code is written now.

Line-level attribution

Every line is tagged AI or human. No sampling: the whole commit history is analysed.

Multi-model detection

See which assistant and which model contributed how many lines to each change.

Zero configuration

Install and go. Blamely reads your git history itself: no tokens, no sign-in.

Local-first

The daemon, its database and the notes all live on your machine. Nothing is uploaded.

Plain git notes

One JSON note per commit under refs/notes/blamely. Read it with git, push it when you choose.

Available in your editor

One CLI. Every editor you already use.

VS CodeA sidebar panel with live AI tracking on every save, commit and push.Set it up CursorTab completions, Composer and chat edits, each attributed to its model.Set it up JetBrainsA native tool window with git history, model breakdown and per-file attribution.Set it up AntigravityThe same panel and status bar, in Google’s agentic editor.Set it up DevinWhat the agent writes on its own machine, attributed like any other assistant.Set it up
Questions

Asked before you had to.

How is Blamely different from git blame?

git blame tells you who committed a line. Blamely tells you who wrote it: a person, or an AI assistant and the model it ran. A line that Copilot suggested and you accepted is committed by you, but written by Copilot, and Blamely records that difference.

Does my code leave my machine?

No. The CLI, its background daemon and its database run locally, under ~/.blamely, and the attribution is written into your own repository as git notes. There is no cloud service in the loop, no telemetry, and no account is needed to use it.

How does Blamely know a line was written by an AI?

The CLI runs a small daemon that watches the edits your AI tools make while they make them. When you commit, each changed line is matched to the edit that produced it. The editor extensions add what the CLI cannot see on its own, such as inline Tab completions.

Which AI coding tools and editors does Blamely support?

Claude Code, Cursor, GitHub Copilot, Codex CLI, Gemini CLI, Devin and OpenCode, each with whichever model it runs. There are extensions for VS Code, Cursor, Antigravity and the JetBrains IDEs; the CLI itself works with any editor. See every supported tool.

Where is the attribution stored?

In git itself: one JSON note per commit under refs/notes/blamely, attached with the standard git notes mechanism. It travels with the repository if you push notes, and stays on your machine if you do not. You can read it with plain git.

Do I need an account or a licence key?

No. The CLI and the editor extensions install with one command and work straight away: no sign-up, no licence key, no network access needed to function.

Know who wrote your code. In one command.

Install Blamely and get per-line attribution across your whole git history, without sending a single line to the cloud.

curl -sSL https://blamely.ai/blamely-mac-install.sh | bash
Local-first Stored in git notes Works in any editor
Read the quick start