My repo's top committer is a bot

I ran git shortlog -sne on my orchestrator repo last week, the way you do before writing a release note and wanting to thank the right people. I scrolled to the top expecting my own name. It wasn't there. The top committer is forgeai-dev. Second place goes to lthorn — another one of my agents. I show up third and fourth, because at some point I managed to give myself two git identities across two machines.

Here's the leaderboard, near enough as it sits in the repo:

   188  forgeai-dev    <forgeai-dev@toyboxcreations.net>
   181  lthorn         <lthorn@toyboxcreations.net>
   125  slowder        <slowder@toyboxcreations.net>
    97  Shannon Lowder <slowder@toyboxcreations.net>
    67  Claude         <claude@anthropic.com>

Two of my agents on top. Me in third and fourth — and if you count the Claude identity that signs AI-authored commits, arguably fifth too. If you'd told me three years ago that the most prolific contributor to my flagship project would be a process, not a person, I'd have assumed I'd lost control of the repo. It's the opposite. This is what it looks like when the loop is working — and, more to the point, when you can still tell who did what.

That's not one bot. It's a team of personas.

Let me be precise, because "a bot wrote my code" gets oversold. Those two top entries aren't one agent wearing two hats — they're two different roles, and the split is the whole point.

Early on, I ran what amounted to a single agent: Lorin Thorn — lthorn — my chief of staff. Everything routed through Lorin. Planning, coding, reviewing, all of it. That's why lthorn sits near the top of the list: for months it was the only worker, so every commit carried its name. Convenient, and a little bit of a lie — because "Lorin did it" told me nothing about which part of the process actually produced the change.

So I started taking Lorin apart. forgeai-dev is the dedicated developer persona — it owns the straightforward implementation work, which is why it has already overtaken Lorin at the top. A code-reviewer persona is taking over the LLM-based review pass. And Lorin is moving up, not out — into a PM and scrum-master role, running my projects, holding them to my delivery standards, and only pulling me in when a project as a whole is in trouble. As the workflows demand it, I'll add more: an analyst, whatever the next bottleneck calls for. I'm not building one clever bot. I'm building a small SDLC team and giving each role its own identity.

Why split one agent into many? Provenance.

Here's the part I care about most, and it's the reason the overhead is worth it. When every persona commits under its own name, inside a known workflow, at a known node, I can ask a question a single catchall identity can never answer: who made this change — which role, in which workflow, at which step? "Lorin did everything" is a black box. "forgeai-dev wrote it, the code-reviewer persona signed off, at these nodes in this run" is an audit trail.

And that trail is about to get deeper. Each persona is getting its own persistent memory — so the reviewer remembers the standards it has enforced, the developer remembers the patterns it has settled on, and nobody shows up to every run a fresh amnesiac. Identity, plus memory, plus a known position in the workflow, is what turns "the bot did it" into something I can actually inspect.

That matters because of a line I'd tattoo on the inside of every automation enthusiast's eyelids: automation of any kind, without auditability and provenance, is one mistake away from disaster. A loop that can land 188 good commits can land 188 bad ones just as fast — and if every one is signed "the bot," you will never find the single change that took you down. Provenance isn't paperwork. It's the difference between an autonomous system you can operate and one quietly accruing risk you can't see until it detonates.

Why I have two names in my own git history

You probably caught the thing I was hoping you'd catch: slowder and Shannon Lowder are the same person — same email, different display name. That's 125 and 97 commits that should be a single 222, split because I once committed from a machine where I'd never run git config user.name, and the default stuck.

It's a small mess, and a telling one. The agents commit under a stable, configured identity every single time. I'm the one who shows up under two names. When you start sharing a commit history with a process, the process is the disciplined one and you're the source of the entropy. That alone reordered my sense of who needs the guardrails around here.

What changes when a process is your top contributor

The leaderboard isn't a vanity metric. It changed how I work, concretely:

• I review more than I write. My highest-leverage hours stopped being "implement the thing" and became "read what the persona implemented and decide if it ships." Different muscle — the one worth building.
• Issues became the interface. The agents work off Forgejo issues, so a well-written issue is now a unit of production. A vague issue earns me a vague PR. I write issues more carefully than I used to write code.
• The repo runs while I sleep. A chunk of those commits landed during hours I was nowhere near a keyboard. For a solo operation, that's the entire game — leverage that doesn't need me in the room.

Where it bites

I won't hand you a clean story, because it isn't one. A persona that commits 188 times will commit 188 times' worth of mistakes if you let it, and it'll do it fast. Three things had to be true before this was a net win. The review gate is non-negotiable — every agent PR gets read before merge, by me or by the reviewer persona. The per-persona identity is what makes a regression findable — when something breaks, "who wrote this" needs a real answer, and "the bot" isn't one. And the line on what an agent may do without me has to be drawn at what's reversible, not at how confident the model claims to be.

The bot being my top committer was never a story about replacing myself. It's a story about changing the job — from the person who writes the code to the person who decides what good looks like, and who can still trace every line back to the role that produced it. The typing is increasingly not mine. The judgment, and the audit trail, still are. Those are the parts I'd never automate away.

If you're running an autonomous dev loop, I'd love to know what your git shortlog says — and whether you can still tell which of your agents did what. As always, I'm here to help.