Ask most AI coding tools to build a feature and you get a pull request. It is a real artifact, often a good one, and it feels like the finish line. It is not. A pull request is a proposal. The feature is not shipped until it has been reviewed, sequenced behind whatever it depends on, merged, deployed, and confirmed to work in production with real traffic. That stretch, from a diff that exists to a feature that works for users, is the last mile, and it is where teams actually spend their week. It is also the part almost every tool leaves entirely to you.
The reason this matters is that the last mile is not a formality you tack on after the "real" work of writing code. For anything that ships to production, the last mile is most of the work, and treating code generation as the hard part is how teams end up with a pile of pull requests and no more shipped features than before.
Generating the diff is the easy 20 percent
The part that demos well, turning intent into a plausible diff, is genuinely the smaller part of delivering a feature. It is bounded, it is fast, and it is the thing models are best at. The demo ends there because ending there is flattering.
Everything after the diff is unbounded and messy. The change has to be understood and trusted by a human reviewer, who has to hold the whole system in mind, not just the diff. It has to be merged in the right order relative to other changes in flight. It has to survive CI, which fails for reasons that have nothing to do with the change. It has to deploy, which touches environments and configuration the agent never saw. And then it has to actually work under production load, where the interesting failures live. None of that is generation, and all of it is required before anyone can say the feature shipped.
Where the last mile actually breaks
The last mile is not one step, it is a series of places a proposal can stall or break, and each one has its own failure mode.
Review. A diff has to be checked by someone accountable, and when an agent produces diffs faster than humans can responsibly review them, the review step becomes the bottleneck for the whole pipeline. Solve it by reviewing less and you have not shipped faster, you have shipped riskier. We treat this in the review bottleneck.
Sequencing. A change often cannot merge until something it depends on has landed, and an agent that ignores that order ships work that breaks on arrival. Order matters as much as content, which is the subject of dependency blindness.
Boundaries. A change that is correct and green inside one repository can break a consumer in another, because nothing verified the whole product at once. That is cross-boundary breakage, and it surfaces precisely at the merge-and-deploy stage the demo skipped.
Definition of done. Underneath all of it is a question the diff cannot answer on its own: is this actually finished? A pull request that compiles is not the same as a feature that meets its criteria, and an agent that treats "the code exists" as "the work is done" will hand you proposals dressed up as completions. Separating genuinely done from merely written, and from blocked, is covered in not everything that fails is a failure: blocked vs wrong.
Why a pile of PRs is not progress
There is a seductive metric trap in last-mile-blind tooling: it makes you feel productive by the wrong measure. Ten pull requests generated in an afternoon looks like a great afternoon. But if those ten PRs now sit in a review queue no human has time to clear, waiting on merge orders nobody has worked out, the tool did not create ten shipped features. It created ten units of unfinished work and handed the hard part back to you, relabeled as a backlog.
This is why "the agent wrote the code" is such a misleading claim of value. The code was never the constraint. The constraint was everything the code had to survive to become a working feature, and a tool that generates diffs while ignoring that constraint has optimized the part that was already easy.
What closing the last mile requires
Closing the last mile means treating delivery, not generation, as the job. The change has to move through review, sequencing, merge, deploy, and verification as a coherent process, with the handoffs between steps made explicit rather than left implicit. Handoffs are where work falls on the floor, and designing them deliberately is what keeps a proposal moving toward production instead of stalling. We cover that in designing agent handoffs and contracts.
It also means keeping a human exactly where the stakes justify one, because closing the last mile is not the same as removing people from it. The decisions that carry accountability, what enters the product and what goes to production, stay human by design. Closing the last mile is about automating the mechanical stretch around those decisions so a person's attention lands where it matters, not about automating the person away.
The honest limitation
Owning the last mile does not make delivery frictionless. Review still takes human time. Deploys still fail for environmental reasons no tool fully controls. Production still surprises you, because production is where the untested cases live. A tool can carry a change further down the last mile, but it cannot make the last mile disappear, and any tool that claims it can has quietly redefined "shipped" to mean "a PR exists."
There is also a real risk in automating the last mile carelessly: a pipeline that moves changes to production smoothly and without judgment ships bad changes smoothly too. Speed through the last mile is only a gain if the gates that matter are still real, which is why the human decisions have to stay human.
Where this leaves you
A pull request is a proposal, not a shipped feature, and the distance between them is the last mile: review, sequencing, merge, deploy, and verification, the part that is most of the work and the part most tools skip. Measuring your agent by diffs generated instead of features shipped is measuring the easy 20 percent and ignoring the hard 80.
This is the gap Loopsfinity was built to own: not stopping at a suggestion or a PR, but carrying a feature from a PRD through to merged, deployed, working software, with human judgment preserved at the decisions that carry accountability. The sequencing version of this problem is in dependency blindness, the cross-repo version in cross-boundary breakage, and the full failure map in why AI coding agents fail in production.