From AI Review to Integration: Splitting a Large Change into Six Pull Requests
Netsujo Inc. ·

An AI review of a change spanning 20 files stopped without a conclusive verdict. The source input used for comparison, including the versions before and after the change, was 1,449,118 bytes. In Netsujo's review setup, the reviewer responsible for a judgment about the whole change had not received the source needed to make that judgment.
We split the change into six pull requests with an explicit dependency order. Each went through formal review. We corrected a defect found during that process and integrated the changes into the source tree. This article explains how we chose the boundaries and handled the dependencies and tests.
1. Identify why the review could not reach a verdict
The change evaluated the scope of files an AI execution could write and connected that evaluation to the execution paths. It involved a shared decision library, runtime registration, work assignment, launch, monitoring and terminal checks. Assessing individual files was insufficient to establish whether the required conditions held across the system.
At the time, our QC pipeline switched to a review divided into multiple windows when source input exceeded 512 KiB, or 524,288 bytes. That number was a mode-selection threshold in our own review pipeline. It was not a general limit on how much source an AI model could read.
The immediate problem was an integration obligation spanning 26 elements that had been assigned to a window without the required source. Knowing the names of related parts and the questions to answer does not establish that the implementation meets those conditions. The reviewer needs the implementation itself.
Stopping the verdict was appropriate. We needed to repair the relationship between the material supplied to the reviewer and the judgment we asked it to make. Stronger wording in the request or guesses about unseen code would not supply the missing source.
That diagnosis made the next action concrete: define change units that deliver the source required for each stage's judgment to the reviewer responsible for that stage.
2. Split the work in dependency order
We placed the shared decision logic first, made it available to the relevant runtime components, and then connected it to the execution path. The table shows source-review input recorded when we prepared the split. It includes both BASE, before the change, and HEAD, after it.
Table. Source-review input recorded when the split was prepared, including BASE and HEAD
| Order | Change under review | Source input (bytes) | Dependency purpose |
|---|---|---|---|
| 1 | Write-scope evaluation library and unit tests | 77,773 | Establish the decision used by later stages |
| 2 | Registration in the runtime bundles | 283,510 | Include the required library in the distributed runtime |
| 3 | Capability checks during work assignment | 285,157 | Determine whether the requested route is available |
| 4 | Dispatcher integration with the evaluator | 250,550 | Connect the decision to the launch path |
| 5 | Launch, monitoring and terminal checks | 369,206 | Cover conditions before and after execution |
| 6 | macOS-specific launcher tests | 318,826 | Check the OS-specific paths |
Source: Netsujo's split-planning records. The original source-review input was 1,449,118 bytes. These figures were recorded when the split was prepared; they are not the full inputs of the final model requests or token counts. Their sum is 1,585,022 bytes, which is larger than the original. Total source input did not decrease. The 512 KiB threshold belongs to our review pipeline's mode selection.
Under that threshold, each part was structured to fit into one ordinary review. The benefit of the split was a unit in which the judgment requested and the source supplied could correspond. Repeating shared context across reviews is compatible with an increase in the aggregate size.
We also keep the planning figures separate from the inputs used for the final reviews. Subsequent fixes changed the source, and the formal review inputs had their own composition. Adding the values in this table as if they were the complete final model inputs would not produce a valid cost or speed comparison.
3. Move tests with the dependencies they require
The first library change included unit tests for its decisions. This established the behavior that later stages would call. The registration stage addressed the source configuration that includes the library in the runtime bundles. Work assignment and dispatch integration followed.
This ordering also narrowed the question for each review. At the library stage: does this input produce the required decision? At the dispatcher stage: is that decision used at the required point? At the launch and monitoring stage: do the checks hold before and after execution and along alternative paths? The stages have narrower responsibilities while retaining the same overall objective.
Tests needed the same treatment. Tests that depended on a later dispatcher integration were moved to the stage introducing that integration and restored there. A test requiring functionality that has not yet been introduced cannot validate an earlier pull request on its own. Leaving the test out permanently would lose coverage that the full change still needs.
To apply this approach, record what each pull request checks, the prerequisites supplied by earlier changes and the tests to restore in a later stage. At integration, reconcile the original change's testing obligations with the stages that now cover them.
The six pull requests in this case had a dependency order. They were not six parallel assignments: later stages used conditions established earlier. Any decision to parallelize part of the work should first account for those dependencies.
4. Correct the defect found after splitting
A review of the launch and monitoring changes found a real defect. On a particular path, a restarted monitor could skip a write-scope check. We corrected the implementation and submitted the revised candidate for formal review.
A monitor's ability to restart and its ability to preserve the required checks after restarting are separate conditions. Verifying the ordinary launch path does not establish that a recovery path preserves the same conditions. The defect in this case was in that connection.
Because of this finding, we cannot describe the outcome as an unchanged patch that passed simply because it was divided. The initial split preserved the change's objective, and the subsequent review led to an implementation correction.
A concrete review unit made it possible to examine launch, monitoring and terminal conditions in the stage responsible for them and identify the problem on that path. That is the observed outcome in this case. It does not establish that splitting will always find defects or guarantee the safety of a whole system.
For another change, a useful planning question is which pull request will examine paths that return to an earlier condition, such as restart, recovery and shutdown. Conditions that cross those paths need an explicit review owner when the implementation is divided.
5. Record the outcome as source integration
Between November 18 and 19, 2026, we merged all six pull requests after formal review of their respective candidates. One review identified a defect in which a restarted monitor could skip a write-scope check on a particular path; we corrected it. The demonstrated outcome here is the source integration of this set of changes.
Passing formal review for each candidate and accepting the behavior on every machine and downstream consumer require separate evidence. Even when a runtime bundle registration has been integrated into source, a host must still adopt that version and exercise the required paths. This article does not claim that fleet-wide acceptance or production acceptance was completed.
We also did not compare total tokens, charges or completion time between the original change and the six pull requests under controlled conditions. The aggregate source-review input in the planning table increased. What this work demonstrated was a way to create reviewable change units, correct a concrete defect and proceed to integration.
6. Define review units before dividing the implementation
When a review stalls, first identify what prevented the judgment. Missing source, ambiguous acceptance criteria and a defect in the implementation call for different actions. When required material is absent, align the input package with the reviewer's responsibility.
The following sequence can make a split plan concrete:
- Write the question for each stage in one sentence. Name the condition being checked, such as a shared decision, its registration for distribution or its actual invocation.
- List the source needed to answer that question. Decide whether changed lines are sufficient or whether callers, callees and unchanged code are also necessary.
- Set the dependency order. Connect each prerequisite supplied by an earlier stage to the place that uses it later.
- Assign the tests. Record which tests can run in each pull request and which must be restored with a later dependency.
- Define the final acceptance scope. Connect source integration, host adoption, execution-path checks and production verification to the evidence each requires.
File counts and byte counts help assess whether that plan can run through your review pipeline. Optimizing only for a smaller patch can separate related implementation details and remove context needed for judgment. Choose a size that keeps the question and its necessary source together.
An AI review workflow needs a joint design for what the model receives and what it is expected to decide. Our six-pull-request case shows one instance of correcting that relationship, fixing the resulting review finding and integrating the changes.
If you want to clarify the boundaries between verification, review and integration in your AI development workflow, discuss your development and review process. Our AI implementation support page describes the scope of our work.