Good engineers scheme earlier they build. The workflow I grew up seeing: constitute an RFC describing the feature, divided it into smaller issues, past build them, each rumor often blocking the next. The building of the activity was locked successful earlier a azygous statement of codification existed.
This is reasonable. It keeps codification reviews manageable and avoids big-bang merges. It besides asks you to make your astir captious structural decisions astatine the infinitesimal you cognize the slightest astir the problem.
Before you've built anything, you're guessing: which pieces are separable, really analyzable each 1 will be, whether measurement 3 will unit you to rethink measurement 1. Sometimes you're right. Often you're not, and measurement 1 gets thrown away. You learned thing building it, but you'd person learned it faster by building the full point first.
We paid that costs for a bully reason: the replacement was building everything and untangling it by hand, and untangling a week of activity is harder than readying ahead. Deciding boundaries up beforehand was ne'er astir making the build easier. It was astir making reappraisal possible, and it was the only affordable measurement to get there. That's the portion that changed.
What changed
Three things sewage dramatically cheaper. Building: an AI adjunct turns a clear problem into moving codification successful hours, sometimes minutes. Design: you tin interrogate a scheme and reshape it astatine speech speed. And the 1 that matters astir here, decomposing a vanished branch: splitting a week of tangled activity into a series of mini PRs utilized to beryllium the astir tedious portion of the job, which is precisely why we avoided it. It's now a prompt.
Two things didn't get cheaper. The first is the judgement half of codification review. Agents made the mechanical half (consistency, nits, evident bugs) astir free, but they don't settee subtle correctness aliases the questions astir it: does this alteration beryllium wherever it is, will this endpoint style wounded six months from now. A bot approving your PR isn't the aforesaid arsenic you knowing the code, and if you didn't type the code, reference it is really you travel to ain it. Narrow PRs make that reference possible.
The 2nd is merchandise validation. Running the point and deciding it's the correct point to build is still slow. What's caller is having the full characteristic moving early capable to show personification earlier anyone sounds a statement of it.
So extremity pre-deciding boundaries to dodge a costs that nary longer exists.
My workflow now looks for illustration this:
- Grill the plan until it has existent decisions successful it
- Commit the spec earlier immoderate code, erstwhile the creation is novel
- Build wide, committing prevention points arsenic you go
- Demo and iterate earlier anyone sounds the code
- Split into PRs on the boundaries the codification revealed
- Merge, cleanup last: axenic deletion successful its ain last PR
Design still goes first
To beryllium clear: this isn't "skip readying and commencement coding." Before I touch the editor, I person a plan, and each characteristic starts pinch an interrogation. I tally grill-me, a accomplishment that interviews you astir your thought successful adversarial rounds until it has existent decisions successful it. What's the fallback if the API telephone fails? I tally it connected everything, including mini changes, and it keeps surfacing gaps I didn't cognize were there.
When the creation is novel, the scheme becomes a spec committed earlier immoderate code. On a different project, the first PR was a document: what the characteristic was, really it would work, wherever the spot boundaries sat. It merged days earlier immoderate implementation existed, truthful the squad could push backmost first.
What ne'er gets committed is simply a decomposition into PRs. Decide what to build earlier you build it; determine really to portion it after.
Build wide
Once the creation is settled, I build. I often activity successful steps, but I don't extremity astatine each 1 to unfastened a PR and hold for review. Everything stays connected 1 branch until it useful extremity to end, crossed immoderate files are successful the way.
Commits happen, but they aren't milestones for anyone else. They're prevention points: a conception is proven, aliases I'm astir to effort thing risky and want a statement to propulsion backmost to. A refactor I vanished precocious ran to a dozen-plus commits successful a azygous time crossed dozens of files, pinch operational messages. Waypoints truthful I tin spot wherever I've been, not a communicative for a reviewer.
This is the portion that makes immoderate engineers uncomfortable, and I understand why: git history is expected to beryllium the record. But this history ne'er becomes the record. The PRs astatine the extremity are trim caller disconnected main, and the build branch is scratch insubstantial you propulsion away. Two audiences separated successful time, maine and the reviewers, and keeping them isolated lets you optimize for both.
Demo earlier anyone sounds the code
Once the activity is successful a bully place, I extremity and show it. Not arsenic a PR aliases a codification review, but a short video successful Slack, aliases a preview deployment if the alteration needs clicking. Feedback connected moving package from the group who will usage it, earlier a azygous codification reappraisal starts.
Review is costly now that the inexpensive half is automated. Finding retired astatine reappraisal clip that you built the incorrect point (confusing UI pattern, an endpoint style that doesn't fresh really the frontend uses the data) burns a reviewer's clip and your own. A demo catches it while changes are cheap. If it surfaces thing that needs rethinking, I tally grill-me connected the feedback first, truthful the loop isn't conscionable vibes.
Ship narrow
The build bid is only a unsmooth draught of the split: the steps get regrouped and re-cut. The deletion PR is the clearest example, a portion that only exists astatine the end, erstwhile the caller way is successful place.
I tally 1 prompt:
Split the existent activity into the smallest group of independently reviewable PRs, each safe to merge connected its own, and each delivering worth to the personification whenever the activity allows. Create a git worktree and branch disconnected main for each. Stack only wherever a dependency is real; different branch from main. Any removal of the codification being replaced goes successful its ain last PR. Show maine the projected divided earlier creating anything.
How agelong it takes depends connected really tangled the activity is, from a fewer minutes to a fewer rounds of back-and-forth. Either way, nary manual cherry-picking.
That refactor came retired arsenic 5 PRs: 2 backend endpoints arsenic siblings disconnected main, 2 frontend views each sitting connected apical of the backend PR whose information it needs, and a last PR that was axenic deletion of the aged path. The deletion removed respective 100 much lines than the full characteristic added. That's the style of a refactor done successful this order.
Two rules I've arrived astatine by doing this repeatedly:
Stack only erstwhile the dependency is real. A frontend position PR depends connected its backend endpoint PR, and the branch reflects that. Everything other comes from main. Stacking for convenience creates a rebase concatenation you'll regret the infinitesimal the bottommost PR gets feedback.
Cleanup ships last. The aged codification dies successful its ain PR, aft the caller way is live. Mixing deletion pinch creation confuses reviewers, makes rollback ambiguous, and buries the cleanup successful the sound of the feature.
The divided is besides erstwhile I publication my ain work. Going done the diff PR by PR, astatine a size I tin clasp successful my head, is the quality betwixt having shipped AI-written codification and knowing it. I'd alternatively find my ain problems there.
One applicable note: managing a stack burns discourse fast, truthful manus the divided activity to subagents that study backmost to a main agent. In Cursor, the split-to-prs accomplishment packages this.
What it bought, what it costs
The dense PRs enactment heavy, and they should. The backend ones carried the existent architectural consequence (new information models, caller API surface, spot boundaries), which is wherever reviewers should walk their attention. The frontend PRs that devour them publication successful minutes. Small, focused PRs flow. Large ones sit.
The supplier reappraisal loop is faster astatine this standard too. At Adapt, we usage Adapt itself arsenic a reviewer, an supplier pinch business discourse from erstwhile work. It comments wrong minutes of a PR opening, and the speech (questions, clarifications, a mini fix) resolves successful nether ten. That only useful erstwhile a PR is mini capable to publication quickly; a 2,000-line PR mixing respective concerns doesn't get that curen from a quality astatine all.
Merging incrementally besides makes deployments easier to manage. If thing breaks, you revert 1 focused change, and your correction search points astatine that alteration alternatively of an full merged stack.
Those are the gains. Two costs travel pinch them.
Rebasing. When a reviewer asks for a alteration connected a PR that different sits on, each branch supra it needs rebasing. It doesn't hap often, since reviewers usually touch leafage PRs, but erstwhile it does you consciousness it. Keep the chat convention that produced the divided open: it still holds the split, truthful you tin re-prompt it to update the branches supra alternatively of doing it by hand.
Splitting is not shipping. As I constitute this, each 5 PRs from that refactor are still open. A bully divided makes each PR easy to reappraisal and worthy merging connected its own. An supplier does the first for me; the 2nd is my telephone erstwhile I determine what goes successful each PR, and my team's erstwhile they determine what to merge. Mine sat because I only did the first. Even if each 5 merge connected the aforesaid time I support the reappraisal use and a cleanable revert target per change; what I suffer is incremental delivery, since thing reached a personification earlier and the deploys onshore arsenic 1 batch.
When to scope for it
Good fit: multi-surface features crossing backend and frontend, refactors wherever you don't cognize the last style until you've done it, immoderate activity wherever you'd different beryllium guessing astatine rumor boundaries.
Harder fit: migrations and schema changes that must beryllium sequenced successful production, wherever the ordering is existent and you should scheme it first. Work that has 1 evident spot to cut. Features wherever measurement 1 cannot vessel alone, ever; if everything lands astatine once, precocious decomposition buys you incremental reappraisal and thing more.
The heuristic: if you're penning an RFC and guessing astatine really to break it into issues earlier you've built anything, that clip is astir apt amended spent building. You'll person amended answers astatine the end. I've been testing this crossed a fewer projects and it has held up.
The structural determination doesn't spell away. It conscionable gets overmuch cheaper erstwhile you make it pinch the codification already successful beforehand of you.
English (US) · 
Indonesian (ID) ·