Blamely
Blamely tells you which uncommitted lines in your project were written by you and which came from AI (inline completion, chat apply, and similar actions). It keeps that attribution across restarts and branch switches, can summarize it in YAML reports, and can attach snapshots to Git commits via git notes so your history stays auditable.
Website: blamely.ai · Issues: GitHub
Why developers use Blamely
- Transparency in code review. Reviewers can see AI-assisted hunks directly in the editor (gutter + hovers) instead of guessing from commit size or tone.
- Team and compliance narratives. When policies ask how AI was used on a change, you have structured data (per file, model, interaction type when available) instead of screenshots or memory.
- Metrics that match the real edit stream. Blamely listens to editor changes and common “accept / apply” commands, then maps them to a per-line blame map rather than relying only on commit diffs.
- Git-aware workflow. Working state lives under
.git/blamely/; optional hooks and git notes (refs/notes/blamely) tie reports to specific commits when you want a permanent record.
- Local first. Attribution and reports are generated on your machine; nothing is sent to Blamely’s servers by the extension itself.
How it works
- Activation. When your workspace loads, Blamely restores branch-scoped blame snapshots and session data from
.git/blamely/ where present.
- Detecting AI actions. The extension watches executed commands (e.g. inline suggest accept, chat apply) and opens a short “AI attribution window” so the following document edits are treated as AI unless they clearly behave like normal human typing.
- Tracking edits. On each text change, Blamely updates a blame map: lines get AI or human attribution, with provider/model/prompt metadata when the environment exposes it. It tries to avoid mis-labeling human-only edits (e.g. isolated newlines) when they are mixed with AI chunks in the same transaction.
- Persistence. Blame snapshots and session data are stored per Git branch under
.git/blamely/snapshots/<branch>/. Switching branches saves the leaving branch’s state and loads the new branch’s snapshots when available.
- Reporting.
report.yml summarizes the current working tree (and can be regenerated on save). After a commit, the extension can attach a structured snapshot to that commit using git notes.
- UI. The status bar shows aggregate AI vs human stats. Blamely: Changes (SCM) lists files that are dirty in Git and still have uncommitted attribution. Blamely: History lists past commits that have a Blamely report in git notes (committed work, not your current working tree).
Multi-root workspaces: Each root folder has its own blame keys and on-disk layout so two projects in one window do not overwrite each other.
What you see in VS Code
- Status bar: Rolling AI vs human character/line summary for tracked uncommitted work.
- Source Control → Blamely: Changes: Files that Git reports as changed vs HEAD (including untracked) and that still have uncommitted line attribution. When the tree is clean, this view is empty even if old blame existed before commit.
- Source Control → Blamely: History: Commits that have a Blamely snapshot in git notes (typically after commit with the extension active).
- Editor gutter: Icons and tooltips on uncommitted attributed lines (configurable).
Commands
| Command |
Description |
| Blamely: Generate Report Now |
Regenerate report.yml (and related outputs). |
| Blamely: Show Blame for Current File |
Quick summary of attribution for the active file. |
| Blamely: Install Git Commit Hook |
Install the optional Git hook in the repo. |
| Blamely: Restore/Remove Git Hook |
Restore a backed-up hook or remove Blamely’s hook. |
| Blamely: Show Report for Latest Commit (Git Note) |
Open YAML from the latest commit’s blamely git note. |
| Blamely: Attach Git Note for Current Commit |
Attach a note to HEAD and push notes if configured. |
| Blamely: Attach Git Note for Commit SHA… |
Attach a note to a chosen commit. |
| Blamely: Accept Inline Suggestion / Next Word / Next Line |
Optional keybindings that attribute the following insert as AI (when you bind through Blamely). |
Run commands from the Command Palette (Ctrl+Shift+P / Cmd+Shift+P) and type Blamely:.
Configuration
Settings use the blamely.* prefix.
| Setting |
Default |
Description |
blamely.suggestionTimeout |
30000 |
Ms after which a pending inline suggestion match is treated as rejected. |
blamely.autoInstallHook |
true |
Install the Git hook when activating in a Git repo. |
blamely.reportOnSave |
true |
Regenerate reports when you save a file. |
blamely.showGutterDecorations |
true |
Show gutter icons and hovers. |
Data layout
All working data stays under .git/blamely/ (not ignored by Blamely by default). Typical layout:
<project>/.git/blamely/
├── report.yml
└── snapshots/
└── <sanitized-branch-name>/
├── session.json
└── *.blame.json
Older installs may still have session.json at .git/blamely/session.json; new data is written per branch under snapshots/.
Inspect the latest note in a terminal:
git log -1 --show-notes=blamely
report.yml (example)
scope: "this_commit"
generated_at: "2026-03-05T00:43:50Z"
detector_version: "1.0.0"
branch: "main"
commit_hash: "3317ed295e"
commit_message: "[AI-assisted] feat: update time-to-fix analysis"
ai_sources:
- copilot/cursor_inline
files:
- path: "src/utils/parser.ts"
source: "copilot/cursor_inline"
model: "github-copilot"
prompt: "// Parse the execution results"
ai_lines_added: 22
human_lines_added: 65
ai_entries: 8
human_entries: 12
total_entries: 20
percentage: "40.0%"
License
MIT
