PatchDrift watches every API version, finds the exact call sites in your codebase that break, and delivers verified fix PRs — reviewed by a human, ahead of the deadline.
28 breaking changes in version 2026-10 alone · scanning is free and needs no access · you pay only when a fix passes your CI
- WebhookSubscriptionInput.callbackUrl
+ WebhookSubscriptionInput.uriapp/webhooks.js:178 and 2 more. Everything else on this version: clean.Measured from Shopify's own changelog and schema archives, July 2026. Shopify stopped publishing consolidated release notes after 2025-01 — assembling the impact is now your job. Or ours.
Every API version schema-diffed against the last, every changelog entry parsed. We archive schemas Shopify retires — history you can't fetch anymore.
AST-level scan of your repo maps each change to file and line. No matches, no noise — most versions won't touch you at all.
Deterministic rules for the mechanical bulk; schema-grounded generation for the rest. Model memory is never trusted over the 2026-07 schema.
Build, types, your tests, and contract replay in a sandbox. Behavioral changes — same shape, different runtime — get flagged, never auto-fixed.
A draft PR with per-line explanations, each citing the changelog entry it answers. A human reviews every PR. Merging is your verb.
Anyone can demo an agent that edits code. The hard part is one you'd let near the codebase your revenue runs on. Every limit below is architecture, not policy.
Your repo is cloned for the run and destroyed after it. Nothing is stored, nothing trains a model.
Per-repo installation only. Branch protection and rulesets apply to us like any other actor; fork-based PRs if you prefer.
Run the scanner inside your own CI. We see findings, not source.
The agent cannot touch test files — passing by weakening the test is structurally impossible, not just discouraged.
Each PR states what was verified: build, types, tests, replay. Low-confidence changes arrive as annotated issues, not diffs.
A quarter of Shopify's breaking changes alter runtime behavior without changing shape. Those get flagged with evidence — never silently patched.
Not testimonials — artifacts from our own pipeline runs on real, unmodified open-source apps.
A webhook registration passing callbackUrl. It validates fine today — the schema still accepts it, marked deprecated in favour of uri. Removal is the kind of change that ships in a quarterly release with a one-line changelog entry, so we report it now rather than the week it breaks.
Of six real open-source Shopify apps we scanned, four were pinned to API versions Shopify retired — one from 2020. Retired pins don't error. They silently "fall forward" onto changed contracts.
An inventory-sync package pinned to a retired version, writing stock through an endpoint with no concurrency protection. Two commits — the code fix and the test-fixture update kept separate so each can be reviewed on its own.
Retired version schemas vanish from official endpoints. We archive every version — so when you finally migrate a 2023-era app, the contract it was written against still exists somewhere.
Moving a driver from REST to GraphQL made its HTTP stubs match nothing. The tests didn't fail an assertion — the requests left the test process and hit Shopify for real, returning 401. Migrations void your mocks silently, so we check coverage before and after.
Most quarters, Shopify ships nothing that touches your code. The scorecard is what a quiet quarter looks like — proof we were watching, and where you actually stand.
A Laravel inventory-sync package, before we migrated it.
Contract scores n/a — it had no GraphQL to check. Dimensions that don't apply are dropped from the weighting, never scored zero.
Every call targeted 2024-01. Retired versions don't error — requests fall forward to whatever the oldest supported version happens to be. The app had been running against a contract nobody chose.
Five call sites, none of which show a complete endpoint on any single line — the version was concatenated in from config. This is the shape that survives every grep-based audit.
REST performs a blind absolute write. Two syncs racing each other silently overwrite — the mechanism behind most oversells. GraphQL's replacement takes a compare-and-swap baseline and rejects stale writes.
Every number here came out of the same tools we'd point at your repo, and every deduction carries the changelog entry that justifies it. Check the links — if a finding doesn't hold up, it shouldn't be on your invoice either.
No seats. Watching is free forever — the bill only exists when there was real work to do.
1–10 call sites. Renames, path changes, header bumps.
11–40 call sites, or up to 5 breaking changes in one release.
41–150 call sites, or anything that changes behavior rather than syntax.
Beyond 150 call sites, or migrations that need design decisions. Refusable, by both of us.
A migration becomes billable only when all five are true and on the record: the vendor published a dated breaking change · it touches your code · you approved the quote · the branch went green on your CI · a named human reviewed and signed the PR. Every one of those is a link on your invoice.
For the free scan: read-only, or run it inside your CI so code never leaves. For fix PRs: a per-repo GitHub App install — opening a PR requires branch-push permission, which is exactly why C-02 through C-04 exist. Your branch protection applies to us like anyone else.
Most Shopify apps don't. Verification degrades honestly: build and type gates always run, contract replay substitutes for missing tests, and every PR states exactly which gates it passed. What we never do is claim confidence we didn't earn.
Shopify tells you what's deprecated — per call, with deadlines. It doesn't find the call sites in your code, write the fix, verify it, or open the PR. The .dev Assistant converts snippets; nobody ships you a reviewed diff. That last mile is the entire product.
For one migration, sure — many teams do, and the good ones budget days for review. What you can't get from a chat window: version schemas Shopify no longer serves, a watch on every future version, replay verification, and a fix pattern library refined across many apps. We sell the standing infrastructure, not the one-off prompt.
We can't. Every billable migration has to start from a dated breaking change the vendor published — we cite the changelog entry and you can open it. We can't mint those, Shopify can, roughly four times a year. On top of that: one charge per repo per release no matter how many PRs it takes, zero call sites means zero dollars, and the tier only ever moves down from what we quoted.
It's written as a warranty, and it pays out like one. If a change we were watching reaches your production without us flagging it 30 days ahead, you get that repo's full year of Coverage back and the migration free. We also hold ourselves to Coverage staying under 30% of revenue — if it drifts above that we cut the price, because the moment the standing fee becomes the business we've stopped being paid for outcomes.
The charge is provisional for 14 days after merge. Revert it, or trace a regression to our diff, and it reverses — across a billing period if need be. Before that: no PR reaches you without a human reviewer's name on it, and the agent is structurally barred from editing your tests, so it can never pass a gate by weakening one.