Skip to content
Build Wide, Ship Narrow: A New AI-Era Software Delivery Model
R&D Management 18 min read

Build Wide, Ship Narrow: A New AI-Era Software Delivery Model

The article advocates a 'Build Wide, Ship Narrow' workflow where developers first build features broadly using AI assistants, then split the completed work into small, reviewable pull requests, enabling faster iteration, better code review, and incremental deployment while preserving design rigor.

ThinkInAI Community
ThinkInAI Community
ThinkInAI Community

Traditional Workflow vs. New Model

Excellent engineers plan before building. The classic workflow: write an RFC, break it into small issues, build each sequentially, with each issue blocking the next. This locks structure before any code exists, forcing critical architectural decisions when understanding is minimal. It keeps reviews manageable and avoids big-bang merges, but often leads to rework when early guesses prove wrong.

What Changed

Three things have become dramatically cheaper:

Building : AI assistants turn clear problems into runnable code in hours or minutes.

Design : You can interrogate and reshape a design at conversational speed.

Splitting a finished branch : Breaking a week of tangled work into a series of small PRs used to be the most tedious part; now it's a single prompt.

Two things remain expensive:

The judgment-heavy half of code review. Agents handle mechanical checks (style, nits, obvious bugs) for free, but cannot resolve subtle correctness questions or judge whether a change belongs here or whether an interface will cause trouble in six months. Reading code you didn't write is how you truly own it; narrow PRs make that reading possible.

Product validation. Running the thing and deciding if it's the right thing to build is still slow. The difference: you can now get the whole feature running early enough to show people before anyone reads a line of code.

Therefore, stop pre-deciding boundaries to avoid a cost that no longer exists.

Author's Workflow

Interrogate the design repeatedly until real decisions emerge.

Submit a spec before writing code , especially for novel designs.

Build wide , committing savepoints along the way.

Demo and iterate first , before anyone reads code.

Split by the boundaries the code reveals into PRs.

Merge, then clean up : pure deletions go in a final separate PR.

Design Still Comes First

This is not "skip planning, just code." Before touching the editor, the author has a design and starts every feature with an interrogation. He runs grill-me (https://www.aihero.dev/skills-grill-me), a skill that conducts multi-round adversarial questioning until genuine decisions surface. It exposes gaps he didn't know existed, even for small changes.

When design is novel, it becomes a spec document submitted before any implementation. In one project, the first PR was a document describing the feature, how it works, and trust boundaries — merged days before any code existed so the team could object early.

The plan that never gets submitted is the one that pre-slices work into PRs. Decide what to build first; decide how to slice after building.

Build Wide

A crumpled scratch-paper build branch on one side and a clean fan of five pull requests on the other
A crumpled scratch-paper build branch on one side and a clean fan of five pull requests on the other

After design settles, building begins. The author progresses in steps but does not open a PR at each step and wait for review. Everything stays on one branch until it works end-to-end, no matter how many files are touched.

Commits happen, but they are not milestones for others. They are savepoints: an idea proven viable, or a rope to pull back before a risky experiment. A recent refactor produced over a dozen commits across dozens of files in a single day, with operational messages. They are breadcrumbs for the author, not stories for reviewers.

This makes some engineers uncomfortable because git history is supposed to be the record. But this history never becomes the final record. The final PRs are cut fresh from main; the build branch is disposable scratchpaper. Two audiences — author and reviewers — are separated in time, allowing optimization for both.

main

Demo Before Anyone Reads Code

When the work reaches a good state, the author stops to show it — not as a PR or code review, but as a short video in Slack or a preview deployment if clicks are needed. Get feedback on runnable software from the people who will use it before any code review starts.

Today the cheap half is automated, so review becomes expensive. Discovering at review time that you built the wrong thing (confusing UI pattern, endpoint structure mismatching frontend data needs) wastes reviewer and author time. Demos catch these when change is still cheap. If feedback demands rethinking, the author runs grill-me again so iteration isn't just guesswork.

Ship Narrow

One tangled build branch cut into five narrow pull requests, with the deletion PR last
One tangled build branch cut into five narrow pull requests, with the deletion PR last

The build order is only a rough draft for splitting: steps get regrouped and re-sliced. The deletion PR is the clearest example — it exists only at the end, after new paths are in place.

The author runs a prompt:

Split the current work into the smallest set of independently reviewable PRs, each safely mergeable alone and delivering user value where possible. Create a git worktree for each PR, branching from main. Stack only when a genuine dependency exists; otherwise branch from main. Any removal of replaced code goes into a final separate PR. Show me the proposed split before creating anything.

Time varies from minutes to a few rounds of back-and-forth. No manual cherry-picking required.

That refactor split into five PRs: two backend endpoints as siblings from main, two frontend views each stacked on the backend PR providing its data, and a final PR purely deleting the old path. The deletion removed hundreds more lines than the entire feature added. That's what refactoring looks like in this order.

Two rules emerged:

Stack only when a real dependency exists. Frontend view PR depends on its backend endpoint PR, so the branch reflects that. Everything else branches from main. Stacking for convenience creates a rebase chain you'll regret: the moment the bottom PR gets feedback, you feel it.

Cleanup ships last. Old code dies in its own PR after the new path is live. Mixing deletion with creation confuses reviewers, muddies rollback, and buries cleanup in feature noise.

Splitting is also when the author reads his own work. Reviewing diffs PR by PR, each small enough to hold in his head, is the difference between "shipping AI-written code" and "understanding it." He'd rather catch his own issues there.

Practical tip: managing a stack of PRs burns context fast, so delegate splitting to a sub-agent that reports to the main agent. In Cursor, the split-to-prs skill packages this.

split-to-prs

What It Gives, What It Costs

Heavy PRs stay heavy, and should. Backend PRs carry real architectural risk (new data models, new API surfaces, trust boundaries) — exactly where reviewers should spend attention. Frontend PRs consuming those backend capabilities read in minutes. Small, focused PRs flow; large ones stall.

At this scale, agent review loops are faster. At Adapt, they use Adapt itself as a reviewer — an agent with business context from prior work. A PR opens, it comments in minutes, and the round-trip (questions, clarifications, a small fix) resolves in ten minutes. This only works because PRs are small enough to read quickly; a 2000-line PR mixing multiple concerns never gets that treatment from humans.

Incremental merges also make deployments easier to manage. If something breaks, you roll back a focused change, and error tracking points to that change, not a whole merged stack.

Two costs come with it:

Rebasing. When a reviewer asks for a change on a PR that another PR stacks on, every branch above needs a rebase. This doesn't happen often because reviewers usually touch leaf PRs, but when it does, it's painful. Keep the chat session that generated the split: it still holds the split info, so you can re-prompt it to update upper branches instead of doing it manually.

Splitting ≠ shipping. At time of writing, the five PRs from that refactor are all still open. A good split makes each PR easy to review and worth merging on its own. The agent handles the first; the second depends on the author's judgment in deciding what goes in each PR, and the team's judgment in deciding what to merge. The PRs are stuck because the author only achieved the first. Even if all five merge the same day, review benefits and clean rollback targets are kept; what's lost is incremental delivery — nothing reaches users earlier, and deployment lands as a batch.

When to Use It

Good for: Multi-surface features spanning backend and frontend; refactors where the final shape only emerges after building; any work where you'd otherwise guess issue boundaries before building.

Less good for: Migrations and schema changes that must execute sequentially in production — the order is real, so plan it first. Work with an obvious natural split. Features where the first step can never ship alone; if everything must land at once, late splitting only buys incremental review.

Rule of thumb: if you're writing an RFC and guessing how to split it into issues before building anything, that time is better spent building. You'll get a better answer at the end. The author has tested this across several projects and it holds up.

Structural decisions don't disappear. They just become much cheaper to make when the code is already in front of you.

Original Source

Signed-in readers can open the original source through BestHub's protected redirect.

Sign in to view source
Republication Notice

This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactadmin@besthub.devand we will review it promptly.

AI-assisted developmentcode reviewrefactoringsoftware deliverygit worktreeBuild Wide Ship Narrowpull request workflowstacked PRs
Reader feedback

How this landed with the community

Sign in to like

Rate this article

Was this worth your time?

Sign in to rate
Discussion

0 Comments

Thoughtful readers leave field notes, pushback, and hard-won operational detail here.