The Daily Read·Y Combinator | July 27, 2026

Y Combinator · Startup Ideas

Self-Maintaining APIs

API communication is broken — breaking changes go unnoticed, changelogs don't get read, and 30% of AWS downtime traced to unnoticed external API changes. Agentic coding tools now make a better model possible.

thumbnail
8.9K
Views
306
Likes
28
Comments
1:15
Runtime

Tap any timestamp pill in the essay to jump the player to that moment.

API communication is broken — and it's been costing developers for years

The speaker opens with a confession of scale: over the past year, they worked at more than fifty API vendors — mostly early-stage startups — and found the same pattern everywhere. Breaking changes ship with little warning. New features quietly launch and go unnoticed. Changelogs don't get read. The failure mode is not unusual; it is the industry default.

Over 30% of AWS service downtime traced to unnoticed external API and package changes
0:00 – 0:22
Over the past year, I've worked at over 50 API vendors, mostly early stage startups, and just one pattern is consistent. API communication is broken. Breaking changes ship with little warning. Useful features quietly launch and go unnoticed. Changelogs don't get read. Heck, this is a problem even when I worked at AWS. Over 30% of a service downtime was due to external APIs and package changes going unnoticed.

The numbers get harder to ignore when the speaker invokes their time at AWS. At one of the most operationally sophisticated engineering organisations on the planet, over 30% of service downtime traced back to a single cause: external API and package changes that nobody caught in time. This is not a startup-scale problem. It is a structural one.

The friction made sense, once. Before autonomous tools, the only mechanism an API provider had to notify customers was documentation — a changelog, a blog post, an email that might reach the right person weeks after the change was already live. Passive communication was the only kind available. It just never really worked.

Instead of announcing changes, API providers should apply them

The argument pivots on timing. Two years ago, giving an external tool read/write access to your codebase was a thought experiment nobody was seriously having. Today it is standard practice. Agentic coding tools — Claude Code, Devin, Cursor — have already cleared the hardest adoption hurdle: developer trust. Enterprises are handing codebase access to external agents every day, provided the value justifies it.

Two years ago, codebase access for external tools was unthinkable. Now it's standard practice.
0:22 – 0:46
This friction made sense before agentic coding tools existed. However, now it doesn't. Agentic coding tools like Claude Code, Devin, Cursor, etc. prove that developers and enterprises are willing to give codebase access to external tools, provided they're valuable. Two years ago, this was unthinkable, but now it's just standard practice. The infrastructure for automated code changes exists. What's missing is the application layer connecting API providers to their customers' codebases.

The infrastructure for automated code changes already exists. What is missing, the video argues, is the application layer that connects an API provider's release process to the codebases of everyone who depends on it. The gap is not technical — it is a product one.

The proposed model inverts the update flow entirely. Instead of Stripe writing a blog post about a breaking change and hoping engineers eventually read it, a Stripe agent scans every customer codebase that uses the affected endpoint, identifies the exact lines of code that need to change, and opens a pull request with the migration already applied. The developer reviews and merges. The breaking change never breaks anything in production.

When Stripe ships a breaking change, an agent should scan codebases and automatically open a PR with the fix.
0:47 – 1:09
API providers shouldn't just announce changes, they should apply them. For example, when Stripe ships a breaking change or a new feature, an agent should just scan customer codebases, identify affected usages, and automatically open a PR with the fix. This could work as per-provider agents — for example, installing Stripe's update agent — or as a neutral third-party service tracking changes across vendors. Think like Dependabot, but for APIs.

Two delivery shapes are viable. The first is per-provider: Stripe ships its own update agent, customers install it, and it handles Stripe-specific migrations autonomously. The second is a neutral aggregator — a single service that tracks changes across many API vendors and opens the right PRs when changes land. The video names that second shape plainly: Dependabot, but for APIs.

The quick version

  • Changelogs are passive, and passive communication fails at scale. A pattern visible across 50 API vendors — confirmed inside AWS, where it drove 30% of service downtime — is not an edge case.
  • Agentic coding tools have already solved the hardest problem: developer trust in giving codebase access to an external tool. That trust is now the foundation everything else builds on.
  • The missing piece is the application layer: something that connects provider release pipelines to customer codebases and applies changes rather than merely announcing them.
  • Two shapes are viable — per-provider agents (opt-in, provider-specific) or a neutral aggregator (Dependabot for APIs). Either could be a company.
API providers shouldn't just announce changes — they should apply them.— Y Combinator, Self-Maintaining APIs

The changelog was the right answer for its time. Agentic coding tools just made it obsolete.

1 / 5