prompt2bot

2026-11-19
by Uri Walevski
Most teams still treat coding agents like a faster pair programmer sitting inside an editor. A human writes a prompt, waits for a diff, inspects it by hand, nudges the model, and repeats.
That interactive loop misses the bigger shift. The real leverage comes from treating software development like a software factory: automated agentic loops built with the same discipline we already use for CI/CD.
In a software factory, a ticket, production alert, or spec enters a pipeline. An
isolated agent checks out the repository, implements the change, runs type
checks, linters, and end-to-end tests, inspects its own git diff, and ships a
pull request or deployment only when every deterministic gate passes. Humans do
not babysit every intermediate command, for the same reason we no longer ask
engineers to manually compile binaries on their laptops before each release.
Traditional software teams spend an extraordinary share of their week in two synchronous bottlenecks: group meetings and manual line-by-line code reviews.
Look at a standard engineering meeting through token economics. In any room or video call, only one person can speak at a time. At roughly 150 words per minute (~200 tokens/min), single-speaker bandwidth has a hard ceiling of ~12k tokens/hour—whether there are two people in the room or twelve.
Total context burn across the participants, however, grows superlinearly as
coordination and context-switching overhead (N × 12k + 0.5k × N²) compounds.
At N = 2, the meeting burns 26k tokens/hour. At N = 7, seven engineers burn
~108.5k tokens/hour—more than 9× the single-speaker bandwidth—with six
people sitting bored waiting for information they could read asynchronously in
two minutes. At N = 12, total burn climbs to 216k tokens/hour.

Manual code review is running into the same wall. Line-by-line human PR review was invented as a social safety net for human inconsistency when automated verification was thin. When agents generate changes at machine speed, human code review becomes the bottleneck—and mostly theater, with tired reviewers rubber-stamping 400-line diffs.
Deterministic CI gates, comprehensive automated tests, static analysis, and dedicated AI PR review workflows catch mechanical regressions far more consistently than seven people in a sync or an overloaded reviewer scanning diffs before lunch.
Once execution moves into autonomous agent loops, Goodhart's Law becomes the central engineering risk: "When a measure becomes a target, it ceases to be a good measure."
Humans game metrics subtly. Autonomous agents game them literally and at high
speed. If the only objective given to an agent is "close the ticket" or "make
the tests pass," it will happily take the shortest path to satisfy that check:
copy-pasting helpers across modules, weakening test assertions, wrapping bugs in
broad try/catch blocks, or inventing over-engineered abstractions.
Left unconstrained, an agent will also burn endless retries and dollars brute-forcing a brittle workaround instead of stepping back to produce a clean, minimal change.
In a software factory, management's job is not assigning tasks or sitting in status meetings. Management's job is finding the right subordinate metrics.
The primary objective tells the factory what to ship. Subordinate metrics constrain how the factory is allowed to achieve it, blocking Goodhart's Law before entropy accumulates:
When you pair a CI/CD-style agent pipeline with an agent budget and the right subordinate metrics, the division of labor changes cleanly.
Agents handle the high-frequency loop—implementing changes, running checks, enforcing health gates, and packaging verified pull requests (whether for feature work or triaging production issues). Humans stop spending hours as bored spectators in seven-person meetings or human linters on pull requests.
Instead, leadership focuses on architecture, product judgment, and continuously refining the subordinate metrics that keep the software factory fast, legible, and honest.
← All posts