GitHub's Postmortem Blames Retry Loops. The Real Story Is AI.

GitHub published their postmortem for the August 17 outage today. It's 622 words. The comment section on HN called it "one of the most vague outage summaries of the year." That's generous — it's shorter than the average press release for a feature nobody asked for.

Here's what the post tells you: a Central US data center failed to scale, a retry loop in VS Code amplified traffic 10x, and they're working on it.

Here's what the post doesn't tell you: GitHub's traffic has roughly doubled in five months. Monthly commits went from 1.4 billion to 2.9 billion since April. A 107% increase in four months.

That's not human growth. That's AI coding agents.

The Numbers That Don't Fit

GitHub drops this number casually in the same postmortem: "Since April, monthly commits have grown from 1.4 billion to 2.9 billion."

Read that again. Not 20% growth. 107%. In four months.

GitHub's entire infrastructure scaled roughly linearly for a decade. User growth was steady. Repo creation was steady. Then AI coding agents hit critical mass, and every single commit by every single agent — across Claude Code, Copilot, OpenCode, Cursor, Windsurf, Codex — flows through GitHub's APIs. Each agent push triggers CI checks, triggers Copilot analysis, triggers Actions runners, triggers PR status updates, triggers webhooks that trigger other services that trigger retries.

The postmortem frames the Central US data center failure as a "scaling" problem. But scaling assumes predictable growth. Nobody predicted 2.9 billion commits in August.

The Retry Loop Is a Symptom

graph LR
  A[AI Agent Pushes Code] --> B[GitHub Actions]
  B --> C[CI Checks]
  C --> D[Status Webhooks]
  D --> E[Copilot Analysis]
  E --> F[PR Notifications]
  F --> G{Service Degraded}
  G -->|VS Code Retry| H[10x Amplification]
  H --> I[Token Service Down]
  I --> J[All Agents Blocked]

The "10x retry amplification from VS Code" that GitHub describes didn't cause the outage. It was the multiplier that turned a regional failure into a global one. The root cause was the data center hitting capacity. The retry loop turned a single-region fire into a multi-region wildfire.

This is the pattern now. Every AI agent pipeline is a chain of retry-happy dependencies. The agent commits → Actions triggers → Copilot analyzes → status pages update → webhooks fire → downstream services retry. One cog hiccups, and the entire chain retries in unison, creating a traffic spike that looks like a DDoS attack by coincidence.

And nobody built for this. Not GitHub. Not VS Code. Certainly not the agents.

What the Postmortem Leaves Out

The post has two sections: "What happened" and "What we have done and what comes next." Between them, it covers roughly three paragraphs of actual substance:

• Central US data center failed to scale
• VS Code retry bug amplified traffic 10x
• Copilot Token Service recovery was delayed
• They're improving autoscaling and retry handling

Missing entirely:

• No timeline. When did the outage start? When did it end? How long was each service degraded?
• No specific mitigations. "Improving autoscaling" is not a plan. What's the new scaling factor? What's the new retry budget?
• No customer compensation. Paid customers burning Actions minutes and Copilot seats during the outage get... a blog post.
• No acknowledgment of the AI traffic problem. The 2.9 billion commits number is presented as a curiosity, not as the elephant in the room.

The comment thread on HN reflects exactly this frustration. One user put it directly: "Paid customer: we know you put your trust in us, so we'll ensure we have a separate pool of capacity to ensure we can keep that trust." The silence from GitHub on this point is telling.

The Broader Pattern

This isn't a GitHub-specific problem. Every platform that serves developers is seeing this AI traffic surge. The numbers are everywhere:

• GitHub commits: 1.4B → 2.9B since April
• Bun downloads: 22M/month, heavily driven by Claude Code and OpenCode
• npm installs: growing faster than ever, but the code being installed is increasingly AI-generated
• CI minutes: spiking across every major provider

The infrastructure layer was designed for a world where humans write code at human speed. One commit, one PR, one review cycle per hour. AI agents operate at machine speed — dozens of commits, iterations, and pushes per minute. And each one looks like a legitimate user to the infrastructure, because it is a legitimate user.

The retry loop wasn't a bug. It was the system correctly identifying that it was under capacity and asking for more — except all the asking happened at once.

What Comes Next

GitHub says they're working on better autoscaling and retry handling. That's necessary but insufficient. The real problem is structural:

1. AI agents need rate-limiting contracts. Not the kind that blocks users — the kind that signals capacity ahead of demand. An agent should be able to say "I'm about to push 50 commits" and get a throttling signal back before the 47th one triggers a retry cascade.
2. Infrastructure needs AI-aware capacity planning. If monthly commits can double in four months, your autoscaler needs to plan for that, not react to it. The current model of "scale up when CPU hits 80%" is dead.
3. Postmortems need more than 622 words. When your platform hosts the code for half the world's software, a vague recap is an insult to every team whose CI pipeline burned on August 17.

The Bottom Line

GitHub's August 17 outage was the first major infrastructure failure of the AI coding era. It won't be the last. The postmortem is honest about the symptoms — retry loops, scaling failures, VS Code bugs — but it avoids naming the disease. AI coding agents generate traffic at machine scale, and the entire developer infrastructure stack was built for human scale.

Until every layer of the stack — from git hosting to CI to package registries — acknowledges and plans for this, we'll keep seeing outages, vague postmortems, and comments sections full of frustrated developers asking for answers that 622 words can't give them.

The commit graph is exponential. Your scaling strategy needs to be too.