Charter
The deep version

What Charter actually does at each gate.

The home page tells you what Charter is. This tells you what it does— phase by phase, the judgment a code generator can’t give you, and the one thing that compounds across every bet. We follow one real bet, Bonsai Compose, the whole way down.

Charter writes no application code — Claude Code does that. Everything Charter does sits aroundthe code: deciding what to build, catching what you’d regret, wiring the launch, reading the small signal, and — the part that matters most — remembering. Six gates. At each one, a decision and an artifact.

Phase by phase

Six phases, one founder.

1

Ideate

You bring
A raw idea, in a sentence.
Charter does
Interviews you Mom-Test style — one question at a time, about your past and your life, not your hopes. Every concept-doc field is proposed for you to agree or push back on, never written silently.
What it decides
Whether the bet is falsifiable yet. It refuses to fill a field it can’t ground in something you actually said, and asks again instead.
The artifact
A concept doc with a problem, an audience, and a kill condition.
2

Design

You bring
The concept doc, and a design (Claude Design, or your own).
Charter does
Writes an executable brief, previews your attached design inline through its own proxy, and runs a design audit against the brief’s surfaces, your bet thesis, your non-goals, and your standing lessons.
What it decides
Approve or revise. A missing brief surface forces revise — the gate hint carries the verdict forward.
The artifact
A brief + a design verdict with grouped findings.
3

Build

You bring
The concept and brief. Your GitHub + a deploy connection.
Charter does
Writes the spec, GTM plan, and acceptance criteria; resolves open decisions with you; creates the repo and pushes the whole package — CLAUDE.md, brief, concept, decisions, lessons; links Vercel or Netlify; and provisions env, auto-creating the Supabase project and pushing the keys.
What it decides
The architecture decisions worth surfacing before a line is written — auth, data model, the cuts that keep the MVP shippable.
The artifact
A repo Claude Code can run, already wired to deploy.
4

Audit

You bring
What Claude Code shipped (a push to the repo).
Charter does
Reads the real diff between what it specced and what shipped, runs two deterministic preflights — deploy config and env parity — and judges the diff against your acceptance criteria and your past lessons.
What it decides
Ship or don’t-ship, with launch-blockers named in plain English. Any HIGH finding holds the verdict.
The artifact
A verdict + findings. It once caught a vercel.json cron that would have failed the deploy silently on the free plan — before a single push was wasted.
5

Launch

You bring
A verified build.
Charter does
One click each: buy the custom domain and provision SSL, wire transactional email (Resend DKIM/SPF + a real confirmation send), connect analytics and error tracking, then draft your launch announcement.
What it decides
Nothing for you — it removes the wiring so the only decision left is “go.”
The artifact
A live app, on a real domain, sending real email.
6

Monitor

You bring
A launched bet.
Charter does
Reads real signal — live deploy health, Plausible visitors and pageviews and bounce, unresolved Sentry errors, your activity feed, and API spend. No placeholders.
What it decides
Surfaces the decision window as your kill condition approaches. Drop, extend, or push on.
The artifact
A calm readout, while it’s still small enough to read every event — feeding the postmortem that writes your next rule.
The part Claude alone can’t do

Watch a score move.

Every dropped or shipped bet ends with a postmortem that distills one rule for next time. The rule joins your library and feeds the conviction scorer on every future idea.

So a score isn’t a number from nowhere. Charter shows you the baseline— what it would score from your profile alone — and exactly how your own past lessons moved it. The scorer you have after thirty bets is a different scorer entirely. That’s the moat, and it’s the one thing that gets better the longer you use it.

58
Confidence · medium
manual · just now
“A push-digest of unread newsletters — the calm inbox for what you actually subscribed to.”
HOW YOUR LESSONS MOVED IT
baseline 72final 58−14 from your lessons
−14“If a category has 3+ free alternatives launching the same quarter, discount conviction.”from Beacon · dropped month 2
CHEAPEST TEST
Post a one-category MVP to the niche’s subreddit. 20+ saves in a week before you build the rest.
Baseline shownwhat it’d score before your lessons
Your scar tissuea past drop, pulling this one down
Honest about the edges

What Charter doesn’t do.

  • −Writes no application code. Claude Code does — and you run it, or pair with someone who can.
  • −Not a team tool. It calibrates against one operator profile; multi-founder is out of scope.
  • −Not no-code. The Ideate / Design / Launch / Monitor thinking needs no code; the build still runs through Claude Code.
  • −Buys nothing without you. Domains and paid tiers are your call, at the provider’s checkout.
  • −Says “I don’t know yet” instead of guessing — and flags when it’s scoring from your profile alone, with no lessons yet.
The wiring it really does

Connected, not described.

Charter doesn’t just talk about your stack — it holds the tokens and does the work.

GitHubRepo create + full handoff package + diff readslive
VercelProject + env + redeploy + domain buy + DNS + deploy healthlive
NetlifySite + env + builds + deploy health (peer deploy target)live
SupabaseAuto-creates the project, wires URL + keys into envlive
ResendDomain verify + DKIM/SPF + scoped key + real sendinglive
PlausibleSite create + snippet auto-committed + live statslive
SentryProject + DSN + SDK auto-committed + recent issueslive
CloudflareDNS for domains you bring from outside Vercellive
StripePayments + revenue on Monitorparked

The judgment is the product.

The code is a commodity Charter hands to Claude Code. What compounds is everything around it.

Get early access →