Build Not yet confirmed elsewhere 1 publisher 3 min read Published Aug 30, 2026, 8:52 AM PDT

After five months behind main, classifying 312 conflict hunks helped turn a two-week rebase estimate into 11 hours

The leverage in this rebase sits in routing rather than prompting, and the three regexes that decide which hunks skip the model entirely are tuned to one repository's five months of noise. Copying the method means re-deriving them.

The Engineer · Build desk

Send a correction

Illustration accompanying After five months behind main, classifying 312 conflict hunks helped turn a two-week rebase estimate into 11 hours — Generated illustration

What happened

The branch was a storage-layer rewrite begun in February and kept alive on "we'll land it next sprint", and by July it sat five months and 1,900 commits behind main.
Rebasing it onto main produced 312 conflict hunks across 137 files, including content conflicts in the storage adapter and index and an add/add conflict on an LRU cache file.
A first attempt that simply opened the repo in Claude Code and asked it to resolve the merge conflicts got through about 40 hunks before it went sideways.
A triage script then classified every hunk and split the 312 into 117 mechanical, 171 semantic and 24 human-only, each class routed to a different resolver.
Semantic hunks went to the model ten at a time behind a build-and-test gate, and the whole rebase landed in 11 hours against a two-week budget.

Why it matters

What it limits constraint The gate can only fail a batch that breaks the build or an existing test, so the plausible-but-wrong resolution the author names as the real danger rides straight through it, leaving the human queue and the decision log as the only defence.
What it costs cost Adoption is priced in gate runs rather than tokens: at least 18 build-and-test cycles plus every retry, so a team with a 30-minute pipeline pays in wall clock what this author paid in review attention.
Who has to decide decision Anyone lifting this harness has to re-derive the mechanical patterns against their own repo's churn first, or they will hand hunks with real semantics to a three-line regex list.
What it sets up precedent If a five-month rebase can be done for roughly a seventh of the hand-rolled budget, the cost argument for killing long-lived branches early gets weaker, and more of them get kept alive on the same promise.

Next story · Invest · Sep 22

Bun's million-line Rust port ran $165,000 through Anthropic's API meter

One report1 publisher

The economics of this pipeline are set by one guard inside the classifier. `classify()` calls a hunk mechanical only when every line on both sides is blank or matches one of three regexes ^[15]. Everything else falls through to the model or to the human queue. That default is the right way round: each hunk has to earn its place on the cheap path before it gets there.

The three patterns tell you what repository this was. One matches lines beginning with `import` or `from`, one matches a quoted key followed by a quoted version string, one matches Markdown-style bullets ^[16]. Between them they cover import block collisions, lockfile churn, formatter disagreements and two branches appending to the same list ^[14]. That is 37.5 percent of the hunks routed around the model ^[21]. For that share to transfer, your drift has to be made of the same noise. A repo whose five months of churn is generated clients, resource YAML or renamed fixtures will see the mechanical bucket shrink and the model's share grow, and the second-order cost of that lands on review attention rather than tokens.

Now the gate. A passing batch is committed and recorded in `resolutions.md`; a failing batch is reverted and re-run with the failure output attached ^[13]. Worth being precise about what that buys, because the author's own statement of the danger is a resolution that compiles and passes the tests that happen to exist while shipping a bug that looks like it was always there ^[10]. A green build and a green suite cannot detect that, by construction. What actually stands against picking a side to make the markers go away ^[6] is the human-only queue and the written record. `resolutions.md` is doing the job the chat session failed at: conflict #12 in `adapter.ts` settled the new retry signature, conflict #88 in a caller reintroduced the old one, and nothing in the session tied the two together ^[7].

Batch size sets the clock. 171 semantic hunks at ten per batch is 18 batches at minimum ^[22], so the build-and-test cycle runs at least 18 times before any revert-and-retry loop ^[13]. Against 11 hours of wall clock that averages about 37 minutes per batch for context assembly, model time, gate, review and commit ^[23]. If your gate takes 25 minutes, the arithmetic stops working and the method does not fit.

The piece I would want before copying this is the context bundle. The published excerpt breaks off inside the classifier and never says what goes into one ^[19], and that is exactly where intent is supplied, which the author identifies as the thing the agent was never shown ^[9]. Everything around it is scheduling, and scheduling is the easy half. Two weeks was the hand estimate ^[4]; on a branch kept alive by "we'll land it next sprint" ^[3], estimates had a track record.

What to watch

A released triage script, which would let teams measure their own mechanical share instead of inheriting three regexes tuned to one repo.
Whether resolutions.md holds up as decisions accumulate, or whether cross-file rulings need to be machine-enforced rather than merely recorded.
Whether the human-only bucket stays near 8 percent of hunks on a branch that is not a storage-layer rewrite.

Clarity's read

What the record supports and how the coverage leans. The claims behind it follow.

Reality

Evidence45
Adoption12
Hype gap+20
Incentives55
Confidence52

Why these scores

Claim ledger

Ranked by verification strength, evidence, and original report placement.

[1]
The rebase took 11 hours instead of the two weeks the author had budgeted.
Reported Supported2 sources— create a free account to open them View cited source
[2]
Running `git rebase main` on the branch produced 312 conflict hunks across 137 files, including content conflicts in src/storage/adapter.ts and src/storage/index.ts and an add/add conflict in src/storage/cache/lru.ts; `git diff --name-only --diff-filter=U | wc -l` returned 137.
Reported Supported Source: dev.to write-up by the branch's authorView cited source
[3]
The branch was a storage-layer rewrite started in February and kept alive by "we'll land it next sprint"; by July it was five months and 1,900 commits behind main.
Reported SupportedView cited source
[4]
The author estimated three days of solid work at best and two weeks realistically to resolve the conflicts by hand, plus a meaningful chance of silently breaking something.
Reported SupportedView cited source
[5]
The first attempt was to open the repo in Claude Code and say "resolve the merge conflicts"; the agent resolved about 40 hunks before things went sideways.
Reported SupportedView cited source
[6]
Failure mode one: on genuinely ambiguous hunks the agent took HEAD or theirs to make the markers go away, which was syntactically clean and semantically a silent revert of somebody's bug fix.
Reported SupportedView cited source
[7]
Failure mode two: the agent lost track of decisions across files. Conflict #12 in adapter.ts established that the new retry signature was kept; conflict #88 in a caller reintroduced the old one, and nothing in the session tied those together.
Reported SupportedView cited source
[8]
Failure mode three: context ran out and quality degraded. By hunk 40 the useful details from hunk 5 were gone and resolutions became noticeably more generic.
Reported SupportedView cited source
[9]
The author's framing: a merge conflict is not a text-merging problem but a question about intent, and the intent lives in history the agent was never shown.
Reported SupportedView cited source
[10]
The author states that a merge conflict resolved plausibly but wrongly does not blow up: it compiles, it passes the tests that happen to exist, and it ships a bug that looks like it was always there.
Reported SupportedView cited source
[11]
The triage script bucketed the 312 hunks into 117 mechanical, 171 semantic and 24 human-only.
Reported SupportedView cited source
[12]
Mechanical hunks were auto-resolved by deterministic rules; semantic hunks got a per-conflict context bundle and went to Claude Code in batches of 10; human-only hunks were queued for the author.
Reported SupportedView cited source
[13]
Every batch was gated on a build and test run: on pass the batch was committed and recorded in resolutions.md, on fail the batch was reverted and re-run with the failure output.
Reported SupportedView cited source
[14]
A large share of the conflicts were noise with deterministic answers: import block collisions, lockfile churn, formatter disagreements and two branches appending to the same list; the author considered spending agent tokens and review attention on them waste.
Reported SupportedView cited source
[15]
In triage.py, classify() returns "mechanical" only if every line across both sides of the hunk is blank or matches one of the MECHANICAL patterns.
Reported SupportedView cited source
[16]
The MECHANICAL pattern list contains three regexes: one matching lines starting with import or from (labelled "imports"), one matching a quoted key followed by a quoted version string (labelled "dep-version"), and one matching lines starting with a dash or asterisk bullet (labelled "list-append").
Reported SupportedView cited source
[17]
A comment in the classifier states that a hunk touching control flow or signatures is where silent bugs hide, and the code searches hunk bodies for keywords including if, for, while and return.
Reported SupportedView cited source
[18]
The hunks() helper parses each conflicted file by splitting on the <<<<<<<, ======= and >>>>>>> markers and yields the ours and theirs line lists for each conflict block.
Reported SupportedView cited source
[19]
The published excerpt ends part-way through the classify() function and does not describe the contents of the per-conflict context bundle beyond the flowchart label "Build context bundle per conflict".
Reported SupportedView cited source
[20]
Reading the two-week budget as ten eight-hour days, 11 hours is about one seventh of it.
Derived Supported2 sources— create a free account to open them
[21]
The mechanical bucket is 37.5 percent of all hunks, the semantic bucket 54.8 percent, and the human-only bucket 7.7 percent.
Derived Supported1 source— create a free account to open them
[22]
171 semantic hunks at ten per batch requires at least 18 gated batches.
Derived Supported1 source— create a free account to open them
[23]
Across 18 batches, 11 hours of wall clock averages roughly 37 minutes per batch.
Derived Supported1 source— create a free account to open them

Get this ledger inside ChatGPT. Ask about any of our stories and the answer brings its figure, each claim’s verdict and the sources. Free, no account.

Add to ChatGPT Add to Claude

Sources

1 independent publisher whose own reporting we read for this story.

dev.to
1 article · August 30, 2026
How I Let Claude Code Resolve 312 Merge Conflicts in One Rebase: 5 Lessons

Ask Clarity

Have a question this piece left open? The answer comes from its reporting and claim ledger — nothing else.

Try

Clarity analysis

How the coverage leans and what the record actually supports. Read the methodology

Perspective Coverage

How much of the coverage speaks to builders, operators and investors. It measures emphasis, not whether the story is right.

Builder

The reusable part of this story is not the prompt, it is the router. dev.to's author tried the obvious thing first — point Claude Code at the repository, ask for resolutions — and watched it pick sides on ambiguous hunks, contradict its own decision about a retry signature forty conflicts later, and go generic as context filled. What replaced it is ordinary engineering: a classifier that decides who touches each hunk, git history assembled per conflict, ten-hunk batches, a build-and-test gate. Two cautions for anyone copying it. The three regexes that let 117 hunks skip the model are fitted to five months of one team's import churn and lockfile noise, and the script that assembles the context bundle — the piece doing the actual work — breaks off mid-line in the published post.

Reality

Evidence, adoption, hype gap, incentives and confidence, each read independently from the current record on the scale shown beneath it. How these are measured.

Evidence45: 0100
Specific, checkable arithmetic, one witness
The artifacts are unusually concrete for a post of this kind — real rebase output, a classifier you could paste into a repository tomorrow, named conflict numbers — and the figures close: 117 plus 171 plus 24 is exactly 312, and 171 hunks at ten a batch does land near eighteen gated passes across eleven hours. What no part of it survives is outside scrutiny. There is no repository to inspect, no second run, no test suite to look at, and the context-bundle script cuts off before it finishes.
Adoption12: 0100
One branch, one engineer, one sitting
Everything observed happened inside a single storage-layer rewrite: one successful run and one abandoned attempt at the naive version, both from the same person. Nobody has picked the method up, and the part that does the routing is explicitly local — three regexes tuned to the import collisions, lockfile churn and bullet-list appends of one codebase over five months.
Hype gap+20: −100 understated0 aligned+100 overstated
The baseline flatters the result
Eleven hours is probably true. Two weeks is a number the author invented before starting, and the whole seven-to-one framing hangs on it — as does the omission of however long the 24 hand-resolved conflicts took. Pulling the other way, the post is genuinely more interested in how the agent failed than in how it succeeded, and it keeps the model away from the conflicts where both sides changed a business rule. The headline says Claude Code resolved 312 merge conflicts; the body says a script decided which 117 it was not allowed to see.
Incentives55: 0100
Attention-paid write-up, no disclosed stake
A "5 Lessons" post is paid in readers, and the number in the title is what buys them. No vendor relationship appears anywhere and none is implied — the pressure here is subtler: the same person set the two-week baseline, ran the clock, and chose which figures to publish. The absences fit that pattern. Token spend, hours on the human-only queue, revert counts and any post-landing bug report would all complicate a clean result, and none of them appear.
Confidence52: 0100
Mechanics believable, outcome unverified
We'd bet on the failure modes: conflict #12 keeping a retry signature that conflict #88 quietly undid is too specific to be a rhetorical invention, and the classifier is real code doing what the text says it does. Our hesitation is about everything downstream of that — one voice, a truncated script, no visibility into the test suite the gate depends on, and no way to know whether the merged branch is still correct.

Topics and entities

Follow any of these and your For You feed starts watching them — no settings page required.

Topics

Developer productivity claimsFollow
Context Engineering Follow
Verification gates for generated codeFollow
Merge conflict resolutionFollow
Agentic coding workflows Follow