All posts
Developer tracking7 min read

Find the commit that introduced a bug: follow the fix back to it

For a CTO and their developers: how a fix leads back to the commit it repairs, why the defect it reveals stays “to confirm” until an administrator or an investigation confirms it, and why the last 60 days are never final.

The DeployIt Team

We build DeployIt, an MCP server that lets a whole company ask its code from Claude and track each developer's work.

To find the commit that introduced a bug, start from the fix: the commit that repairs a defect leads back to the commit that caused it. DeployIt does that reading for every fix that reaches the landing branch, and counts the result as a defect “to confirm” until an administrator or an investigation confirms it.

This page is for a CTO who wants to know where defects come from, and for the developers whose commits are counted: what the machine finds, what it cannot decide, and who has the last word.

In your Claude · example

Who introduced the defects we fixed this quarter?

Seven defects fixed this quarter, listed by the author of the commit each one came from. Three are confirmed, four are still to confirm. Commits from the last 60 days aren't mature yet: these counts can still rise.

DeveloperMerged commitsConfirmedTo confirm
Camille R.8112
Idriss B.7421
Léa M.5701
Drawn from your commits212 merged commits · sample data

The question is asked in plain language, with the Leadership profile. The rest of this page explains each word of the answer.

How do you find the commit that introduced a bug?

There are three ways, and they do not serve the same person.

Bisect. The Git documentation sums up git bisect in one line: “Use binary search to find the commit that introduced a bug” (git-scm.com, checked on 17 November 2026). You name a commit known to be bad and one known to be good. Git picks a commit in between, you say which side it falls on, and the range narrows until one commit is left. It needs a bug you can reproduce, and it is one hunt per bug.

Blame. git blame goes through a file line by line and tells you which revision, and which author, touched each line last (git-scm.com, checked on 17 November 2026). It helps once you know which line is wrong. It names the last change to that line, which is not always the change that broke it.

Read from the fix. Once a bug is fixed, the history already holds the answer. The fix shows which code was wrong, and that code came from an earlier commit. Nobody has to reproduce anything.

The first two are tools for one developer and one bug. The third can be done for every fix, and it gives a company a count.

How does a fix point at the commit it repairs?

A fix is a merged commit like any other. What sets it apart is what it does: it repairs code that an earlier commit wrote. DeployIt finds that earlier commit and writes a defect, a row with four things in it: the commit the defect came from, its fix, who fixed it, and whether it is “confirmed” or “to confirm”.

Here is the life of one defect. It is an example: the dates and the people are invented.

  • 3 March. Camille merges a commit that changes how a VAT amount is rounded.
  • 12 March. Idriss merges a fix: some invoices were one cent off.
  • That night. The statistics are updated, as they are every night. DeployIt finds the commit this fix came to repair, the one of 3 March. One defect, “to confirm”, with its origin, its fix and the name of the person who fixed it.
  • Later. An investigation rereads the code, or an administrator looks at the two commits. The defect becomes “confirmed”, or the administrator dismisses it.

Only work that reaches each repository's landing branch counts. A fix that has not been merged is not counted. The datasets and their reading rules are on the documentation page.

Why is a defect “to confirm” before it is “confirmed”?

Because a link between two commits is a count, not a judgement. A fix can rewrite code that was right on the day it was written: the business rule changed, a dependency moved, the author of the fix tidied up on the way. The machine sees two commits. It does not know what the team had agreed.

So a defect has one of three statuses.

StatusWhat it saysWho decides
To confirmOnly the machine has counted itNobody yet
ConfirmedA second reading agrees: it is a defectAn administrator, or an automated investigation
DismissedIt is not a defectAn administrator only

The terms of service describe the automated investigation: a model that rereads the code, checked by two others. It can confirm a defect. It cannot dismiss one. Only an administrator dismisses, and that decision prevails.

For a developer, this is the part that matters. A defect counted against your commit is not settled while it reads “to confirm”, and a person can always overrule the machine. The short version is among the questions we get asked.

Why does a defect take 60 days to mature?

A defect shows up after the fact. A commit merged last week has had no time to be fixed: its zero means nothing yet. The last 60 days are therefore not mature, and the stats_schema tool says so.

Three consequences for whoever reads a report:

  1. Do not compare a fresh month with an old one. Example: in a report asked for on 17 November, the commits merged after 18 September are inside the 60 days. Their defect count can still rise.
  2. A closed period can still move. A commit that landed late, two identities merged, a defect dismissed: every summary carries the time it was last computed.
  3. A warehouse has to reread. A data team that loads these statistics rereads at least the last 60 days on each pass. The call is described in Feed developer statistics into your BI.

What does the human decision change?

It settles the count. DeployIt tracks each developer, commit by commit, and the terms of service set the framework: the company informs the people it tracks before it connects its repositories.

A score given by a model is a clue, never on its own the reason for a decision about a person. And the human decision prevails over a defect counted by the machine.

Three habits follow. They are our advice, not rules of the product.

  • Decide who rules on defects. The administrator who confirms or dismisses should be able to read the two commits, or ask the person who can.
  • Rule before you talk. Go through the “to confirm” defects before they come up in a conversation. A 1:1 anchored in delivery is a poor place to find out that half of them should have been dismissed.
  • Read a count next to its commits. Two defects on 130 merged commits and two on 20 are not the same fact. The code grade follows the same rule: it always comes with the number of commits it covers.

A tracked developer finds what is measured, who reads it and what their rights are on the privacy page.

What DeployIt does here

DeployIt is an MCP server. Your company gets one link, https://mcp.deployit.ai/<company>/<code>; each person adds it to Claude (on the web, on the desktop or in Claude Code) and signs up with a name and an email, which is not verified; their questions are logged under that name. Everyone starts with the Everyone profile: questions about the product, answered from the code; a filter removes the code, the file paths and the names of team members it recognises from the answers, without proving their absence, and a leak test tells you what still gets through. An administrator gives the Developers profile (excerpts) or the Leadership profile (developer statistics) to whoever needs it. Repositories are connected from GitHub or GitLab; DeployIt makes no commit, branch or pull request, and only adds one webhook per repository.

The rest, profiles and limits included, is in what DeployIt does, on one page.

Next step: start the trial, connect one repository, add your company link to Claude with the three steps of the connection guide and, with the Leadership profile, ask who introduced the defects fixed this quarter; the demo answers with the Everyone profile, without statistics.

Price. Free plan: 15 questions a week for the whole company. A 30-day trial, no card. Plans from €290 a month excluding tax for up to 25 tracked developers: see pricing.

Ask your code from Claude

30-day trial, no card. Or try the demo first: add https://mcp.deployit.ai/demo to your Claude connectors.

Connect my code

Frequently asked questions

How do I find the commit that introduced a bug?

Three ways. With git bisect, you mark one bad and one good commit and Git narrows the range by binary search. With git blame, you look up which revision last modified the faulty line. Or you start from the fix: the commit that repairs the bug leads back to the commit it repairs, which is the reading DeployIt does for every merged fix.

What is the difference between git bisect and git blame?

According to the Git documentation, checked on 17 November 2026, git bisect searches the history by halves, between a commit you mark as bad and one you mark as good, until it isolates the commit where the bug appeared. git blame goes through a file line by line and tells you which revision and which author touched each line last. Bisect needs a bug you can reproduce; blame needs a line you already suspect.

What does a defect “to confirm” mean in DeployIt?

DeployIt has found the commit that a fix came to repair, and only the machine has counted it so far. An administrator can confirm or dismiss it; an automated investigation that rereads the code can confirm it, never dismiss it. The human decision prevails.

Why are the defects of the last 60 days not final?

A defect shows up after the fact: a commit merged last week has not had time to be fixed. DeployIt treats the last 60 days as not yet mature, and the stats_schema tool says so. A closed period can still move too, which is why every summary carries the time it was last computed.

Can a developer contest a defect counted against their commit?

They raise it with an administrator of their company. Only an administrator can dismiss a defect, and that decision prevails over what the machine counted. The terms of service add that a score given by a model is a clue, never on its own the reason for a decision about a person.

Continue reading

Connect my code