A one-person orchestra, and the merges nobody does anymore

A cost that multiplies with every feature

The architecture is deliberate. Each feature lives on its own branch and the deployable artifact is their union, which keeps diffs against upstream clean, lets any feature be reviewed or removed independently, and allows different combinations to be offered to different users. The price is paid at every upstream release: the change has to be merged across a whole graph of branches, and the effort grows with the number of features.

Left to humans, that cost eventually forces the architecture to degrade. Teams squash the fork, lose the independence of each feature, and take on a permanently harder review problem instead. The interesting question was whether the merge work could be automated well enough that the good architecture stays affordable.

One engineer, owning the whole cycle

This was built by a single Forward Deployed Engineer working as a one-person orchestra: framing the problem, designing the mechanism, specifying it, and implementing it, with the Silicon Software Engineer writing code throughout. No analyst, no separate implementation team, no QA hand-off.

Theorem 2 of AI-First Theory says that full-lifecycle command plus delegation skill plus AI tools produces exactly this, and that no new skills are required to get there. This engagement is that claim running in production. On the delivery estimates, the shape is worth roughly 10× the volume of work for the same budget and about 5× faster delivery, at held quality.

Scripts decide, the agent resolves, humans arbitrate

The division of labor is the whole design. A deterministic script engine plans the entire sweep: what merges where, in what order, and whether the result is acceptable. The AI agent is invoked for exactly one job, resolving a conflict handed to it in a sandboxed worktree. It cannot choose its own work, cannot push, and cannot open pull requests.

• Conflicts are classified, not merely detected. Trivial and mechanical cases merge automatically. The judgment calls the agent is allowed to resolve are written policy, as is the always-escalate list, which covers anything touching security semantics.
• Every resolution is verified before it lands. Type-checks and tests must pass, and then an independent AI reviewer does a cold read of the resolution. Repeated rejection escalates to a human automatically.
• The human sees only what needs a human. Escalations arrive as focused pull requests stating the exact decision required. A quiet sweep reports a single line.
• Deployment is not the agent's to touch. It runs through a separate, non-agentic pipeline with health-check auto-rollback. Propose, approve, and apply are three different authorities.

Capability for the agent, authority for the human

The same stance that governs a RACE Programming delivery governs this pipeline. The agent executes and a person owns acceptance. Work reaches the agent as a specification narrow enough to act on without reinterpretation, which is what an Executable User Story does for a Pit Crew and what a single scoped conflict does here. Nothing lands without clearing gates, the same reason a four-gate Definition of Done stands in front of a Pit Stop. And the escalation policy is a written artifact rather than habit, settled against a corpus of past decisions, so a rejected resolution is treated as a defect in the policy to be fixed, not a coin toss to be retried.

Seven merges in eight, untouched

The sweep runs on a schedule, unprompted. Across roughly two dozen composable feature branches, a single upstream sync can imply thousands of individual merge decisions, and on measured samples about seven out of eight merges complete with no human involvement. A typical escalation concerns one file. The automation itself is a substantial, tested codebase rather than a script, which is what makes it trustworthy enough to leave running.

The architectural payoff matters as much as the saved hours: because the sweep is affordable, the branch-per-feature model survives, and every feature stays independently reviewable and removable.