Your agents will happily build the wrong thing. And keep going.
The further they get, the harder it is to turn back. onMain checks the idea before anything is built, and the results after release, so product and engineering are always on the same page.
Free for one product and one person.
Fast.Wrong.Shipped.
That's agent speed with nothing checking the idea. Building the wrong thing used to cost a sprint. Now it takes an afternoon — and every hour after makes it harder to reverse.
There is surely nothing quite so useless as doing with great efficiency what should not be done at all.— Peter Drucker
The market calls it the agentic SDLC. What that means, and where onMain fits →
The onMain Standard · one team, two lanes
The loops show the way. The gates hold the line.
Your way of working is written down once as loops your agents follow, step by step. Gates sit on the steps and decide whether the work may move on. Product and engineering each have their own, on one record.
Product lane · the Product Loop
Before anything is built, and after it ships
- Knows why
Every idea states the problem, who it's for and what success looks like.
- Tests the premise
The idea is challenged before it becomes work, not discovered wrong in review.
- Agrees before building
The brief is approved, and a change to it is seen by every card it touches.
- Defines done
Acceptance criteria come down from the brief to every piece of work.
- Checks the outcome
After release: did it do what we meant? What we learn becomes the next idea.
Engineering lane · the Planning & Engineering Loops
Clear work in, clean releases out
- Thinks first
A plan written against the real code, before a line is changed.
- Challenges its own plan
No plan is built until its assumptions have been attacked.
- Checks its work
Every step reviewed; the whole change passes one verified run.
- Works your way
Your way of working, written once, versioned, followed by every session.
- Lands cleanly
Releases checks parallel work together, once, and lands it. Releases →
Shared
Writes it down
One record both lanes read, so nobody re-explains what was decided.
idea → brief → card → plan → review → release
Caught before the build
8 wrong claims
in the median plan, found by the challenge before any code. 27 plans · at least 3 in every one.
Landed without a pile-up
34% → 16%
of pull requests needed a rebase once Releases landed parallel work together.
Your guardrails
Dial it up. Dial it back.
Your guardrails are a set of gates, each on or off. Start from a preset, set it once for the firm, adjust it per product.
Light
For a prototype or a spike.
- Know why you're building it
- Check it landed
Standard
For most product work.
- Premise tested, done defined
- Plan challenged and reviewed
- Outcome checked
Strict
For work that can't go wrong.
- Every gate on
- A person approves each step
Preset names are placeholders until the product names them (onMain Standard Gate System PRD, presets).
Why not just a prompt?
A prompt is a request. A gate is a rule your team chose.
- Check the idea is worth building. - Challenge your plan before you build it. - Check it did what we meant.
> update_plan status: executing ✗ plan_unreviewed This plan has no adversarial pass yet. > run the adversarial pass ✓ 8 claims corrected · executing
Any agent that connects over the MCP is held to the same gates. onMain brings no agent of its own. How it's different →
Building for clients? Keep them on the same page too.
The same guardrails, plus a client portal in your brand, built from the same work. Nobody writes a status report from memory again.