AI ProgramsRetreatBlogAboutCareersBook a Conversation
Workflows/Innovation

How We Think About Speed

When the product feels slow, we do not guess. We measure to find the real bottleneck, fan the review out across independent reviewers, adversarially verify every finding, ship the fixes as small reversible pull requests, and measure again to prove the win. A human sets the target and owns the risk. AI does the reading, the finding, and the verifying.

Rule Measure firstReview Human + AIEvery fix Verified twice

Speed work goes wrong before it starts

Performance is the easiest thing to work on and the easiest to work on badly:

"Slow" is a feeling, not a number, so teams optimize the part that feels obvious instead of the part actually costing time.
The database gets blamed first. Usually the real cost is redundant network round-trips and oversized payloads.
Plausible-sounding fixes ship without proof, then quietly do nothing, or make it worse.
A big rewrite trades a slow system that works for a fast one that does not.

From a hunch to a proven win

01Something feels slow
Notice
Operator
02Find the bottleneck
Measure
Claude
03Dimension by dimension
Review
Claude
04Try to break each finding
Refute
Claude
05Scope and risk
Decide
Operator
06Typed, built, deployed
Ship
CI + deploy
07Before and after
Prove
Operator
The loop runs again the next time a number moves the wrong way.

How each step works

01
Notice the slownessOperatorA human observation

It starts with a person, not an alert: a page feels slower than it should, or a number moved the wrong way. We write the hunch down as a plain question, like why the admin feels slow, and resist naming a cause before we have measured one.

02
Measure before touching anythingClaudeFind the real bottleneck

Before a line of code changes, Claude establishes where the time actually goes. On our own admin that meant pulling live database row counts and indexes: every table was under a thousand rows, so the database was answering in microseconds. The real cost was elsewhere, in redundant round-trips and oversized payloads. Measuring first is what stops you from indexing a table that was never slow.

03
Fan the review out by dimensionClaudeIndependent reviewers

The review splits into independent lenses: over-fetching, request waterfalls, caching, client bundle weight, database indexes, and repeated queries. Each reviewer sees only its own lens, so nothing hides in the gap between two people's assumptions. Every finding cites the exact file, line, and the offending code.

04
Try to break each findingClaudeAdversarial verification

Every finding is handed to a skeptic whose job is to refute it. Is the code really doing what the finding claims? Does it run on a hot path, or is it cold code that rarely executes? Would the fix change behavior or weaken a guarantee? Only findings that survive earn a fix. Plausible-but-wrong is the most expensive kind of wrong, and this is where it dies.

05
A human sets scope and owns the riskOperatorThe decision

A person decides which fixes ship now, which wait, and which touch something sensitive enough to need a careful review of its own. On our admin, the change to the authentication path was pulled into its own reviewable unit precisely so a human could weigh the tradeoff before it shipped. AI proposes, a person decides.

06
Ship small, verified, reversible changesCI + deployTyped, built, deployed

Fixes ship as small pull requests grouped by theme, not piled into one. Each is type-checked and built before it can merge, and each is reversible on its own. Small and verified keeps a fast system a working system. Big-bang rewrites are how you trade a slow product for a broken one.

07
Prove the win with numbersOperatorBefore and after

Then we measure again, and the numbers have to move. Round-trips per page, bundle size, time to first byte, before and after, side by side. On this admin the authentication round-trips per request dropped from three to one, the busiest page shed almost a third of its startup code, and the dashboard stopped waiting on an outside service to draw. A change that cannot show its before and after did not improve anything.

The seven elements

Every workflow we document has the same anatomy: seven elements, each assigned to a human, a machine, or both. This is the Centaur Map from our workflow design method.

01 TriggerHuman

A person notices the product feels slow, or a tracked metric moves the wrong way. The hunch is the start, not an automated alarm.

02 InputsMachine

The codebase, the live database including row counts and indexes, and real user-path measurements. We read the system as it runs, not as we remember it.

03 DecisionBoth

Measure before optimizing: is the cost the database, the round-trips, or the bytes? Machines surface the evidence, a human sets the target and owns the risk.

04 RoutingMachine

Findings fan out to independent reviewers, one per dimension, and each finding is adversarially verified before it earns a fix.

05 OutputMachine

A ranked action list: root cause in plain terms, the fix, the effort, and the exact files to touch. Nothing speculative.

06 DeliveryBoth

Small, themed pull requests, each type-checked and built. A human reviews the risk and merges.

07 MeasurementBoth

Before-and-after numbers on the metric that mattered. Machines produce them, a person decides whether the win is real. If it is not measured, it did not improve.

The standing rules

  • Measure before you optimize, and again after to prove it
  • The database is innocent until the row counts say otherwise
  • No finding ships without surviving an adversarial second look
  • Change only what traces to the goal, no speculative rewrites
  • Anything sensitive gets its own reviewable change

Why it works

  • Effort lands on the real bottleneck, not the one that feels obvious
  • Round-trips and bytes are where the milliseconds hide, so that is where the work goes
  • Adversarial verification kills plausible-but-wrong fixes before they cost anyone
  • Small, reversible changes keep a fast system a working one
  • Every win comes with a number, so nobody takes "it feels faster" on faith