Plan

Before build, there’s the part most builders solve with five different tools: idea analysis, PRD, personas, wireframes, pricing, roadmap. Atelier folds it in. The plan lives in the Console, version-controlled in your project, compiles to schema + RLS + scaffolded UI, and stays the source of truth as the code evolves.

The shape

.atelier/plan/
├── analysis.mdx        ← market / competition / viability
├── prd.mdx             ← spec, version controlled
├── personas.yaml       ← user model
├── journey.draft.json  ← visual journey map
├── wireframe.draft.json
├── landing/            ← waitlist, A/B copy
├── pricing.mdx         ← model + tiers + WTP analysis
└── roadmap/            ← issues, sprints, cycles

People work in the Console. The Console reads and writes this tree. Git is the audit log — every save is a diff your team can review. The CLI is an escape hatch for automation and CI; humans don’t need it day-to-day.

Start with the idea

Open Console → Plan → Idea. Type the one-line concept into the prompt entry (“Multi-tenant invoicing SaaS for indie freelancers”) and press Analyze. A dashboard fills in:

• Market size card — recent web signal + comparable SaaS revenue.
• Competition card — auto-built matrix showing where each existing product sits across the dimensions that matter for your idea.
• Pattern matches card — privacy-respecting metadata across Atelier projects: who tried something similar, what they kept, what they dropped.
• Viability score (1–100) with the reasoning expanded inline.
• Risks + opportunities list, ordered by severity.

Hit Re-analyze any time — the dashboard shows what changed in the market since the last pass.

The dashboard’s backing artifact is .atelier/plan/analysis.mdx. Same data the Console writes when you save. Diff it like any markdown file.

Or via CLI: atelier plan analyze "<idea>" for headless runs.

Write the PRD in chat

Open Console → Plan → PRD. The surface is side-by-side: the draft on the left, an assistant chat on the right. Sections are standardized — problem, users, goals, non-goals, constraints, MVP, success metrics, open questions. Empty sections get prompts; filled ones get challenged. You answer in chat; the draft updates in place.

The version timeline runs down the side of the editor. Click any version to load it; click two to diff them. A Review button runs an AI critique against the standard sections and pins the comments in the margin.

The draft is just markdown on disk at .atelier/plan/prd.mdx. Same data the Console writes when you save. Branch it, roll it back, code-review it.

Or via CLI: atelier plan prd (interactive), atelier plan prd diff, atelier plan prd review.

Persona + journey

Once the PRD is roughed in, model the people who’ll use the product.

Open Console → Plan → Personas. The persona list runs down the left; each one opens a form on the right — role, permissions, goals, frustrations. Save and the persona compiles to an RLS role.

# .atelier/plan/personas.yaml
- name: Freelancer
  role: end-user
  permissions: [own-invoices, own-clients]
  goals: [send invoices fast, look professional]
  frustrations: [hates spreadsheets]
 
- name: Agency owner
  role: tenant-admin
  permissions: [all-of-team, billing]
  goals: [bill multiple clients per project, manage team]

Same data the Console writes when you save.

Open Console → Plan → Journey. Drag steps onto the canvas. Wire each to a persona from the side panel. Each step becomes a page. Each transition becomes an analytics event. The activation funnel renders in the inspector — no instrumentation code.

Or via CLI: atelier plan journey opens the editor in the browser; useful in headless or remote dev.

Wireframe → schema

Open Console → Plan → Wireframe. The component palette only shows pieces from your Design Cascade — every drop is brand-on. Drop a component, then bind it from the inspector:

[Invoice table]   → table: invoices, columns: number, client, total, status
[Client form]     → mutation: create client
[Settings panel]  → policy: tenant-admin only

The Schema preview pane derives the migration draft and matching RLS policies as you go. SQL renders inline; click Accept to write it into .atelier/migrations/.

Or via CLI: atelier plan wireframe to open the editor headlessly.

Compile the plan into code

Open Console → Plan → Compile. A diff viewer opens with one tab per output:

• .atelier/migrations/<ts>_init.sql — schema + RLS policies.
• app/(routes)/... — route stubs for every journey step.
• .atelier/functions/ — backend Function skeletons for the core actions.
• .atelier/tests/ — RLS isolation tests for every persona-policy pair.
• Tracker tickets in the roadmap, one per MVP feature.
• Storage buckets, email templates, scheduled jobs — anything the plan implies.

Accept or reject per file. Plan diff → code diff. Plan version → code SHA. The traceability runs both ways: open any page in the running app and the Console shows the PRD section, the wireframe, and the journey step it came from.

Or via CLI: atelier plan compile for CI gates and headless pipelines.

Validate the idea before you build

Open Console → Plan → Landing. Pick a template (waitlist / pre-order / interest signal), and the page comes up branded with your Design Cascade and instrumented with Analytics. A/B copy slots — headline, hero, CTA — sit in the right rail; edit them in place and save to spin up a variant. Set the conversion threshold inline: “if we hit 20% signup, start building.”

When the threshold is met, the waitlist becomes the seed user list for the persona it was targeted at. Power users from the waitlist auto-link to the matching journey for early feedback.

Or via CLI: atelier plan landing for headless setup.

Price it before you ship

Open Console → Plan → Pricing. The surface shows three panels: comparable SaaS in your category (auto-pulled), per-segment willingness-to-pay sliders, and a model picker (per-seat / usage / tier / freemium). The recommended model is highlighted with the reasoning; conversion-by-tier is plotted underneath. Accept to write the default tier config — it wires straight into Billing.

A/B test plans are auto-generated for the prices you’re least sure about, and listed in the Experiments tab ready to launch.

The backing artifact is .atelier/plan/pricing.mdx. Same data the Console writes when you save.

Or via CLI: atelier plan price for headless runs.

Jobs to be done

Open Console → Plan → Jobs. The form at the top captures the job statement — functional / emotional / social, the job executor, the circumstances. Save and the job appears in the job-map canvas below.

The job map is a horizontal canvas with the eight steps already laid out: Define → Locate → Prepare → Confirm → Execute → Monitor → Modify → Conclude. Click any step to add an outcome metric. The importance × satisfaction matrix sits to the right; drag a step’s pin in the matrix and the ODI score auto-computes — importance + max(0, importance − satisfaction). Anything > 12 lights up as an innovation opportunity, > 15 is flagged extreme. Scores feed back into PRD goals and explicitly justify the non-goals.

# .atelier/plan/jobs/get-paid-fast.yaml
job: Get paid for freelance work within 7 days of completion
type: functional
job_executor: Freelancer
circumstances:
  - Just finished a project
  - Client doesn't have payment infrastructure

Same data the Console writes when you save.

Or via CLI: atelier plan jobs to list and edit headlessly.

Customer interviews → insights

Open Console → Plan → Research. Drag an audio or video file into the upload zone, and Atelier transcribes (Whisper-class) and diarizes interviewer vs participant. The transcript viewer opens with speaker labels on the left and timestamps you can click to scrub the original media.

The AI-extracted insights panel runs alongside the transcript — pain points, workarounds, goals, and verbatim quotes, each one tagged automatically. Click an insight to jump to the moment it came from.

Across interviews, the affinity board clusters insights — “67% of participants mentioned X” appears as a cluster card with the quotes that support it. Each insight links back to a job (#202) and forward to PRD evidence sections, so the PRD doesn’t drift from what was actually said.

For B2B SaaS sold to teams, each tenant runs their own interview library in their own Console — research stays scoped.

Or via CLI: atelier plan research upload <file> for batch ingest.

Brainstorm, then converge

Open Console → Plan → Brainstorm. Pick an exercise from the launcher:

• Crazy 8s — 8 minutes, 8 sketch frames, timer in the corner.
• SCAMPER — Substitute / Combine / Adapt / Modify / Put to other use / Eliminate / Reverse, each step prompted in sequence.
• Mind map — drag-drop nodes on an infinite canvas, AI suggestions for branches in the side panel.
• How Might We — reframing exercise, one HMW per card.
• Worst possible idea — reverse-thinking board to escape local maxima.

The board is multi-cursor live; teammates join from their own Console. The assistant sits in the side panel: “generate 10 more like these,” “find the boldest,” “find the safest” — new cards land inline. Switch the board to Converge and dot voting turns on. Winners get a Promote to Idea analysis button that drops them straight into Plan → Idea.

Or via CLI: atelier plan brainstorm to open a session headlessly.

Decision log

Open Console → Plan → Decisions. The list view shows every ADR with status filters (proposed / accepted / superseded / deprecated) along the top. Click any decision to open it; the supersedence chain renders as a graph in the drawer — decision X supersedes Y, Y supersedes Z. New ADR is a form: title, context, alternatives, decision, consequences, linked PRD sections.

# .atelier/plan/decisions/0001-multi-tenant-rls.yaml
id: 0001
title: Use Postgres RLS for multi-tenant isolation
status: accepted
date: 2026-06-10
linkedPrdSections: [3.1, 3.5]
context: |
  We need multi-tenant isolation. Options...
alternatives:
  - Database per tenant
  - Schema per tenant
  - RLS (chosen)
decision: Postgres RLS with GUC-threaded user context
consequences:
  - Pros: standard SQL, single DB, easier operations
  - Cons: all queries must run with correct GUC

Same data the Console writes when you save.

When code touches a PRD section linked to a decision and the decision wasn’t updated in the same PR, a banner appears in the Console review surface flagging the drift.

Or via CLI: atelier plan decision new, atelier plan decision list.

Hypothesis-driven

Open Console → Plan → Hypotheses. The backlog view sorts by confidence × impact — the bets worth running this week sit at the top. New hypothesis is a form: because / we believe that / to verify / success when / linked features / linked KRs.

# .atelier/plan/hypotheses/h-001.yaml
id: H-001
confidence: 60
because: Several interviews mentioned 'I don't know what to do next'
we_believe_that: Adding a 5-step checklist will lift onboarding completion
to_verify: A/B test checklist vs no-checklist
success_when: Completion rate +20% in 4 weeks
linkedFeatures: [F-042]
linkedKrs: [trial-to-paid-conversion]

Same data the Console writes when you save.

The save modal has two toggles — “create feature flag” and “create A/B test” — both on by default. Both spawn from the hypothesis without leaving the Console. The test result feeds back automatically; the hypothesis status flips to validated / refuted / inconclusive. The learning library is a searchable view: every shipped feature, every test, every confirmed or refuted belief, with filters for outcome, owner, quarter.

The library trains your confidence calibration over time: how often you said 70% and were right.

Or via CLI: atelier plan hypothesis new, atelier plan hypothesis list.

Risk + assumption register

Open Console → Plan → Risks. The heat map plots risk-if-wrong × confidence — top-right corner is the work to do this sprint. Click a cell to open the assumptions clustered there.

# .atelier/plan/assumptions/a-001.yaml
id: A-001
assumption: Freelancers will pay $10/mo for invoicing
type: desirability
risk_if_wrong: critical
confidence_now: 30
linkedPrdSections: [4.2]
validation:
  experiment: Landing page test (#187)
  threshold: 5% conversion from waitlist
  cost: 1 week
status: untested

Same data the Console writes when you save.

Each assumption drawer shows an AI-suggested validation experiment — the cheapest, fastest way to find out. Three buttons sit underneath: Start landing test, Schedule interview, Open flag pilot. One click and the experiment is set up against the assumption.

When an assumption is refuted, linked PRD sections surface a banner in the PRD editor — you don’t unknowingly ship a product that depends on it.

Or via CLI: atelier plan assumption new, atelier plan assumption list.

OKRs + success metrics

Open Console → Plan → OKRs. The quarter selector sits at the top — pick 2026 Q3 and the objectives for that quarter load. Add objective opens a form. Add KR opens a sub-form: pick a metric (autocomplete against your Analytics events), set baseline and target, choose direction.

# .atelier/plan/okrs/2026-q3.yaml
objective: Grow indie builder adoption
key_results:
  - metric: weekly_active_projects
    baseline: 50
    target: 200
    direction: up
  - metric: trial_to_paid_conversion
    baseline: 0.08
    target: 0.15

Same data the Console writes when you save.

Each KR card on the dashboard shows current value, a trend chart, and an On track / At risk / Off track badge updated nightly by cron. KRs link to PRD sections, which link to tickets, which link back. Close enough tickets in the right area and the KR moves on its own — the spreadsheet you used to maintain manually now maintains itself.

Or via CLI: atelier plan okr list, atelier plan okr update.

Public roadmap + changelog

Open Console → Plan → Roadmap. The board has Now / Next / Later columns. Each column header has a Make public toggle — flip it and that column appears at /roadmap for customers. Items get a public tag and the AI rewrites technical descriptions into customer-facing copy in the side drawer; you edit and approve before it goes live. Authenticated visitors can vote and comment from the public portal.

Switch to the Changelog tab. Merged tickets appear in chronological order with an AI-drafted entry in the right pane — benefit-led, customer-facing. Edit, approve, publish. The /changelog route picks them up; RSS feed, email digest, and an inline “What’s New” modal pick up since-last-visit entries. For B2B, each tenant gets their own portal scoped to changes that touched their slice.

Or via CLI: atelier roadmap publish to flip the internal tracker (#189) to public in one shot.

Roadmap, native

Linear-like tracker in the Console. Issues link to PRD sections and commits — close an issue when the commit lands. Cycles. Milestones. Per-tenant boards if your SaaS is sold to teams who’ll run their own. Linear import/export and API are first-class for teams who want to keep both.

PRD section 3.1 — "Invoice send"
  ↓ derives
Issue #INV-12 — "Implement send endpoint"
  ↓ linked to
PR #324 — atelier/invoicing-app
  ↓ merged →
Auto-close, link recorded in PRD timeline.

In Functions

ctx.plan mirrors the plan surface, scoped to the project:

export default async function nightlyPlanCheck(_req, ctx) {
  const drift = await ctx.plan.driftFromCode();
  if (drift.length) ctx.alerts.send('Plan and code have drifted', drift);
}

Use it for governance — keep the PRD honest as code evolves.

The plan compiles. The code traces back.

v0 ships UI. Atelier ships product.