Cursor writes the code. Mandaire decides what to build. Before any code exists, Mandaire reads your intent and writes back what it heard, what it is not building, and the assumptions it is making. If it misread you, you find that out before code costs anything.
If you have shipped a fast build that solved the wrong problem, you already know what this is for. If you are staring at a vibe-coded project and are not sure what it actually is anymore, same thing.
We respond within 24 hours. Tell us what you are building.
What "refuses" means
Most AI builders will build whatever you describe. That is the problem. Mandaire reads the intent brief first, before a line of code exists, and writes back what it thinks you want, what it is deliberately not building, and the assumptions it is making. If the brief misreads your intent, you find that out before code costs anything. It is not a refusal that happens after the code is written. It is a catch that happens before the code exists.
The refusal shows up in practice like this:
[mandaire dev · Intent brief · "user dashboard v2"]
Here is what I think you want:
A dashboard that shows the 5 metrics a free-trial
user needs to see to decide whether to convert.
Not an admin view. Not a power-user view. A
conversion-decision view.
Here is what I am deliberately NOT building:
- Usage graphs going back 90 days (converts nobody;
you asked for "history" but the conversion moment
is always this week vs last week)
- The settings gear in the top-right (you mentioned
it three times; it belongs on a settings page we
have not built yet, not on the conversion surface)
Assumptions I am making (please correct):
- "Convert" means upgrade to paid; not activate
a feature or complete an onboarding step
- The 5 metrics are the ones from the Notion doc
dated April 3, not the revised list from the
investor deck — those are different and you have
not reconciled them
One product call I need before I build:
Which of the two metric lists is canonical?
I will not start until you tell me.That metric conflict had been sitting in two documents for six weeks. Nobody caught it because nobody was asked to reconcile them before writing code. The intent brief asks.
When the brief is approved, the code gets written. A working application in a private repository, ready to run. The refusal happens before the build. The build still happens.
What this is for
Lovable, Bolt, Cursor. The first draft of almost any product now takes days, not months. That is real progress. The problem is that the failure mode, describing what you want, shipping it fast, and discovering it was the wrong thing, now happens in days instead of months too. The speed of execution went up. The quality of the brief did not.
Every hour spent on a wrong build is an hour not spent learning from customers.
The waste vectors in early-stage software product building, ordered by how much each one costs when you get it wrong:
Where Mandaire sits in the stack:
| Cursor / Lovable | Cowork / Operator | Mandaire .dev | |
|---|---|---|---|
| What it does | Writes the code | Executes tasks | Decides what to build |
| Remembers past decisions | No | No | Yes: every call, why you made it |
| Checks your thinking before building | No | No | Yes: refuses if the brief is wrong |
| Written record after each build | No | No | Yes: what was built and why |
| Price | $20-50/mo | $20-200/mo | $500/mo |
Cursor and Cowork are the execution layer. Mandaire is the judgment layer above them. A Mandaire user might also use Cursor. The comparison that matters is the one you are already making: whether you need a CTO function and cannot or should not hire one yet. Fractional CTO retainers run $2,500-15,000/month. Mandaire in beta is $500.
The question worth asking: is this different from pasting a spec into Claude and asking "what am I missing?" Yes. Mandaire has watched your previous builds. After three months it knows you rejected the multi-tenant architecture for cost reasons, chose Postgres because you wanted control, and that the investor deck has a different feature list than the Notion doc. Claude does not know any of that. It starts over every time. The ledger does not.
A recent example
Moltbook launched. Three days later, 1.5 million API auth tokens were exposed. The root cause was a judgment call that was never made: how the API surface should handle token scope. Not a coding error. A product decision that nobody decided before the code was written.
The intent brief Mandaire writes before any code exists is the artifact that surfaces that call before it ships. Scope, threat model, auth behavior: these are product decisions, and they belong in the brief, not the post-mortem.
Who it is for
You know what you want to build. You can recognize when the build matches your vision. You are not the one who should be writing the code. The founder, the operator, the product person who has lived the customer problem and can bring real judgment to the calls that matter.
It is not for projects where what you want is a template you could buy. It is not for hand-tuned ML infrastructure. It is not yet for engineering teams that already have a CTO function.
Each build delivers a working application in a private repository, plus an intent brief, end-of-build report, and decision ledger in writing. Works with any stack Cursor or Claude Code can run. Typical first build: 3 to 5 working days from an approved intent brief. The code and the artifacts are yours permanently.
This is an ongoing relationship, not a one-shot delivery. Month two starts with the decisions and corrections from month one already encoded. The judgment compounds. The ledger is always live.
$500/month in beta.
Priced against the fractional CTO function ($2,500-15,000/mo), not against Cursor's $20. The self-hosted open-source path is free. Full pricing and operating model at how it runs. Real artifacts from the first build at Proof.
Go deeper
Proof
Not promise
Real artifacts from building mandaire.app: the intent brief, the end-of-build report, the decision ledger, the taste memory, the failure admission. What Mandaire actually produces.
Beta plan
90 days, falsifiable
Week 0 through Day 90. What we will prove. What counts as success. What counts as failure. Named, not hedged, because a CTO with falsifiable terms is different from any other AI builder.
How it runs
Build with us, ship without us
For the build, not for permanent hosting. How the LLM stack works, pricing, sovereignty path, what stays yours when you graduate to your own infrastructure.
The full architecture and trust commitments are at mandaire.org.
Private beta. First seats are going to founders we know fit the archetype. A one-paragraph reply about what you want to build helps us prioritize.
Beta users are founding positions. The judgment Mandaire accumulates with early builders directly shapes what the product becomes. This is not a drip sequence with a discount code at the end.