The board says twelve items are Done. The repo says nine of them merged, two are sitting on branches nobody has touched in a week, and one got dragged to Done during a Friday afternoon tidy-up. It also has four things on main that never had a ticket.
Neither one holds the whole sprint. The board is what the team agreed to do, and the repo is what got committed. Finding the work that fell between them, or never reached either, is a big part of a Scrum Master's job.
Git can help with one piece of that. It'll show you where the board and the repo disagree, and you don't need to write code to ask it. It can't show you anything that never became a commit, and some sprints that's most of what happened.
Where work hides
Ask two questions about any piece of work from the sprint. Is it on the board? Is it in the repo?
| In the repo | Not in the repo | |
|---|---|---|
| On the board | Planned work that shipped | A Done card with nothing merged, or In Progress with no branch |
| Not on the board | Work that shipped without a ticket | Support, reviews, meetings, waiting on another team |
The top left is the sprint going to plan. Git can show you the top right and the bottom left, where the board and the repo disagree. Nothing records the bottom right, so the only way in is to talk to people.
I'd start with the bottom left. It's work the team already did and nobody counted.
Read the repo without changing it
Everything below runs in a terminal, against a clone of your team's repo. The only command that changes anything is fetch, and all it does is update your copy of what's on the server. If terminals make you nervous, skip to the version with buttons.
Your clone only knows what it fetched last time, so start there:
git fetch --all --prune
--prune drops branches that were deleted on the server, so you don't count work that already merged and got cleaned up.
What shipped without a ticket
Merged work lands on the main branch. To see just the merges and direct commits, without every commit from inside every branch, use --first-parent:
git log origin/main --first-parent --since="14 days ago" --oneline
Each line is one piece of work that reached main. With merge commits, it reads like "Merge pull request #418 from team/PAY-1432-refund-flow". If your team squashes, it's the pull request title.
If your team puts ticket keys in branch names or commit messages, you can hide every line that has one:
git log origin/main --first-parent --since="14 days ago" --format="%h %an %s" | grep -vE "[A-Z]+-[0-9]+"
Everything left reached main with no ticket attached. Skip the dependency bots and read the rest. It tends to be a hotfix, a favor for another team, a refactor somebody did while they were already in the file, or a config change that felt too small for a ticket.
None of that is bad work, and most of it probably needed doing. But the sprint plan didn't leave room for it, so it came out of the time set aside for something else. If the same kind of thing turns up sprint after sprint, I'd bring it to the retro as a planning question. Nobody needs a lecture about tickets.
What's Done on the board but not on main
Now the other direction. Pull just the ticket keys out of the same log:
git log origin/main --first-parent --since="14 days ago" --format="%s" | grep -oE "[A-Z]+-[0-9]+" | sort -u
That's every ticket that reached main in the last two weeks. Hold it up against the board's Done column. A Done card that's missing from the list might have shipped from a different repo. It might not have needed code. Or it might not be done. Git can't tell you which, so that one goes on your list of questions.
What's gone quiet
Branches that haven't moved in a while deserve a question too. To list every remote branch by its last commit:
git for-each-ref refs/remotes/origin --sort=-committerdate --format="%(committerdate:relative) %(refname:short) %(authorname)"
The oldest ones are at the bottom. A week without commits doesn't mean something's wrong. It does mean somebody should ask.
While you're reading that list, look for branch names with no ticket key. That's work in progress the board doesn't know about yet.
To see how far a branch has fallen behind main:
git rev-list --count origin/team/PAY-1501..origin/main
That's how many commits on main the branch doesn't have. The farther behind your are, the more merging starts to hurt.
Since git 2.38 you can also test a merge without touching any files:
git merge-tree --write-tree origin/main origin/team/PAY-1501
A single hash on its own means it would merge cleanly. A list of conflicts means somebody is going to lose an afternoon to it. Better to know that before the review than to find out in the middle of it.
Who was involved
git shortlog -sn origin/main --since="14 days ago" --no-merges
That's commits per person. Use it to make sure the right people are in the review, and for nothing else.
A commit count says nothing about effort or value. Put it on a slide and you'll lose the team's trust faster than any other way I know.
Don't be creepy with it
Anyone with access to the repo can see all of this, so none of it is secret. It still needs care. I use it to find questions:
- "PAY-1501 hasn't moved in nine days. Is it blocked on something I can help with?"
- "The board says the export work is done, but I don't see it on main. Did it ship somewhere else?"
- "There's a fix on main from Tuesday with no ticket. Did something come in sideways?"
I don't use it to rank people. The day a team suspects you're counting their commits, they start making more, smaller ones, and your numbers stop meaning anything.
Besides, somebody with two commits in two weeks was busy with something. Whatever it was, git didn't record it.
What the repo will never show you
That's the bottom right box. Git only sees work once somebody commits and pushes it, and a lot of a sprint never gets that far:
- code review, which happens on your host and mostly stays there
- support questions, incidents, and "can you take a quick look at this"
- pairing, where two people's afternoon lands under one name
- interviews and onboarding
- waiting on another team or a decision
- research that ends with "we shouldn't build this"
I wrote about one of these a while back. A developer said "no blockers" at every standup and rarely had a commit before noon. The commit times were only a hint. They'd been spending their mornings helping QA troubleshoot flaky tests, and nobody had put that on the board. I found out by asking what their morning looked like.
For this box, the tools are the ones you already have:
- At standup, listen for "I got pulled into" and "I was helping".
- Your host's pull request list shows what's waiting on review, and who keeps doing the reviewing.
- The support or incident channel has the interruptions that never became tickets.
- In the retro, ask what people spent the sprint waiting on.
The repo is one more place to look. What it has going for it is that you can check it in a few minutes without interrupting anyone.
The version with buttons
Pasting these commands every two weeks got old, so I built them into Git Revenge, a free desktop git client I maintain. Its Insights tab does the repo part of this prep, and only the repo part.
The Shipped view lists what landed on main in the window, grouped by ticket key. Anything without a key is grouped at the end, which gives you the shipped-without-a-ticket list without the grep. If you set up a link pattern for Jira or Azure Boards, each key links to the ticket. Items that arrived as a merge show their cycle time, from the branch's first commit to the merge. Dependabot and Renovate updates get folded into their own group, so they don't pad the count.
Needs attention flags open branches that cross a line: no commits in 7 days, older than 14, more than 50 commits behind, more than 500 lines changed, or a trial merge that conflicts. You can change all of those thresholds.
Hotspots shows which files changed most, and flags any that open branches are also changing. That's usually where the next conflict comes from. Under it, Rework lists the reverts and fixup commits that landed. The board hides those too: a story that was merged, reverted and merged again is still one Done card.
When you're done, Copy summary turns it all into Markdown for your review notes, and Export CSV gives you a spreadsheet.
The window can be the last 7 or 14 days, the month so far, or everything between two releases. It's measured up to the latest commit on main, not up to "now", so the numbers don't drift if you reopen it tomorrow. Every export lists the commits and settings it came from. If your team works across several repos, put them in a project group and Insights combines them.
Insights only knows what git knows. Pull request reviews, ticket states and story points aren't in there, and it deliberately doesn't chart individual productivity. It won't find the QA favor either. What it does is get the repo part of your prep out of the way, so there's more time left for the conversations that find the rest.
It's also a full git client, not a viewer, and there's no read-only mode yet. If you only want to look, keep a separate clone just for review prep and only ever fetch into it. Insights itself never changes the repo.
It runs on Windows, macOS and Linux. The first time, ask a developer on your team to help you clone the repo. After that, press Ctrl+K and type "Insights". The Insights guide explains where every number comes from.






