We Open-Sourced the Tool We Use to Track AI-Generated Code

I ran autter stats last week and got this back:

you  ██░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ai
     6%                                  94%

94% of that commit was AI. I wrote 6%.

The weird part? Before that moment, I had no idea the split was that lopsided. git blame showed my name on every line. CI passed. The PR got approved. But most of that code came from Claude, from a prompt I barely remember writing at 11 PM.

I kept thinking about this. Not the percentage itself, but the fact that nothing in my toolchain told me. Git doesn't care who actually wrote the code. It only knows who committed it. And right now, with every team running Cursor, Copilot, Claude Code, or some combination of five different agents, that distinction matters more than it used to.

So we built a thing. Today it's open source.

What it does

Autter is a git extension. You install it once, and from that point on, every line of AI-generated code gets linked to the agent that wrote it, the model it used, and the prompt session it came from. All of this happens automatically when you commit.

git commit -m "add auth middleware"
 
[auth-service 0afe44b2] add auth middleware
3 files changed, 127 insertions(+), 8 deletions(-)
 
you  ████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ai
     18%                                82%

There's also autter blame, which works exactly like git blame — same flags, same everything — but shows you who actually wrote each line:

cb832b7 (Sagnik Ghosh      2025-12-13  133) pub fn execute_diff(
cb832b7 (Sagnik Ghosh      2025-12-13  134)     repo: &Repository,
fe2c4c8 (claude            2025-12-02  138)     // Resolve commits
fe2c4c8 (claude            2025-12-02  139)     let (from_commit, to_commit) = match spec {
fe2c4c8 (claude            2025-12-02  140)         DiffSpec::TwoCommit(start, end) => {

Lines 138–140 were Claude. You can trace them back to the exact prompt that generated them.

How it works under the hood

I keep getting asked about this, so here's the short version:

Coding agents call autter checkpoint when they write or modify files. This is already built into 14 agents: Claude Code, Cursor, Copilot, Windsurf, Codex, Gemini, Amp, Junie, Continue, Pi, Droid, OpenCode, Rovo Dev, and Firebender.

On commit, Autter stores line-level attribution in Git Notes. Not in your commit history, not in your source files. Git Notes are metadata that travel alongside commits without touching the diff. This was a deliberate choice; we didn't want attribution data bloating your repo.

The part I'm honestly most proud of is the git operation handling. When you rebase, squash, stash, or cherry-pick, Autter moves and merges attributions automatically. It watches for those operations and reconciles the attribution within 5–100ms. We spent a lot of time making sure you couldn't lose track of who wrote what, no matter how aggressively you rewrite history. Go ahead, give it a try. Try breaking it apart as much as you want.

We don't use git hooks: too slow, too fragile across repos. We don't wrap the git binary: zero overhead on your git commands. And we don't use AI to guess which lines are AI-generated. The agents themselves report what they wrote. Guessing felt wrong for something that's supposed to be a source of truth.

The stats nobody has right now

autter stats gives you numbers that, as far as I can tell, most teams are currently guessing at or just not tracking:

{
  "human_additions": 28,
  "ai_additions": 76,
  "ai_accepted": 47,
  "git_diff_deleted_lines": 34,
  "git_diff_added_lines": 104,
  "tool_model_breakdown": {
    "claude_code/claude-sonnet-4-5-20250929": {
      "ai_additions": 76,
      "ai_accepted": 47
    }
  }
}

Percentage of AI code. Lines generated versus lines committed. Acceptance rates by tool and model. Human overrides.

This isn't survey data or a rough estimate. It's measured at the line level on every commit.

I think the tool_model_breakdown is the most interesting part. If you're running three different agents, you can now see which one actually produces code that sticks versus code that gets rewritten a week later.

Prompt storage

This was one of the harder design decisions. Prompts contain useful context — the requirements, the architecture thinking, the "make it work like X but handle Y differently" kind of instructions. But they also often contain sensitive information: company names, internal systems, sometimes credentials pasted by accident.

We store prompt sessions outside of git entirely. They get scanned and redacted before storage. You get fine-grained access control over who can see them. And if you're running local-only mode, they never leave your machine.

The tradeoff is that prompt history requires a separate lookup rather than living inline with your code. We think that's the right call, but I'm curious what people think once they start using it.

Install

Mac, Linux, and Windows (WSL):

curl -sSL https://autter.dev/install.sh | bash

Windows:

powershell -NoProfile -ExecutionPolicy Bypass -Command "irm https://autter.dev/install.ps1 | iex"

No per-repo setup. The installer asks whether you want local-only mode or to connect to the Autter platform. Local-only works without an account. The platform adds cross-repo dashboards, prompt search, and team analytics, with your data going to your org's own database.

For teams

We built a teams version because individual attribution, while useful, only gets you so far. The teams version connects to GitHub, GitLab, Bitbucket, or Azure DevOps and joins in data from across the SDLC:

• Percentage of AI code by PR, repo, team, and contributor
• Token cost tied to individual PRs
• How much rework AI code requires before and after deployment
• Incident tracing back to the AI session that generated the code
• Searchable prompt archive across all repos

Hundreds of teams are using this already. A few of them are bigger companies, though most are smaller engineering orgs that wanted visibility into what their agents were actually doing.

Why we open-sourced it

Honestly, attribution should be infrastructure. It shouldn't be something you pay for to get the basics. The CLI does accurate line-level tracking locally, for free, and we think that should be the default for every developer using AI tools.

The spec is published too. We want other tools to build on this, not just us.

The business is the teams platform: the dashboards, the cross-repo analytics. The CLI is the foundation. It made more sense to open it than to gatekeep it.

Apache 2.0. Built in Rust.

• Autter CLI on GitHub
• Autter open attribution standard

If something breaks, tell us.

Sagnik