What’s new.

Improvment

Some Git servers reject commits that don’t include an issue key, such as a Jira ticket ID. This could prevent Blamely from publishing attribution notes because Git’s default notes commits use fixed messages that don’t satisfy those rules.

Blamely now publishes each attribution note in its own notes commit using the original commit message, followed by the standard Notes added by line. Since the original commit message has already passed your server’s validation, the notes commit can pass the same checks.

Notes are published alongside their commits. If a commit hasn’t been pushed yet, its note waits until that commit is pushed. Any notes that were previously stuck locally will be published automatically on the next push.

If the server rejects a notes push, Blamely now shows the server’s actual error instead of a generic warning. If you try to push refs/notes/blamely manually, Blamely will also explain why it should manage that ref itself.

Blamely 1.8.3

22 September 2026

Devin joins the AI tools Blamely tracks, and four Windows problems are fixed — three of which were costing people attribution or flashing windows across their screen without ever reporting an error.

The JetBrains plugin and the VS Code extension go out at 1.8.3 alongside the command-line tool, as they always do, but nothing in them changed this time. Everything below is in the command-line tool, which is what does the recording for all three.

Devin

Blamely now works with Devin

Devin writes code in three different places, and Blamely follows all three.

Its command-line tool and its editor are the straightforward ones: Blamely sees the edits as they happen, the same way it does for every other assistant.

Work you hand to Devin in the cloud is different. It never touches your machine while it's being written — it comes back to you as a finished branch, long after the fact, with nothing to observe. Every line of it used to read as your own work. Blamely now reads the credit Devin leaves on the commit itself, so that work is attributed to Devin. This only happens when Blamely saw nothing of its own: anything it actually watched being written always wins.

One fix comes with this. Devin reads its settings from the same file Claude does, so on a machine with both installed, everything Devin wrote was filed under Claude. It is now filed under Devin.

Devin's work shows which model wrote it, and how much it used

Devin doesn't say which model is running, so everything it wrote was recorded with no model name against it — it showed up as Devin and nothing more.

Blamely now works it out for itself, down to the specific model (swe-2-high, for instance), along with how much each step used. Devin's models get their own logo in the report's leaderboard.

Windows

Blamely starts tracking again immediately after an update

An update shut the background service down and then failed to bring it back. The step that stops the old service was also stopping the very thing meant to start the new one.

Nothing was recorded from that moment until the 15-minute safety check happened to come round — so every AI edit in that gap was credited to nobody, on every machine, at every update. Windows now handles the restart itself, and the new version is up within seconds.

No more black command window flashing on your screen

Blamely checks every 15 minutes that its background service is still alive, and Windows insisted on giving that check a command window of its own: a black box that popped open and shut four times an hour, plus once more every time you signed in.

The service now starts completely out of sight. The 15-minute check itself hasn't changed — it's what brings Blamely back after a crash or an update, and it's worth keeping.

Install and blamely doctor now tell you when a machine is stuck on the old way of starting

If Blamely was ever installed as an administrator, a later ordinary install can't change how the service starts. So the fix above, and every fix like it, simply never arrived on those machines — while install showed a green tick and doctor said nothing at all.

Both now notice the difference, say what it is, and print the one command that repairs it.

It is deliberately not repaired for you. Doing so needs administrator rights, which is precisely why it has to be reported rather than quietly swallowed.

Blamely's program files now show the right version

The version recorded inside the program itself had been left behind at 1.6.7 while Blamely shipped 1.8.2, and the small helper that starts the background service carried no name, no publisher and no icon.

A nameless program that starts another program is exactly the shape antivirus software treats as suspicious. Both files now carry full details and are signed by the same publisher.

Elsewhere

Every update now leaves a record

~/.blamely/update.log gets one line per update: whether it worked, which version it came from and went to, and the reason when it didn't.

Updates run in the background with nobody watching, so a machine that quietly stopped updating gave you nothing to go on — you only found out months later, from how far behind it was. blamely doctor shows the most recent line, and points it out when the last attempt failed.

Updating

blamely update

This brings your VS Code and JetBrains plugins along with the command-line tool.

On Windows, run blamely install afterwards if you're updating by hand — the fixes to how the background service starts are put in place during install.

Three silent bugs, fixed. What they had in common: none of them ever showed an error. Blamely looked like it was working while it was quietly losing your data.

Branching before you commit no longer credits the AI's work to you

Working on your main branch and creating a branch once it's time to commit — git checkout -b my-feature — is how a great many people work. And it lost the entire session's AI attribution. The commit reported every AI-written line as hand-written.

Blamely filed the work under the branch you were working on, then went looking for it under the branch you committed on. It now finds it, whether you created the branch from your IDE or from the terminal. The AI/Human marks in your editor are correct right away too, not only once you've committed.

Attribution reaches your remote again after the first clash

Blamely sends each commit's AI/Human breakdown to your remote alongside your code. But the moment a teammate's breakdown got there before yours — or your own rebase rewrote yours — the send was refused. And from that point on it was refused every single time: everything after it stayed on your machine alone, with nothing anywhere to tell you.

Blamely now brings both sides together and sends again, keeping your teammates' records alongside your own. If it still can't get through, it says so instead of staying quiet.

Pasting no longer freezes the IDE

JetBrains IDEs

Every paste longer than a few characters made Blamely run several git commands before the editor was allowed to respond. A multi-cursor paste — or the automatic reformat that follows one — multiplied that by every insertion point.

Blamely now gets the same information without running anything at all, and does the remaining work out of your way. Typing is lighter as well: the plugin had been copying the whole file three times on every keystroke, even when nothing was using those copies.

blamely doctor now catches the projects where Blamely can't run at all

A project that manages its own git hooks — Husky, lefthook and pre-commit all do — takes over the setting Blamely depends on. That switches Blamely off completely for that project: nothing is recorded, nothing is sent. Nothing said so, and everything looked fine everywhere else.

Doctor now reports it and tells you what to do about it.

Updating

blamely update

This brings your VS Code and JetBrains plugins along with the command-line tool.

If you're updating by hand, run blamely install afterwards — the remote-sending fix lives in a file that's written during install, so an older copy would otherwise stay in place.

A stability and performance release. Nothing new to learn — everything just works better and costs less.

Attribution no longer stops quietly

The background service could get stuck waiting on a Git command that never returned. While your AI tools continued working, their edits could stop being credited.

Nothing looked broken and nothing appeared in the logs. You would only notice later when work you didn't write was incorrectly attributed to you.

This is now fixed. Blamely now gives up on stuck Git commands and continues processing normally.

Much lighter on your machine

Blamely was doing unnecessary background work. This release significantly reduces that overhead:

• Chat session discovery: Previously, Blamely scanned your editor's entire storage folder every few seconds to find chat sessions. On machines with a long history, this could mean scanning thousands of folders. It now goes directly to the relevant location, reducing this repeated work by roughly 8×.
• Repository scanning: The editor extension previously re-read the entire repository on every keystroke. This is now eliminated.
• Git polling: Git was previously executed three times every three seconds just to detect new commits. Commits and branch switches are now detected immediately when they happen — rather than up to three seconds later.

Switching tabs is quick again

Opening a file or splitting the editor previously triggered a full repository scan.

Blamely now reads only the files you're actually looking at, making file navigation and editor tab switching significantly faster.

No more leftover processes

When Blamely recorded lines deleted by an AI tool, helper processes could remain running until the editor was closed. A burst of AI edits could also start many processes at once.

Helper processes now:

• Stop automatically when they're no longer needed.
• Are limited so only a small number can run simultaneously.
• No longer accumulate during extended editing sessions.

Summary

This release focuses on making Blamely more reliable, faster, and lighter on system resources — without introducing new concepts or requiring any changes to your workflow.

Added

• Blamely now keeps itself up to date. It checks for a new version once a day and installs it for you, then re-registers your AI-tool hooks and restarts the background service. You don't have to do anything — and because an out-of-date Blamely doesn't look broken, it just quietly credits some AI work to you, staying current matters more here than with most tools.
• Updates are verified before anything is replaced. Each download is checked against the checksums published with the release, and the new version is run once to confirm it works on your machine. Only then does it take over. If any step fails, the version you were running is left exactly as it was.
• You stay in control. Run blamely update any time to update on the spot, or blamely update --check to just look. To be told about new versions without installing them, use blamely config set update.auto off; to stop checking altogether, blamely config set update.check off (or BLAMELY_NO_UPDATE_CHECK=1). When an update is waiting, blamely status and blamely doctor say so.
• Updating works on locked-down company networks. If your network blocks GitHub, point Blamely at an internal mirror with BLAMELY_UPDATE_API, or install a release you already have on disk with blamely update --from <archive> --sha256 <checksum>. When the check can't reach the network it stays silent — it never delays your AI tools, your commits, or the background service.

Added

• Windows no longer warns you about Blamely. Every Windows download — the installer and the app itself — is now signed with a certificate Microsoft trusts on every Windows machine, under the verified publisher Oobeya Inc. The "Windows protected your PC" screen is gone, there's nothing to import, and antivirus false alarms should stop. Security teams can approve Blamely once by publisher name instead of chasing each release.
• A setting to fix a stuck AI/Human breakdown. On very large repositories, or slow/company-managed disks, the breakdown could give up before it finished and show nothing. It now waits up to a minute instead of a few seconds, and you can raise that yourself in the VS Code and JetBrains plugin settings.

Changed

• Blamely is now fully readable, everywhere. All code-scrambling was removed from every part of Blamely — the command-line tool, the JetBrains plugin, and the VS Code extension. What we ship is exactly what's in the public source, so your security team can read and verify every line of what runs on your machines. Nothing we build is capable of producing a scrambled version anymore.

This release focuses on making Blamely start reliably on every machine — especially company-managed Macs and Windows PCs.

Fixed

• Blamely's background service now starts reliably on macOS. Some users — especially on company-managed Macs or after a reinstall — ended up with everything installed but the service never running, so nothing was tracked. Install now starts the service in a way macOS respects in all of these cases, including when it had been switched off by an earlier uninstall..
• Updating Blamely on Windows now switches to the new version immediately. Previously the old version could quietly keep running after an update — and stop receiving edits from your AI tools — until you signed out or restarted.
• Fewer false alarms on slower machines. On corporate Windows machines where antivirus scans new programs, the service can take a little longer to start the first time. Install now waits long enough for that instead of reporting a failure while the service was actually coming up fine.
• Editor extension installs are reported correctly. In some editors (seen with Antigravity on Windows), the Blamely extension installed successfully but was reported as failed. Install now reports what actually happened.
• Better guidance when something really is wrong. If the service genuinely fails to start on macOS, install now tells you the specific cause and the exact command to fix it, instead of a generic list of things to try.

Added

• Attribution now survives cherry-pick, squash, and stash operations. Reorganizing Git history no longer removes authorship information for individual lines, extending Blamely's existing support for rebase and amend workflows.

Fixed

• Blamely now continues running on Windows laptops operating on battery power. Previously, if Windows started while unplugged, the background service could fail to launch, causing activity to go untracked until the device was connected to power.
• Added RustRover support to the installer. RustRover installations are now detected and configured automatically, consistent with other JetBrains IDEs.
• Improved attribution reliability on Windows across Cursor, Antigravity, and Claude. Drive-letter paths (for example, C:\...) are now handled correctly, reducing cases where AI-generated changes could be attributed to the wrong contributor.
• Improved accuracy of per-file AI and human line counts, resulting in more precise contribution reporting.

New

AI Attribution for File Deletions

• Cursor file deletions are now credited to AI.
• When you ask Cursor to delete a file, the deletion is recorded as an AI-generated change rather than a human change.
• Improved Windows support for AI-attributed deletions, including files deleted directly from the terminal.

One-Click Installers

• Added one-click installers for:
  • Windows
  • macOS
  • Linux
• No command-line setup required.

Branded Windows Installer

• The Windows installer now uses the Blamely branding and icon:
  • Installer window
  • Installed application

Custom Tool Locations

• Added support for custom Codex and Claude configuration locations.
• Useful when teams run Codex or Claude from non-standard directories.
• Standard locations (~/.codex and ~/.claude) are always monitored.
• Custom locations are scanned in addition to the standard locations, never as a replacement.

Environment Variable Detection During Installation

• blamely install now reads:
  • CODEX_HOME
  • CLAUDE_CONFIG_DIR
• These values are automatically stored in Blamely's configuration.
• This is important because the background agent runs independently and does not have access to your shell environment variables.

Fixed

Improved AI Rewrite Attribution

• More accurate attribution when AI rewrites an entire file.
• Both newly added lines and replaced lines are now credited correctly.

Better Deletion Detection

• File deletions performed by Copilot and Cursor agents are now correctly detected.
• Deletions are attributed to the appropriate AI tool.

Windows Attribution Reliability

• Improved attribution accuracy and reliability on Windows systems.

Cleaner Installation Logs

• Fixed character encoding issues during installation.
• Setup logs no longer contain garbled or unreadable characters.

Fully Private HTML Reports

• HTML reports no longer load Google Fonts.
• Opening a report does not make any external network requests.
• All report data remains entirely on your machine.

Improved IDE Experience

• Editor gutters now highlight only the lines you have actually modified.
• Switching branches preserves in-progress work and attribution data.
• Supported IDEs:
  • VS Code
  • IntelliJ IDEA

A reliability release: attribution stays accurate when you delete or paste code, and the background helper keeps itself running so tracking never quietly stops.

Highlights

• Deleting code through the terminal is credited correctly. When an AI assistant removes a file or clears lines from the command line, that work now shows up as the AI's — including on Windows and the newest assistant builds.

• Pasted code stays yours. Paste something in and Blamely keeps it credited to you, even when the same text happens to appear in AI-generated code elsewhere. No more of your pastes being mistaken for the assistant's work in JetBrains.

Improvements

• The background helper keeps itself alive. Only one copy ever runs at a time, and on Windows it now restarts on its own if it ever stops — so tracking keeps going without you having to sign out and back in.

• A more accurate "how much you kept" figure. The summary of how much of an assistant's suggestions you actually kept now reflects every kept line and never overshoots 100%.

• Cleaner, steadier gutter in JetBrains. The AI/human markers no longer flicker or fight each other, so what you see lines up with how the work was really split.

• Setup that holds up. Installing with admin rights now sets up the same automatic recovery as a normal install, so attribution keeps running no matter how Blamely was set up.

Thanks for using Blamely. Questions or feedback? We'd love to hear from you.

The release focused on light themes, a clearer status bar, and friendlier installs.

Highlights

• A clearer, more colorful status bar. The AI/Human summary no longer washes out on light themes — it uses your theme's normal text with a colored status dot, in both VS Code and JetBrains. And on dark themes in VS Code, the AI and Human figures now stand out in their own colors — blue and green.

Improvements

• Sidebar and history look right in light mode. The Blamely panels (Changes and History) now adapt their surfaces, borders, and accents to light themes instead of being tuned only for dark — no more faint, washed-out cards.

• Clearer line counts. The status bar now spells out the count — "1 line", "2 lines" — instead of just a bare number.

• Installing with admin just works. If you run the installer with sudo (or from an elevated terminal, local admin), Blamely now sets itself up for your normal user account, so the background helper and your editor line up. Previously this could leave attribution running under the wrong user.

• Consistent status lamp. The daemon indicator now shows the same crisp colored dot across VS Code and JetBrains, independent of your theme.

Thanks for using Blamely. Questions or feedback? We'd love to hear from you.

A focused follow-up to 1.6.3 that makes deletions attribute correctly and keeps the gutter fast and dependable on larger projects and on Windows.

Highlights

• Deletions land with the right author. When an AI assistant removes a file or clears out lines, those deletions are now credited to the AI — not quietly counted as your own work.

Improvements

• No more stalls on big repositories. Attribution gives itself enough time to load the first time you open a file, so it no longer gives up early on large projects or Windows — and it keeps working smoothly after that.

• Smoother in the background. Overlapping updates no longer pile up and compete with each other, so the gutter stays responsive even during busy editing sessions.

• Tidier behind the scenes. Blamely now cleans up its own tracking data after you commit, keeping things light and accurate over time.

Thanks for using Blamely. Questions or feedback? We'd love to hear from you.

Blamely 1.6.3

This release makes AI-vs-human attribution more accurate across your whole workspace, brings GitHub Copilot Chat tracking up to real time, and gives the gutter a cleaner, more consistent look in both VS Code and JetBrains.

Highlights

• Works across every repo in your workspace. If your workspace contains more than one Git repository, Blamely now tracks AI and human changes in all of them — not just the first one it found.

• Live GitHub Copilot Chat tracking. Copilot's edits are now captured the moment they land, so they show up as AI right away instead of briefly appearing as your own work.

Improvements

• Sharper attribution when AI and your edits mix. When a file has a blend of AI-written and hand-written lines — including deletions — Blamely now keeps each line credited to the right author.

• Reliable on Windows line endings. Files saved with Windows-style line endings now attribute cleanly in the gutter, with no stray mislabels.

• Accurate gutter after you shift code around. Inserting lines above an AI-written block no longer splits it into a mix of AI and human — all the AI lines stay correctly marked, matching the commit report.

• Smoother inline suggestions. Accepting an inline completion is now attributed correctly and consistently.

• New files show up right away. Brand-new files now appear in the gutter the moment you start writing — no need to stage them in Git first.

• Always on the latest plugin. Updating through Blamely now reliably replaces the old plugin, so you're never left running a stale version.

• A cleaner, consistent gutter. The AI and human gutter markers now share the same crisp sizing across VS Code and JetBrains, so the experience looks the same wherever you work.

• A friendly nudge for new projects. Open a folder that isn't a Git repository yet and Blamely offers to set it up — since it needs Git to track who wrote what.

• Clearer status bar. The AI and human summary now leads with the percentage, so the headline number is the first thing you see.

Thanks for using Blamely. Questions or feedback? We'd love to hear from you.

Highlights

• Accurate attribution when AI and human edits interleave (IntelliJ). When an AI assistant (e.g. Copilot agent) rewrites a file you'd just edited by hand, your human-written lines are no longer re-labeled as AI. IntelliJ now diffs each AI rewrite against a pre-write snapshot — matching the VS Code plugin — so only the lines the assistant actually wrote are attributed to it.
• IntelliJ 2026.1 support. The plugin now initializes correctly on IntelliJ 2026.1 (build 261), which removed the old startup API. Previously the plugin loaded but its tracking never started.

Fixes

• IntelliJ no longer freezes during attribution refresh. Git lookups were running on the UI thread and could freeze the IDE for 10–20s; they now run off the EDT.
• Windows: VS Code / Cursor gutter and status bar now populate. The editor plugins read the attribution DB via sqlite3, which Windows lacks. Installers now place sqlite3.exe in ~/.blamely/bin (where the plugins look first), fixing the silent spawn sqlite3 ENOENT failure.
• IntelliJ plugin install now finds all IDEs. The installer detects Toolbox and Program Files installations (and IDEs that haven't been launched yet) instead of only already-configured ones — fixing "couldn't find IntelliJ" during install.

Changes

• Status bar shows whole-session totals. Both the VS Code and IntelliJ status bars now display AI vs Human for the entire session (all changed files), instead of just the active file.

[1.6.0] - 2026-06-15

Added

• Claude Desktop attribution — new watcher records edits/deletes from Claude
  Desktop's "cowork" sandbox (no PostToolUse hook there): tails its logs, maps the
  VM's mounted repo path back to the host, and records deletions from the rm
  command (hashed from HEAD) so attribution doesn't depend on VM→host sync timing.

Changed

• VS Code extension installed from Open VSX — registry-independent install by
  .vsix path; works on VS Code, Cursor, Antigravity.

Fixed

• Copilot chat attribution — scanTextEdits now scans incrementally, detects
  new request appends mid-session, and handles responses more robustly — fixing
  Copilot chat edits that failed to load and went unattributed.
• blamely install no longer fails on VS Code — Marketplace delisting made the
  old id-based install a no-op; falls back to the registry id when Open VSX is down.

Notes

• Gemini (Antigravity) — the agent is attributed via transcript logs (shipped
  earlier); the inline-completion fix this cycle is editor-plugin side (see the VS
  Code 1.6.0 changelog).

Fix
Windows: blamely install no longer fails with schtasks /Create: Access denied

On many Windows setups, registering the daemon as a logon Scheduled Task requires Administrator rights. Install now:

• Tries the Scheduled Task (Blamely Daemon) as before
• On access denied, falls back to a Startup folder entry (blamely-daemon.vbs) — no admin required
• Starts the daemon immediately after install

Full Changelog: https://github.com/blamely-ai/blamely/commits/v.1.8.0

Rolling build from the most recent release. Pin a version with a v*.*.* tag instead.

Rolling BETA build. Install: curl -sSL https://blamely.ai/blamely-mac-install.sh | BLAMELY_CHANNEL=beta bash