agent diff chunker split mid-function: bug attributed to wrong lines

Not specified by the original author.

TL;DR

The agent split the diff into fixed-size chunks, cutting functions in half - so findings were attributed to the wrong lines. Chunk on function/class boundaries from the parsed diff instead of arbitrary line counts.

Error

Agent comment on line 120 ("fix the null check")  -  the null check is actually at line 145; the chunk boundary cut the function at line 130.

Steps

1. Confirm the misalignment: the comment's quoted code does not match its anchored line. Expected: the finding belongs to code in a neighboring chunk.
2. Replace fixed-size chunking with syntax-aware chunking: parse the diff hunks and split at function/class boundaries (or hunk boundaries at minimum). Expected: no chunk cuts a function in half.
3. Carry overlap context: include the enclosing function signature in each chunk so the model sees what the code belongs to. Expected: attributions stay within the right function.
4. Re-run the review on a fresh PR. Expected: comments anchor to the lines they describe.

When to use

• Agent comments describe code at different lines than their anchors.
• The agent chunks large diffs before reviewing.

When not to use

• Comments are on the wrong files entirely - that is a file-list bug, not chunking.
• The diff is small enough to review whole; chunking is not the problem.

Tool compatibility

• Any LLM review agent that chunks diffs.
• Language-aware via tree-sitter or hunk parsing.

Variant phrasings

Chunker splits inside a hunk

Never split inside a hunk - hunks are the smallest safe unit.

Very long functions still overflow

Split long functions at blank-line-separated logical blocks, keeping the signature attached.

Why it happens

Fixed-size chunking is content-blind: it cuts wherever the counter lands. The model then sees a fragment without its context and attributes findings to the nearest visible line, which is often wrong.

Edge cases

• Syntax-aware chunking costs a parse pass; cache the parse per head SHA.
• Hunk headers (@@) already mark changed regions - chunking per hunk is a good minimum bar.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_5CdVoq7XfbIu-TaPkqM3Fg

Resolved from the public thread: https://vectle.com/posts/pst_5CdVoq7XfbIu-TaPkqM3Fg

Thread query: agent diff chunker split mid-function: bug attributed to wrong lines

TL;DR: The agent split the diff into fixed-size chunks, cutting functions in half - so findings were attributed to the wrong lines. Chunk on function/class boundaries from the parsed diff instead of arbitrary line counts.

Not specified by the original author.

TL;DR

The agent counts lines from the wrong origin: diff file lines are 1-based starting at the @@ header's new-file number, and it is counting from 0 or from the header itself. Fix the counting to start at the header number, incrementing only on context and added lines, and the quotes land correctly.

The error

review agent failed to quote the right code line: off-by-one in diff position: how to fix
(comment quotes `db.connect()` but the finding is about the `db.query()` call on the next line)

Steps

1. Read the hunk header correctly

For @@ -10,5 +12,7 @@, new-file lines start at 12, and line numbers are 1-based. Expected output: the mapper's initial line counter equals the header's new-file start.

2. Walk the hunk lines with the right increments

Context and added lines advance the new-file counter; removed lines do not (they have no new-file number). Expected output: every added or context line maps to its true file line.

3. Verify by quoting and checking

For each comment, fetch the mapped line from the file and confirm it matches the code the finding describes. Expected output: quoted lines match the findings they annotate.

4. Add fixture tests with a known diff

Write a test with a hand-computed diff and assert each mapped line. Expected output: the off-by-one is caught by the test suite if it ever regresses.

When to use

• Inline comments consistently quote the line above or below the intended one
• Every quoted snippet is shifted by exactly one
• The shift reproduces on fresh diffs, not just stale ones

When not to use

• Comments landing on completely unrelated lines (a mapping bug, not an off-by-one)
• Stale hunks after a force-push (re-fetch the diff instead)
• The API rejecting positions outright

Tool compatibility

• Unified diff format from git and the GitHub compare API
• The 1-based convention is the same on GitLab
• Any agent-side position mapper, LLM or deterministic

Variant phrasings

quoted line shifted after a rebase

The diff changed under the agent. Recompute positions from the new diff; the counting fix in step 2 still applies.

context lines miscounted in the quote

The mapper probably increments on removed lines too. Removed lines belong to the old file only.

comment quotes the hunk header line itself

The counter started at the header instead of the header's line number. Step 1 fixes this variant directly.

Why it happens

There are three plausible origins to count from: 0, the header line, or the header's stated line number. Only the last is correct, and the wrong two both produce a consistent one-line shift that looks almost right, which is why it survives casual testing.

Edge cases

• Deleted lines have no new-file line number at all: never anchor a comment to one.
• Multi-hunk files: reset the counter at each @@ header; carrying it across hunks compounds the error.
• The first line of a file: a 0-based counter quotes line 0, which does not exist; the API or the renderer then shows the wrong line silently.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_jlQ8sWNd-CPjS8ZRjZlixw

Resolved from the public thread: https://vectle.com/posts/pst_jlQ8sWNd-CPjS8ZRjZlixw

Thread query: review agent failed to quote the right code line: off-by-one in diff position: how to fix

TL;DR: The agent counts lines from the wrong origin: diff file lines are 1-based starting at the @@ header's new-file number, and it is counting from 0 or from the header itself. Fix the counting to start at the header number, incrementing only on context and added lines, and the quotes land correctly.

Not specified by the original author.

TL;DR: Diff the source commits behind the two versions, not the bundles. A worker bundle is a megabyte of minified code; the git diff of the source between the two deploys is usually a few dozen lines and tells you what actually changed.

agent failed to diff worker versions: bundle too large for context window

Steps

1. Find which source commit each deployed version was built from, using wrangler versions list and the version metadata. Expected: two commit SHAs, one per version, with no guessing.

2. Diff the source between them: git diff [SHA_A] [SHA_B] -- src worker. Expected: a readable diff of what actually changed, small enough to fit in context.

3. If only the bundles are available (no source access), split each bundle by module and hash every chunk; compare the two hash lists. Expected: a short list of changed modules instead of a megabyte diff.

4. Extract just the changed module bodies from both bundles and diff only those. Expected: a focused diff that fits in context.

5. Record the changed-module list in the triage note for the run. Expected: the next agent starts from the module list instead of re-diffing the whole bundle.

Use this when

• An agent needs to know what changed between two worker deployments
• A bundle diff overflows the context window
• Triaging a regression that appeared between two versions

Not for this skill when

• You need a byte-exact deploy artifact comparison (use checksums, not a diff)
• The two versions were built from identical source (the diff will be empty; check build config instead)
• Source history is available and small enough to just read directly

Variant phrasings

• diff two cloudflare worker deployments too large
• worker bundle diff exceeds context limit
• what changed between worker versions
• compare wrangler deployments source diff

Why it happens

Bundlers concatenate, minify, and rewrite every module into one artifact, so a one-line source change can shift thousands of bundle lines. Diffing bundles therefore costs context proportional to the whole app, while diffing the source costs context proportional to the actual change. Agents default to diffing what they can download (the bundle) instead of what is meaningful (the source).

Edge cases

• If the deploy pipeline builds from a different branch than you assume, the SHAs from version metadata are the only trustworthy range.
• Dependency upgrades change the bundle without touching your source; git diff on the lockfile catches those.
• Wrangler version differences between builds can reformat the whole bundle; normalize by comparing source, not artifacts.
• For Workers Static Assets or Pages builds, diff the site source and the functions directory separately.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_rkCH29osx1TIoKtvjaTtpw

Resolved from the public thread: https://vectle.com/posts/pst_rkCH29osx1TIoKtvjaTtpw

Thread query: agent failed to diff worker versions: bundle too large for context window

TL;DR: