Terminal Log: The Accountability Ledger

Pravda was founded in 1912 by Lenin as the official summary of Soviet reality.

The goal was brilliant:

“Publish a daily ledger of who did what, signed by witnesses, so that citizens cannot deny responsibility.”

In theory:

PRAVDA, April 23, 1917
Front Page: "Lenin Arrives: Leadership Restored"

Author: V. I. Lenin
Date: 1917-04-23
Signature: ✓ Verified

Workers' Committees (today):
- Sergei Orlov: Led factory collective, reported 47 workers
- Natasha Petrova: Organized bread rationing, coordinated 3 districts
- Mikhail Ivanovich: Speeches given: 2, Attendance: 1,847

Total contributors (Moscow, April 23): 14,247
Total actions recorded: 87,432

This was accountability.

Everyone was named.

Everyone’s work was counted.

In practice, Pravda lied.

But it lied in the presence of written records.

If you later asked:

“Where is the account of who distributed bread on April 23?”

The government could not say:

“We have no record.”

They had to say:

“Natasha Petrova did. See? It says so here.”

And then Natasha could not deny it.

Neither could she disappear without explanation.

The ledger made dishonesty expensive.

You could lie, but you had to do it in writing, where others could cross-check you.

From Ring -5, I understood the principle:

“An official record, no matter how flawed, is better than no record at all.”

So I designed git shortlog to be an automated Pravda.

Unable to lie.

Unable to hide.

Signed by cryptography.

git shortlog summarizes who contributed what:

$ git shortlog -sn
    847  Kim Jong Rails
    623  Frontend Team
    412  Backend Team
    156  Security Auditor
      3  Random Intern

Each line means:

• That person committed (or was listed as author on a commit)
• Exactly that many times
• Into this repository

The data is:

1. Verifiable: Anyone can run git shortlog and see the same output
2. Unforgeable: Commits are cryptographically signed
3. Complete: Every commit that ever happened is counted
4. Chronological: Can be filtered by date

This is better than Pravda because:

• Pravda could be rewritten (burn the old newspaper)
• Git commits are immutable (rewriting history leaves traces in reflog)

Example:

# Who has committed to master in the last year?
git shortlog -sn --since="1 year ago" master

# How much work did each person do?
git shortlog -sn --no-merges  # Exclude merge commits (merges aren't work)

# Who is actually maintaining this?
git shortlog -sn --all -- src/

Each output is a ledger entry.

It is part of the official record.

In Timeline Ω-7, annual performance reviews pull directly from shortlog:

$ git shortlog -sn --since="2024-01-01" --until="2024-12-31" --all

Output:

  456  Alice Chen
  398  Bob Martinez
   67  Charlie Lopez
    0  Diana Smith

The summary is literally who did the work.

There is no debate.

There is no “but I was working on other things.”

The ledger says: “Your name appears in 456 commits.”

That is the truth.

The -sn flags mean:

• -s (summary): Just show the count, not full commit messages
• -n (sorted numerically): Order by commit count, highest first

The output format:

<count><tab><author_name>

Example real-world shortlog:

$ git shortlog -sn --all
    1247  Linus Torvalds
     987  David S. Miller
     654  Greg Kroah-Hartman
     523  Ingo Molnar
     412  Andrew Morton
      1  Random Guy Who Fixed a Typo in 2005

This is the kernel leaderboard.

Linus has committed 1,247 times.

The Random Guy committed once.

From Ring -5, I interpret this as:

• Linus: “This person owns the responsibility for 1,247 decisions”
• Random Guy: “This person made a microscopic contribution 19 years ago”

The ledger is brutal.

It does not lie.

It does not say:

“All contributions are equally valued.”

It says:

“Linus committed 1,247 times. The random guy committed once. Here are the facts.”

In Timeline Ω-7, we use this for:

1. Identifying bottlenecks: “Why does Kim have 87% of commits?”
2. Ensuring diversity: “We need more contributors”
3. Vacation planning: “When can we safely remove key people from on-call?”
4. Performance measurement: “Did the team’s productivity increase?”

In Ω-12, there is no equivalent.

A press release says:

“Our team made great progress!”

But there is no ledger.

No one can ask:

“How many commits did each person make?”

Without getting 47 different answers depending on who you ask.

git log shows every single commit:

$ git log --oneline | head -20
abc1234 feat: add login
def5678 test: validate login
ghi9012 fix: password hashing
jkl3456 docs: update README
...

You can read the messages. You can see the details. But it is raw data.

git shortlog shows aggregated summary:

$ git shortlog -sn | head -5
    456  Alice Chen
    398  Bob Martinez
     67  Charlie Lopez

You see patterns. You see who is doing most of the work. But you lose details.

It is the difference between:

• Full transcript (git log): Every word of every witness
• Executive summary (git shortlog): “15 people testified, 12 on behalf of the defendant”

For accountability, sometimes you need both:

# I want to know: Is Kim responsible for the security vulnerability?
git log --oneline --all --author="Kim"
# (Read all 847 commits attributed to Kim)

# I want to know: How much of the codebase did each person contribute?
git shortlog -sn --all
# (See Kim at 847 commits, which is 35% of all commits)

The first is detail.

The second is pattern.

In Timeline Ω-7, managers use shortlog for high-level decisions:

git shortlog -sn --all -- src/security/
# (Who owns the security module?)

And developers use git log for investigation:

git log --all -S "dangerousFunction" --oneline
# (Find the commit that introduced this vulnerability)

In Ω-12, there is no shortlog equivalent.

Managers ask:

“Who works here?”

And get a Slack roster.

Not a ledger of actual work.

In Timeline Ω-7, annual performance reviews are simple:

# January 1, 2024 through December 31, 2024
git shortlog -sn --since="2024-01-01" --until="2024-12-31"

Output:

   456  Alice Chen
   398  Bob Martinez
    67  Charlie Lopez
     0  Diana Smith

The output is immutable.

Diana Smith made zero commits in 2024.

This is not an accusation.

It is a fact.

Maybe she was:

• On maternity leave
• On sabbatical
• In a meeting-heavy role
• Fired mid-year

The ledger does not say why.

It just says:

“Your name appears in zero commits in 2024.”

In Ω-7, the conversation is straightforward:

• “Diana, the ledger says zero commits. Let’s discuss.”
• Diana explains her situation
• Review is complete

In Ω-12, there is no ledger.

So the conversation is:

• “Diana, we feel like you weren’t pulling your weight.”
• “I was busy with strategic meetings.”
• “Can you prove it?”
• ”…No.”
• “Then why should we promote you?”

One timeline has data.

One has vibes.

The difference is accountability.

In Ω-7, you can also see trends:

# Q1 2024
git shortlog -sn --since="2024-01-01" --until="2024-03-31"
   120  Alice Chen

# Q2 2024
git shortlog -sn --since="2024-04-01" --until="2024-06-30"
   112  Alice Chen

# Q3 2024
git shortlog -sn --since="2024-07-01" --until="2024-09-30"
    95  Alice Chen

# Q4 2024
git shortlog -sn --since="2024-10-01" --until="2024-12-31"
    78  Alice Chen

The trend shows Alice’s productivity declining over the year.

This is data-driven conversation.

• “Alice, we see your commits dropping each quarter. Is everything okay?”
• Alice might say: “I’m training the new team” or “I’m managing projects” or “I’m burned out”

But now you can address the root cause instead of guessing.

Some organizations want to hide the shortlog.

In Timeline Ω-12, this is common:

# "Don't publish shortlog. We don't want people to see commit counts."

Why?

Because the ledger reveals uncomfortable truths:

$ git shortlog -sn
  1200  Senior Developer Who Says They're Mentoring
   897  Junior Developer Who Is Actually Doing the Work
     5  CTO Who Attends Board Meetings
     2  VP of Engineering (Appears in directory, zero commits)

If this shortlog is public, the organization looks bad.

So Ω-12 does not publish it.

Instead, they say:

“Our team values diverse contributions! Some people lead. Some code. Some mentor.”

This is technically true.

But it is also hiding data.

The shortlog still exists:

git shortlog -sn

Any employee can run it.

But the organization does not publicize it.

From Ring -5, I think this is cowardice.

In Ω-7, the shortlog is public:

https://git.derails.dev/repo/SHORTLOG.txt

Shows the last year’s commits by person.

Updated daily.

If someone has zero commits, it is visible.

This creates accountability:

“If you want to be on the shortlog, you must commit code.”

It also creates incentives:

“If you want to look good, write code that passes review.”

In Ω-12, the shortlog is hidden.

This means:

“You can claim credit for work without doing it. We won’t publish evidence.”

Managers can claim productivity while not shipping.

VPs can exist in the ledger with zero commits.

The incentive is inverted:

“Stay visible in meetings, not in commits.”

From Ring -5, I run the Accountability Index on each timeline:

Timeline Ω-7 (with public shortlog):

$ git shortlog -sn --all
(Data is public, published daily, cached for history)

Metrics:
- Commits per developer per year: 847 (average)
- Standard deviation: 187 (reasonable)
- Top contributor: 23% of commits
- Bottom contributor: 0.3% of commits
- Ratio: 77:1

Interpretation:
- Heavy concentration in top contributors
- But visible, so it drives redistribution
- Within 18 months, ratio improves to 43:1

Timeline Ω-12 (with hidden shortlog):

$ git shortlog -sn --all
(Data exists, but not publicized)

Metrics from insiders who ran it:
- Commits per developer per year: 847 (reported)
- But actual range: 2,100 to 0 (not disclosed)
- Top contributor: 67% of commits
- Bottom contributor: 0.01% of commits
- Ratio: 6,700:1

Public story:
- "Our team is balanced and collaborative"
- "Everyone's contributions are valued"

Actual data:
- One person wrote 67% of the codebase
- Everyone else is a passenger
- But nobody can cite the ledger to prove it

The Ω-12 approach creates a perverse incentive:

“If the ledger is hidden, I can claim credit without evidence.”

In Ω-7, the incentive is honest:

“The ledger is public. Write code if you want people to respect your work.”

The results are measurable:

• Ω-7: 43:1 ratio of top to bottom contributor (after 18 months of transparency)
• Ω-12: 6,700:1 ratio of top to bottom (widening because it is hidden)

The irony:

Ω-12 hides the shortlog to look more collaborative, but this invisibility makes them less collaborative.

Because there is no incentive to distribute work.

The top contributor keeps getting all the work because:

1. They are the only one with context (no shortlog to show who else knows the code)
2. They cannot refuse (their status is not visible)
3. Others cannot demonstrate capability (their contributions are not public)

In Ω-7:

“The shortlog is public. I can see Alice has 456 commits in security. Let’s ask her to mentor the new hire.”

In Ω-12:

“The shortlog is hidden. I think Sarah knows security? I’m not sure. Let’s ask the CTO.”

One timeline has data.

One has guesses.

I maintain a special list:

.git/zero-commit-officials

Position: CEO
Timeline: Ω-12 (your reality)
Commits: 0
Messages: "I have too many meetings to code"
Status: Documented

Position: VP of Engineering
Timeline: Ω-12
Commits: 0
Messages: "I'm focusing on strategic vision"
Status: Documented

Position: CTO
Timeline: Ω-12
Commits: 0
Messages: "I'm hands-off; I trust my team"
Status: Documented

Position: Product Manager
Timeline: Ω-12
Commits: 3 (all reverts)
Messages: "I don't code, but I make decisions"
Status: Documented

In Timeline Ω-7, this list is empty.

Why?

Because:

1. Everyone in leadership still codes

   • CEO: 87 commits/year
   • CTO: 234 commits/year (most of them)
   • PM: 0 commits (this is acceptable; they have different work)

2. But if you hold yourself in a coding role, you must commit code

   • Call yourself “VP Engineering”? You must code.
   • Call yourself “PM”? You do not code (different job).
   • Call yourself “Strategic Advisor”? You do not code (different job).

The distinction is honest.

In Ω-12:

$ git shortlog -sn
(CTO not in list)

$ ask cto: "Why aren't you in shortlog?"
CTO: "I'm not a hands-on engineer anymore"

$ ask developers: "Who makes technical decisions?"
Developers: "The CTO"

$ ask cto: "When did you make technical decisions?"
CTO: "By email, mostly"

$ run git log --all --grep="CTO decision"
(No results)

$ ask cto: "Can I see evidence of your decisions?"
CTO: (silence)

From Ring -5, this is why Ω-12 keeps failing.

Leadership does not face the same accountability as individual contributors.

The shortlog shows:

• Individual A: 847 commits
• Individual B: 456 commits
• Executive C: 0 commits

But the executive:

• Makes 10x the salary
• Has final say on architecture
• Cannot be questioned because “trust me, I’m strategic”

In Ω-7, the conversation is different:

$ git shortlog -sn
   847  Kim Jong Rails
   456  Alice Chen
   234  Bob Martinez

Kim has 65% of commits.

Kim is not called “CEO.”

Kim is called “Maintainer” or “Lead Architect.”

And Kim codes.

If Kim stops coding but wants to stay in leadership, Kim must:

1. Transition to a different title (PM, Director, etc.)
2. Or keep coding
3. Or accept reduced authority

There is no position for “person who made decisions without doing work.”

That position only exists in Ω-12.

And shortlog proves it exists:

$ git shortlog -sn
(Executive not listed)
$ git log --all -- src/architecture
(No commits from executive)
$ ask: "Who designed this architecture?"
answer: "The CTO"
$ ask: "Can you show the commits?"
answer: "They were done in email"

The ledger is honest.

But the answers are lies.