prompt2bot logoprompt2bot
Software Factories and Subordinate Metrics

Software Factories and Subordinate Metrics

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.

Why 7-person meetings and manual code reviews are dying

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.

Meeting Token Economics: Single-Speaker Bandwidth vs. Total Context Burn

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.

Goodhart's Law hits agents harder

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.

Management's job: finding the right subordinate metrics

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:

  • Lines of code (LOC) discipline: Good generalizations shrink a codebase; sloppy agent output bloats it. Tracking net lines of code—and penalizing unnecessary growth or duplicated logic—pushes agents to reuse existing primitives and delete dead paths instead of piling on new layers.
  • Code health: Strict type checking, linting, duplication checks, and automated tests weighted by failure probability and cost. Every loop must leave code health equal or better, enforced mechanically by CI rather than by subjective opinion.
  • An explicit agent budget: A hard cap on tokens, cost, or iterations per task. An agent budget turns infinite brute-force thrashing into a clear stop signal. If an agent cannot solve a task within budget while keeping LOC and code health intact, that points directly to an unclear spec or structural complexity that humans should simplify.

Building the automated loop

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.

Ready to build?

Turn a plain-language prompt into a live AI agent in under a minute

Deploy on WhatsApp, Telegram, email, or your website with a cloud VM, browser automation, and pre-built skills. Start with a 7-day free trial (up to 500 LLM runs, no credit card required).

Want to share prompt2bot with your audience or clients? Earn 20% recurring monthly commission →

← All posts