Commit History: GitHub's New All-Time Commit Leaderboard Explained (2026)

On June 28, 2026, a small side project called Commit History hit developer Twitter the way a leaderboard always does: everyone looked themselves up, the people at the top posted screenshots, and everyone else argued about what the numbers actually mean.

The site — commit-history.com, built by peetzweg — does for GitHub commits what star-history.com did for repository stars: plot cumulative totals over a user's lifetime and rank the all-time leaders. Public commits. Private commits (for users who expose them). Combined totals. One URL per username. Instant bragging rights — or instant existential crisis.

In the first 48 hours, indie hackers discovered they had more private commits than most engineers have public ones. Open-source maintainers found themselves outside the top 100 despite decades of work. And the AI-agent crowd asked the question that defines 2026: if Claude Code commits for you, does the number still count?

TL;DR — what people are asking

Niche questions answered (the searches after you look yourself up)

Most traffic to Commit History does not stop at the homepage. People look up steipete, feel inadequate, then search specific follow-ups. These are the ones that actually came up in launch-week threads — answered directly.

"Why is my number lower than I expected?"

Nine causes, in order of how often they explain a gap:

1. You squash-merge. One merged PR = one commit on main. Your branch might have had 40 commits; the leaderboard sees one. Teams that rebase-merge preserve all 40.
2. Wrong git email. Commits authored as you@company.com do not count until that email is verified on your GitHub account under Settings → Emails.
3. Org work attributed elsewhere. Commits on org repos count if GitHub links them to you — but squash-by-maintainer, bot merges, or "Co-authored-by" splits can shift attribution.
4. Private work hidden. If you never enabled private contributions, Commit History shows public repos only — while your real output might be 90% private (levelsio's pattern).
5. You review more than you commit. PR reviews, issues, and discussions do not increment commit totals. Neither do Stack Overflow answers or Notion docs.
6. Short career window. The chart is lifetime cumulative. Someone who started committing daily in 2010 will beat someone who started in 2022 even if the latter ships faster today.
7. Deleted repos. Usually still counted if GitHub retained events — but edge cases exist after account migrations or force-pushes that rewrite history.
8. Different tool, different number. GitHub's green squares count "contributions" (commits + PRs + issues in some cases). Commit History counts commits only.
9. Stale cache. Viral launch means API lag. Recheck after 24–48 hours if you just enabled private visibility.

Quick diagnostic: run locally on a repo you own:

git shortlog -sn --all --author="$(git config user.email)"

Compare that author count to what GitHub attributes — if local is higher, your email linkage is the problem, not Commit History.

"Why is steipete #9 on public but #1 on combined?"

Because ~77% of his counted commits are private (~208k private vs ~61k public as of June 29, 2026).

Public rank rewards long-visible OSS history (Dicklesworthstone, rgbkrk, theorem-prover maintainers). Combined rank rewards total git volume across a career, including private agent experiments, client repos, and unreleased tooling — which is exactly how OpenClaw-era shipping works.

Same pattern for fabpot (~88k public, ~168k private, ~255k combined): Symfony's public face plus years of private Symfony Ltd work.

Takeaway: Public leaderboard ≈ "who maintained visible open source longest." Combined leaderboard ≈ "who touched git most overall, including hidden repos."

"Why does brahimhamichan have 600k private commits?"

At ~601k exposed private commits, brahimhamichan is 3× steipete and 3.7× levelsio on the private list alone — the largest outlier on the entire site at launch.

Commit History does not publish repo names for private totals, so explanations are inference:

Do not treat 600k as a target. Treat it as proof the leaderboard measures events, not normalized engineering output.

"How do I get on the private leaderboard?"

Three steps — no Commit History account needed:

1. GitHub → Settings → Profile → check "Include private contributions on my profile" (exact label varies).
2. Confirm your contribution graph shows dark green + light green squares (private days appear shaded).
3. Wait for Commit History to re-fetch — search your username, toggle Private or Both.

What this does not do: expose repo names, commit messages, or code. It only allows aggregate private commit counts to be read by tools GitHub permits — same as your profile graph.

Privacy note: If you enable this, anyone can see that you commit privately on some days — not what you committed. Recruiters and curious strangers already used this setting pre-Commit-History; the site just sums it.

"Do merged PR commits count, or only direct pushes?"

Commits that land on the default branch and GitHub attributes to you count — whether you pushed directly or merged via PR.

What does not count the same way:

This is why two engineers with identical merged LOC can differ by 5–10× on Commit History: merge strategy, not effort.

"Can AI coding agents inflate my rank — and by how much?"

Yes. Rough order-of-magnitude for heavy agent users in 2026:

Over five years of agent-native shipping, that is how private totals reach six figures without "fake" data — just high-frequency git events.

That does not mean the human did nothing. It means the harness chose to commit often. See loop engineering with Claude Code for why agents default to commit-per-action.

Hiring implication: Ask for PRs and design docs, not Commit History screenshots.

"Why do indie hackers beat FAANG engineers on this list?"

Because the leaderboard rewards volume over employer prestige:

• Indie hackers (levelsio, steipete) commit across dozens of personal/private repos, ship daily, rarely squash, and increasingly use agents — all inflating totals.
• Big-co engineers often work in monorepos with squash-merge, shared git identities on internal tools, or code hosted off GitHub entirely.
• Maintainers (fabpot, gaearon) rank high when their public OSS career is decades long — different path, same volume logic.

Arnav Gupta noted on X his public commits sit just outside the top 100 — between Guillermo Rauch and Addy Osmani — which matches "senior visible engineer, not daily micro-commit indie hacker."

None of this ranks impact. Stripe engineers do not need 150k commits to matter.

"Is Commit History safe / official / storing my lookups?"

If you do not want to appear in "Recently looked up," wait until that feature changes or ask peetzweg — do not search yourself speculatively if that bothers you.

"Commit History vs star-history vs GitHub profile — what's the difference?"

Use star-history in READMEs to show project traction. Use Commit History for career commit narrative — knowing the caveats above.

"Should I change how I commit to climb the leaderboard?"

No — unless you want a higher number for its own sake.

If you want commits to mean something when agents are involved:

# Before merging agent work to main — squash WIP on a feature branch
git checkout feature/agent-run
git rebase -i main   # squash "fix", "wip", "try again" into one commit
git checkout main && git merge --squash feature/agent-run
git commit -m "feat: add payment webhook handler (agent-assisted)"

Better metric for teams: merged PRs with tests, incident resolution time, or revenue — levelsio's actual scoreboard.

What Commit History actually shows

The homepage is deliberately minimal. You type a GitHub username, get a cumulative commit chart, and can flip between public, private, and both views.

Three features drove the viral loop:

1. Per-user lifetime plots — not a calendar heatmap, but a running total across a career.
2. Global leaderboards — sortable top lists for public, private, and combined commits.
3. "Recently looked up" — a social proof ticker showing who the internet is stalking (steipete, levelsio, Dicklesworthstone, and dozens of others appeared within hours of launch).

Private rankings only include users who have enabled private contribution visibility on GitHub. That is a critical caveat: the private leaderboard is not "all private commits on GitHub" — it is "private commits from people who opted to show them." The true private kingpin is almost certainly someone who keeps private stats hidden.

The leaderboards as of June 29, 2026

Numbers move as GitHub ingests new data. These reflect what Commit History displayed at launch plus the first day of lookups.

Public commits (top 10)

Private commits (top 10, exposed only)

Combined totals — why steipete dominates the conversation

Add public + private for the names X cared about most:

Peter Steinberger's combined total made him the poster child for the launch — not because public commits rank first, but because he is visibly building OpenClaw and shipping with AI-native workflows while sitting at the top of the both leaderboard. Pieter Levels posted that he had the most private commits among exposed profiles alongside steipete — which, for an indie hacker famous for shipping dozens of micro-products, scans as on-brand.

Vincent Koc landed in the top 25 all-time on combined lookups. Jay Meistrich pointed people to the site for exploration. banteg noted finding himself "in good company." The pattern was consistent: the leaderboard rewards people who have been committing daily for a decade or more, often across many repos, often with agents now accelerating the pace.

How GitHub counts a "commit" — and why the leaderboard is gameable

Before treating Commit History as a skill score, understand what increment the site is summing.

GitHub counts commits authored on the default branch (and contributions via merged PRs depending on settings). What it does not normalize:

The Git beginner's guide on explainx.ai covers what a commit actually is — a snapshot pointer in git history, not a unit of value.

Bottom line: Commit History measures git event volume, not engineering impact. A single well-designed API migration might be three commits. A vibe-coded prototype might be three hundred.

The AI-agent question: do commits still mean you shipped?

This is the debate that made the launch more than a novelty.

In June 2026, a meaningful slice of the leaderboard's upper tier ships with coding agents in the loop. Peter Steinberger's public persona is explicitly agent-native — terminal agents, harness design, high-frequency iteration. Pieter Levels has talked for years about using AI to accelerate indie product development. Neither hides that machines write a lot of the diff.

Three honest positions emerged on X within 24 hours:

1. "Hard work pays off"

The optimistic read: cumulative commits correlate with years of showing up. The top public names include maintainers who held critical open-source infrastructure for a decade (fabpot/Symfony, gaearon/React, leodemoura/Lean). The number is a proxy for ** sustained output**, not a lottery ticket.

2. "The number is meaningless now"

The skeptical read: when Claude Code or Cursor Agent can commit, run tests, and retry in a loop, commit count measures harness aggressiveness as much as human effort. Two developers with the same merged LOC can differ by 10x in commit count based on agent settings alone.

3. "It's fun — stop overthinking it"

The pragmatic read: star-history was never a quality metric either. It was a storytelling tool — "look how this repo grew." Commit History is the same for people. Look up your username, share the chart, get back to work.

explainx.ai's read: all three are partially true. The leaderboard is real data with real career correlation at the extreme top — nobody accidentally commits 200,000 times. But in the AI-agent era, the margin between ranks 500 and 5,000 tells you less about skill than it did in 2020.

For the full stack of what actually makes agents ship reliably — prompt, context, loop, harness — see Context vs Prompt vs Loop vs Harness Engineering.

Who is peetzweg, and why star-history was the right template

peetzweg (GitHub: @peetzweg) built Commit History as a direct homage to star-history.com, the charting tool developers use in READMEs to show repo growth curves. The insight was simple: stars measure project attention; commits measure person persistence — and nobody had made the second one easy to look up.

The site itself is lightweight: username in, chart out, leaderboard for comparison. peetzweg added a "Buy me a coffee" link — standard indie-tool monetization for something that will cost real money in GitHub API quota if it stays viral.

Recently looked-up users on launch day included a mix of indie hackers, Canva engineers, and agent builders — a cross-section of exactly who commits most in 2026.

What Commit History is bad at (on purpose)

For engineering evaluation, use PR review quality, incident ownership, system design — not a public scoreboard. For curiosity and culture, Commit History is excellent.

How to look yourself up (and what to do with the result)

1. Go to commit-history.com.
2. Enter your GitHub username in the search box.
3. Toggle Public, Private, or Both — private only works if you enabled "Private contributions" in GitHub profile settings.
4. Compare against the all-time leaderboard tabs.

If your number is lower than expected: check whether you squash-merge, whether most work lives in org repos under a different email, or whether you simply have not enabled private visibility.

If your number is higher than expected: check for old bot commits, fork sync patterns, or an agent harness that commits aggressively — all common in 2026.

If you are building with agents and want commits to mean something: adopt intentional git hygiene — meaningful commit messages, squash before merge on shared branches, and separate agent WIP branches from main. That is loop engineering applied to version control, not just model prompts.

The bigger picture: metrics in the agent era

Commit History arrived the same week developers argued about token economics pushing agent adoption and types of AI agents maturing from chatbots into autonomous loops.

The pattern across all of it: easy metrics get popular fast; hard metrics stay rare.

• Stars → project hype
• Commits → activity volume
• SWE-bench → benchmark scores on narrow tasks
• Revenue → the metric indie hackers actually care about (levelsio's world)

None replace the others. Commit History fills a gap star-history never could — personal output over a career — at the exact moment when "personal output" is the hardest thing to define.

Whether that makes you feel inspired or skeptical probably says more about how you ship than where you rank.

Summary

Commit History (commit-history.com) is peetzweg's star-history-style leaderboard for lifetime GitHub commits. It went viral around June 28–29, 2026, with Dicklesworthstone leading public commits, brahimhamichan leading exposed private commits, and steipete (~268k combined) dominating the conversation on X.

The site is fun, flawed, and culturally timed: it turns git history into a scoreboard at the moment AI agents make git history easier to inflate. Use it for curiosity and storytelling — not hiring decisions.

Related reading on explainx.ai

• What Is Git? How to Push Code to GitHub — what commits actually are
• Loop Engineering with Claude Code — why agents commit so often
• Types of AI Agents — coding agents vs other agent types
• Why AI Companies Want You Using Agents — token economics behind agent loops
• Top 10 AI Agent Loops for Coding Workflows — production loop patterns that generate commits
• Building AI Agents pathway — structured learning for agent architecture

External: commit-history.com · star-history.com · GitHub profile contribution settings

Leaderboard figures and usernames reflect commit-history.com as observed on June 29, 2026. Rankings update as GitHub data refreshes and users change private visibility settings.