LOOP &
HARNESS
ENGINEERING
An AI agent is only as good as its harness — the constraints, feedback, and context wrapped around the model. As agents take over more of the building, the hard part stops being who writes the code and becomes keeping the whole system aimed at the right strategy. Here is how I think about that, in five short chapters.
The system underneath the speed.
I lead engineering at TimelyCare, where I was the first engineer and built the core of the telehealth platform. Lately I've been changing how we ship — moving the product development lifecycle from human-driven to substantially agent-driven. That shift cut median delivery time — active work to production, ~68 days to ~18; idea to first code, backlog and all, ~230 to ~34 — across 87 initiatives since adoption. And that median is a trailing measure: the gains have been compounding, so it understates where the work lands today.
These chapters are that work, written down. A few people driving from strategy through deploy, with a harness carrying everything in between.
This is distilled from a single practice — mine. I wrote these dense, to think with; this page is the plain-English version. If you want the even-plainer version of what any of it means in practice, that's a conversation I'd enjoy.
— Mark Huebel
The Loop
Most AI setups make work happen faster. Far fewer check whether the work still serves the strategy. The Loop closes that gap: every cycle, a written strategy aims the work, a separate reviewer judges it against that strategy, and what the cycle learns feeds back to sharpen the strategy itself. Each pass leaves the next one better aimed.
For practitioners — the eight stations & the laws
- North Star
- the operational strategy — the anti-goals and tie-break rules an agent can act on, not a vision statement.
- Tint
- project the few rules that bear on this task; aim the work before a line is written.
- Build
- produce the work, already tinted; log net-new decisions as they're made.
- Alignment Lens
- a disinterested judge — never the builder — scores the work against the strategy, every cycle.
- Capture
- record what was decided, what was refused, and why.
- Intent Store
- the memory the loop reads and writes — the running record of what the product actually decided to be.
- Strategy Review
- on a slower clock, a strategist reads the accumulated evidence and proposes amendments to the strategy.
- Human Ratify
- amendments are machine-proposed, human-approved. The gate that stays.
- Three roles, never fused. Generator ≠ verifier ≠ strategist. Fuse any two and the system grades itself an A.
- Two cadences. The lens runs every cycle — fast, cheap, machine. The review runs on its own slower clock. Mix the clocks and the compass spins.
- The gate that stays — and narrows. Delegate execution; never what you're building. The approval gate narrows to exceptions only as trust is earned.
- Coherence → validity → anticipation. Today it checks internal consistency. It earns the right to measure real outcomes, then to anticipate the customer's future, as those stages wire in — and announces its blind spot until they do.
- Truth = completeness. The source of truth lives wherever the decision record is most complete — local for one decider, an aggregator across a team.
Inside a Build
Inside one build cycle, the harness scores the plan before any code exists. The builder logs its decisions as it works. Then a stack of independent reviewers — correctness, tests, instrumentation, experience, and strategy-alignment — each check the work before it ships. Not one rushed "looks good to me."
For practitioners — the stack contract & the laws
- Correctness
- a stranger reads the work for design, simplicity, and the bugs the maker smoothed over.
- Tests
- new behavior carries tests that would fail without the change. Coverage gates the ship.
- Instrumentation
- the bridge to measuring real outcomes — every expected result ships the sensor that will score it.
- Experience
- the built flow is walked as the user, against the brief — not as the author.
- Alignment
- the Loop's lens as one dimension here — scores the work against the strategy, flags a sensorless bet.
- Score the plan before the code. The cheapest deviation is the one caught while it's still a sentence.
- A stack, not a vote. Five disinterested passes, each its own fresh context and finding list. One fused "LGTM" grades nothing.
- Remediate fast, escalate honest. The inner loop is bounded — a deviation that survives N rounds stops ping-ponging and escalates to a human.
- Cycles come in classes. A typo fix isn't an onboarding flow. Light work runs correctness and tests; the full machinery is earned by new behavior. Only capture is unconditional.
- Bring your own tools. The stack is a contract, not a toolchain — mature CI, review, and analytics drop in as implementations.
Scaling to a Portfolio
More than one product doesn't mean a different machine — it means the same loop, stacked. One company-level strategy on top, product-level strategies below, and a simple router that decides where each new idea belongs — including the case that matters most, "fits the mission, but no product yet," which is where the next product comes from.
For practitioners — the recursion & the laws
- Route
- serves the mission and fits a product — the normal case. Send it down that product's loop.
- White Space
- on-mission but housed nowhere. A cluster of these is the loop discovering a new product — or a star drawn too tight.
- Tension
- a product wants it, the mission doesn't. Don't auto-decide: either the product drifted, or it learned something the company hasn't absorbed.
- Decline
- serves neither. Decline cleanly — but record why, and mine the refusals.
- The harness is fractal. org : product :: product : work. The same loop at every altitude — only "the work" changes.
- The product North Star is the membrane. It's the company loop's output and the product loop's fixed point at once.
- White space is generative. Fits nowhere, yet on-mission = a product waiting to exist. The portfolio grows from inside the harness.
- Tension escalates; it doesn't auto-resolve. When a product fights the company, one of them is wrong — the review decides which.
- Route, don't duplicate. One decision belongs to one product's source of truth. The router places it; it doesn't copy it into three.
Betting Beyond the Data
The Loop only refines what the evidence already supports — so it can never reach a market that has no evidence yet. This is the discovery engine: it generates bold bets no data justifies, kills most of them cheaply against a kill test chosen in advance, and lets the survivors earn their way in.
For practitioners — the engine & the laws
- Inventor
- the generator with its discipline removed — it emits hypotheses with no evidence behind them, still aimed by the North Star.
- Hypothesis
- an un-validated bet on a possible future, carrying only a falsifiable claim and the cheapest test that would kill it.
- Probe
- the cheap experiment — a fake door, a manual cohort, a reversible spike — and the threshold set before it runs.
- Convert
- a survivor earns a real citation and rejoins the main flow. Spend fast; commit slow.
- Every hypothesis ships its kill criterion. It dies on a clock, not on enthusiasm — no attachment, no zombie projects.
- Inference proposes, the probe decides. Never bet on being right about the idea; bet a bounded amount on cheaply falsifying it.
- A three-layer floodgate. Role separation, a pre-registered kill test, and a bounded exploration budget — each closes one failure mode.
- Conversion is tiered. A small, reversible survivor converts now; a big or capability-requiring one batches at the slow review, weighed against the portfolio.
- No privileged voice. A founder may inject a bet — but it ships the same kill criterion and faces the same gate. No one grades and ratifies their own invention.
About This Doctrine
A doctrine about keeping work honest has to be honest about itself. The ledger below says which parts are live practice and which are still design intent — and the text changes the way it says a strategy should change: on evidence, never silently.
The coherence loop and the build harness — how I approach AI-native engineering today.
The self-improving, world-measuring stages — measuring real outcomes and anticipating the customer's future. Designed, marked not-yet-wired.
The pattern is the product.
Drop in your own strategy, your own memory, your own signal sources — the loop is the same. If you're working the same problem — building with AI agents at production scale without taking your hands off the wheel — I'd welcome a conversation.