The agentic product operating system

01 · The approach

People decide. Agents build. Cost and checking run under every move.

The loop

What it costs, on two separate bills

Where each check happens, and who does it

1. Checkable without rendering itA linter. Fast, free, and it corrects while you work.
2. Needs product or codebase contextAgent guidance, written as prose with the evidence attached.
3. Sets a new standardA person, reading a written review. That is where the automation stops.

The pit wall

Ten principles the loop rests on

• Cheap production changes the job. Staff for judgment, let agents carry production. Title does not decide who owns the scarce work.
• Write a short brief, then build the thing. What survives from the old specification document is a thin layer of judgment: the problem, the definition of good, and what is off the table.
• The test cases are how you know. Every AI feature carries a set of test cases with a named owner. Enforce it harder than test coverage, because the failure is silent.
• Taste is the edge, so grow it and encode it. "Use verb plus noun for a destructive action" is usable. "Make it clean" is an adjective a model ignores.
• What it costs is a product decision, and it is two separate bills. Meter what you ship. Leave what your team burns building alone through the window where velocity compounds.
• Automate to the moat. Automation allocation is a positioning call. Hold the human line wherever the human interaction is itself the value.
• Measure freely, interpret deliberately. Aggregation and clustering are agent work. Deciding what the numbers mean is where the value sits.
• One good default, one principle set. One strong way to do a thing, one build loop, one set of principles across every function.
• The best move is often subtraction. Removing the layer, the step, the token, and the well-built prototype that is not worth keeping.
• The build is the marketing. You are not manufacturing content, you are exposing momentum.

02 · The build

What you build in ninety days, in the order that matters.

Ninety days

1. Phase 0 · FoundationsOne-command stack, continuous integration under five minutes, legacy migrations codified as lint-backed rules, the brief template and the design rules written down where an agent can read them. What it opens: agents can build without fighting the pipe.
2. Days 0 to 30 · First loopOne workstream through all five moves, with its own test cases and a budget for what it costs to run. Preview deployment on every branch. Principles published, and leaders building in the open. What it opens: the validation gate.
3. Days 30 to 60 · Open the gatesAutomated review on every pull request, risk-based auto-merge, per-feature cost line, production monitoring on model calls, deploy separated from release. What it opens: the review gate.
4. Days 60 to 90 · Steady stateThe loop is how AI work gets built. The test cases are a gate, not a suggestion. Provider changes are treated as incidents. Non-engineers ship. What it opens: the constraint moves to Shape, which is the point.

The context layer

• An owner for every domain, and a full content audit that has actually been verified.
• A locked source of truth, with downstream triggers when anything in it changes.
• Traceability back to the source, so a wrong answer is catchable rather than merely embarrassing.
• Never promote a single screenshot or one reviewer comment into a universal rule. Someone has to sign off that a rule is a standard and not one person's preference.
• A weekly staleness sweep, because context rots quietly and nothing raises an exception when it does.

What triggers what, and where the data goes

• A drop in quality flips the flag. Stop the bleeding first, work out why second. The flag is the off switch, not a code rollback.
• Risk decides the reviewer. Anything touching money, data models, or public interfaces routes to a person. The threshold is the policy.
• Approval and the check are logged separately. An audit needs written criteria and a way to override them, not a person clicking approve.

What never leaves

• Strip personal data out before it reaches a prompt or any stored record, and do it on the way in, not afterwards.
• Secrets never appear in prompts, logs, or chat. Use a secrets manager and short-lived credentials.
• Route model calls through your cloud provider's own gateway to make the cloud the processor and pin the region.
• Run the build cache and the stored records on your own infrastructure where you can, which takes them out of the tier that sees sensitive data at all.

The stack, and how to think about vendors

• A published, versioned subprocessor list with change notification.
• Access logged and least-privilege, with short-lived credentials over long-lived keys.
• Each vendor's own audit reports on file, with a diarized renewal.
• A documented offboarding path that forces deletion.

Where this breaks

• When prototype-first is the wrong order. Prototype-first assumes a rough internal build is safe to ship. On anything that moves money, touches regulated data, or cannot fail even internally, the thin shape leads and the prototype follows. Naming which side you are on is a judgment the tooling will not make for you.
• Vertical products. When your team is not a representative user, using your own product drifts you toward building for yourselves.
• Writing the test cases costs you time up front. Skipping it looks fast for a month, then you cannot tell whether anything works.
• One opinionated loop reduces flexibility. Senior people resist a single default, and that resistance is real rather than stubborn.
• Shape quality is the concentrated risk. Weak shapes scale bad output faster than ever, which makes whoever owns Shape a hiring question, not only a process one.
• Culture is the limiter. This is largely not a technical problem. A team that adopts it after watching it work will keep it. A team that was told to will quietly work around it.

03 · The read

Stop counting what shipped. Count what landed.

Every claim says how much you know

The test you write before you build

1. Define what good meansWritten as something you can score. Whatever you define, the agent chases exactly that and nothing beside it.
2. Build the test set from the ugly cases, on purposeThe tail is in the set by design, because a demo is one happy path and behaviour is a distribution.
3. Set a pass barIt clears the bar or it does not ship. The gate stands before a real person sees it.

What fails, and how it fails

• Agentic features degrade, they do not crash. Uptime stays green while the output quietly gets worse. No exception is ever raised. Track whether the quality scores are slipping, and what each action costs, not just whether the service is up.
• A provider change is your incident. The provider ships a new model and your feature degrades on their schedule, not yours.
• Mitigate before diagnosing. Flip the flag back to the deterministic path first. Reversible in one step is the safety net under the speed.
• Review blamelessly. When the failure came from a probabilistic system there is often no who, only how.
• Throughput is a leading indicator of capacity, never the goal. Widen the pipe and you flood it with confident wrong builds faster.

04 · The ladder

Where you are, and what the next rung looks like.

The composite ladder

Each framework's own ladder

How a score is produced

• Weighting adapts to the stage. An approximate stage is computed first, and that selects the weight table, because what matters at Foundation is not what matters at Compounding.
• Functions interact. Six interaction effects, bounded so no single pairing can dominate, capture the fact that strong design with weak development reads differently from both being weak.
• Coherence is scored separately from the total. It is a weighted blend of function alignment, cross-function balance, interaction rules, and the shape of the profile. A high score with low coherence is a different problem from a low score.
• Anomalies are flagged, not smoothed. Any dimension more than one and a half standard deviations from the profile gets surfaced rather than averaged away.
• The gap between frameworks is itself the output. Under 15 points apart is aligned, 15 to 25 is worth a conversation, over 25 is the finding.