I Built a Tool That Auto-Fixes Downstream Code When You Change an API

You change a field in your proto file. You push it. Then you spend the next two days pinging 4 teams on Slack asking them to update their consumers.

Sound familiar?

I built Ripple to eliminate that entire workflow. Push a breaking API change → fix PRs appear in every consumer repo. In 15 seconds. No manual coordination.

The Problem Nobody Talks About

There are great tools for detecting API breaking changes:

• 
  buf catches proto incompatibilities


• 
  oasdiff diffs OpenAPI specs


• 
  GraphQL Inspector flags schema changes

But detection is only step 1. The real pain is propagation:

1. You know user.proto removed phone_number
   


2. But WHO uses phone_number? Which repos? Which files?


3. And what's the correct fix in each consumer?

That coordination — finding consumers, understanding their usage, writing the fix, opening PRs — takes 2-3 days per breaking change at most orgs I've observed.

What Ripple Does

You push: removed `phone_number` from user.proto



Ripple:

  ✅ Detects: field 3 removed (breaking)

  ✅ Finds: python-sdk/client.py, node-api/handlers/user.ts, java-gateway/UserService.java

  ✅ Generates: correct fix for each file (removes the dead field reference)

  ✅ Opens: 3 PRs with explanation of what changed and why



Time: ~15 seconds

How It Works Under the Hood

1. Diff Engines (one per contract type)

Ripple has custom parsers for 10 contract types:

• OpenAPI / Swagger


• Protobuf / gRPC


• GraphQL


• Database (SQL + Prisma)


• AsyncAPI (Kafka, SNS, MQTT)


• Avro (Confluent Schema Registry)


• tRPC (TypeScript)


• Thrift (Apache)


• JSON Schema


• Smithy (AWS)

Each engine understands the semantics of its format. Removing an optional field is fine. Removing a required field is breaking. Changing a type is breaking. Adding a required field without a default is breaking.

2. Consumer Finding (the hard part)

This is where most tools stop. Finding consumers is genuinely difficult because:

• Consumers might be in different repos


• They might reference the spec indirectly (through generated code)


• Naming conventions vary wildly between codebases

Ripple uses an ensemble approach combining 5 strategies:

# Simplified version of the ensemble

consumers = set()

consumers |= grep_for_field_name(removed_field)        # Basic but fast

consumers |= check_import_graph(spec_file)              # Who imports this?

consumers |= query_git_history(spec_file)               # Who changed when this changed?

consumers |= check_playbooks(org_config)                # Custom rules

consumers |= multi_invoker_detection(spec_file)         # Same spec, multiple callers

The git history approach is the most interesting — if user.proto and python-sdk/client.py always change together in commits, they're probably coupled. This is based on research from PropBench, a benchmark I built for measuring engineering judgment in change propagation (268 real scenarios, 1,223 consequence files analyzed).

3. Fix Generation

For each consumer file, Ripple generates the fix using:

1. 
   Template-based fixes for common patterns (field removal → remove reference)


2. 
   LLM-powered fixes for complex cases (Claude generates the correct code)


3. 
   Validation — the fix must pass basic syntax checks before opening a PR

4. PR/MR Creation

Opens a pull request (GitHub), merge request (GitLab), or PR (Bitbucket) with:

• Clear title: "fix: Remove phone_number reference (field removed in user.proto)"


• Explanation of what changed upstream


• The minimal diff to fix the consumer


• Link back to the original commit

Installation (One Click)

GitHub:

Free. Open source. Looking for 10 teams to try it and give feedback.

If you've ever spent a day fixing downstream code after an API change, I'd love to hear about your workflow. What contract types do you use? How do you find consumers today? How long does propagation take at your org?

Built in ~6 days as a side project. Currently a solo founder applying to YC. If this resonates, star the repo or install the app — it helps more than you'd think.