How it works

Blamely runs inside your IDE and tracks every change: who wrote each line — you or the AI. No cloud, no sign-up. Here’s how it works.

Line-level attribution

  • As you type or accept suggestions, Blamely attributes each changed line to AI or Human, with character and line counts and percentages.
  • Formatting-only changes (e.g. Reformat Code) do not change ownership; existing AI/Human blame is preserved.

AI detection

Blamely recognizes code from:

  • GitHub Copilot (completion, chat panel, inline)
  • Cursor
  • Codeium
  • Tabnine
  • Supermaven
  • CodeGPT
  • Amazon CodeWhisperer
  • JetBrains AI

It uses suggestion traces when available, a short “mark next as AI” window after AI actions, and optional stack inspection for chat-panel applies.

Where you see it

  • Status bar — Live AI / Human chars and lines; click to open the Blamely tool window.
  • Gutter — Optional line icons (AI / Human) next to line numbers for uncommitted changes (Settings → Tools → Blamely).
  • Tool window → Changes — Per-file AI / Human breakdown for uncommitted changes.
  • Tool window → History — Commits, authors, AI %, coding time, branch, top models, and full commit list.
Terminal
$

Persistence and git

  • Blame is stored under .git/blamely and survives IDE restart, branch switch, and stash.
  • You can attach a report and line blame to each commit as git notes under refs/notes/blamely.
  • An optional pre-push hook pushes these notes to the remote (cross-platform; does not overwrite existing hooks).

See the Blamely directory in your repo: open a terminal, then run cd .git/blamely and list the contents (demo below).

Notes reflog — Blamely stores notes under refs/notes/blamely. You can inspect the reflog and then show a note for a commit:

notes reflog
$more .git/logs/refs/notes/blamely

Report YAML (report.yml)

Blamely writes a report.yml per commit with AI vs human line counts, models, and metrics in a standard YAML format.

Where it is written

  • Tools → Blamely → Generate Report — writes .git/blamely/report.yml for the current branch/commit.
  • On commit — the commit listener generates a report from the blame snapshot and stores it in the git note for that commit (with the line-level blame snapshot).

Top-level keys in report.yml

  • scope — Always "this_commit" (report covers a single commit).
  • commitDate — ISO-8601 timestamp when the report was generated.
  • detector_version — Blamely detector version (e.g. "0.2.0").
  • branch — Git branch name at report time.
  • commit_hash — Full commit SHA.
  • commit_message — Commit message (JSON-escaped).
  • summary — Totals: total_files_changed, total_lines_added, total_lines_deleted, total_changes, ai_lines_added, human_lines_added, ai_percentage, model_count.
  • metrics — first_start_coding_time (ISO-8601 or null), time_waiting_for_ai_ms.
  • agent_info — ide (e.g. "IntelliJ"), models (list), interaction_types (e.g. completion, chat_panel).
  • files — List of per-file entries (path, source, model, ai_lines_added, human_lines_added, lines_deleted, total_changes, ai_percentage, prompts).

Line-level blame (in git notes) includes: lineNumber, authorType (AI/HUMAN), provider, model, prompt, interactionType, changeType (ADD/DELETE), codingType (TYPING/BULK_INSERT).

Formatting rules — Strings that may contain newlines or quotes are JSON-encoded. File paths and simple strings are quoted and backslash-escaped. Numbers and null as YAML literals; percentages as strings.

Example (minimal report.yml)

report.yml
$ cat .git/blamely/report.yml
scope: "this_commit"
commitDate: "2025-03-10T12:00:00Z"
detector_version: "0.2.0"
branch: "main"
commit_hash: "abc123def456"
summary:
  total_files_changed: 2
  total_lines_added: 45
  ai_lines_added: 30
  human_lines_added: 15
  ai_percentage: "62.5%"
agent_info:
  ide: "IntelliJ"
  models: ["claude-3"]
files:
  - path: "src/App.kt"
    source: "cursor"
    model: "claude-3"
    ai_lines_added: 20
    human_lines_added: 8
    ai_percentage: "69.0%"

Coding types and metrics

  • TYPING — normal typing; BULK_INSERT — paste.
  • File add/move is attributed appropriately.
  • Metrics — first coding time in session, time waiting for AI, interaction types (completion, chat_panel, etc.).

Actions (Tools → Blamely)

  • Generate Report — Regenerate report and blame state.
  • Show Blame for Current File — AI / Human breakdown for the active editor.
  • Install / Restore Git Hook — Install or restore the pre-commit hook.
  • Show Commit Report — Open report from git notes for the latest commit.
  • Attach Git Note — Add or overwrite the Blamely note for the current commit.
  • Push Notes to Remote — Push refs/notes/blamely so the remote has notes.

Settings

  • Settings → Tools → Blamely: Toggle "Show line icons in gutter" (AI / Human next to line numbers).
  • Settings → Editor → General → Gutter Icons: Show or hide the Blamely gutter entry.