Lumixia Brief

Turn a messy idea into a clear project brief GPT-5.6 actually understands — through a guided interview, a live confidence score, and instant sync to Notion.

Comment

Inspiration

Every founder, PM, and agency team knows the moment: someone drops a one-line idea into a doc — "build me a dashboard for X" — and everyone downstream has to guess what it actually means. AI tools make this worse, not better. Feed a vague prompt to a generator and you get a polished-looking output built entirely on invented assumptions nobody signed off on. Rework follows.

We wanted the opposite of "generate first, ask questions never." Lumixia Brief starts from the belief that a good brief isn't written, it's interviewed into existence — one adaptive question at a time, until the team can see exactly what's known, what's assumed, and what still needs a human decision.

What it does

Lumixia Brief turns a deliberately vague project idea into a reviewable, versioned one-page brief:

  1. Enter a rough idea.
  2. Answer 5–12 adaptive questions, one at a time — never while typing, only on submit.
  3. Watch confidence build across eight dimensions: Problem, Audience, Outcome, Scope, Constraints, Timeline, Risks, and Success criteria.
  4. Review a structured brief plus an "Alignment Improvement" summary showing what got clarified along the way.
  5. Reject any section for a focused follow-up question, or approve an immutable, versioned snapshot.
  6. Sync the approved version to a Notion page, idempotently — retrying never creates a duplicate.

The model (GPT-5.6) proposes facts, assumptions, contradictions, and dimension assessments. It never decides. The server independently calculates the confidence score, enforces stop rules, and owns every workflow transition — so the process stays explainable and testable, not a black box.

How we built it

  • Frontend: React 19 + Vite, served from Vercel's CDN, with an EN/TH language switch and full desktop/mobile support.
  • Backend: A single Express app running as one Vercel Fluid Compute function, with strict Zod contracts shared between client and server.
  • Auth & data: Supabase Auth (Google OAuth + mandatory TOTP/AAL2) and Supabase Postgres with forced Row-Level Security on every table — RLS checks ownership and MFA independently of the application layer.
  • AI: OpenAI's GPT-5.6 Responses API with Structured Outputs, store:false, and strict retry rules — swappable behind a provider interface so the app can run fully mocked for development.
  • Integrations: Per-user Notion OAuth with AES-256-GCM-encrypted tokens, and an owner-operated Codex MCP server (/api/mcp) that lets us run the entire interview through a Codex session instead of paid API calls, gated by Supabase OAuth 2.1 consent and AAL2.
  • Ops: Sentry with full payload redaction, Docker for local Supabase/portability checks only (not the runtime), GitHub Actions running format/lint/typecheck/unit/UI/RLS/E2E/audit/SBOM/secret-scan gates on every PR.

Codex was our pair programmer for nearly the entire build — scaffolding the app, implementing the confidence engine, writing the RLS policies, and generating the test suite — with every milestone logged in a Build Ledger and every architectural decision written up as an ADR.

Challenges we ran into

  • No paid OpenAI credits during the build. We solved this by making the model provider fully swappable (disabled / mock / live) and building an owner-operated Codex MCP integration plus a loopback bridge so the live interview could run against a real reasoning model without ever touching OPENAI_API_KEY.
  • Browsers don't trust HTTPS pages calling http://127.0.0.1. Our first Production rehearsal got blocked outright (ERR_BLOCKED_BY_CLIENT). We fixed it by keeping a same-origin loopback pairing popup open as a relay, so the production page never makes a mixed-scheme request directly.
  • Auth migration mid-build. We started on a third-party auth provider and migrated to native Supabase Auth to get first-class AAL2/MFA enforcement baked into both the API and RLS — a full rip-and-replace under deadline pressure.
  • Keeping AI honest. It was tempting to let the model's confidence claims stand on their own. Instead we built a deterministic scoring rubric (sum of dimension points / 24 × 100) entirely in server code, so the number is explainable and unit-tested, not a model's opinion.

Accomplishments that we're proud of

  • Production fails closed: missing security or provider configuration stops the app from starting at all — no silent fallback to insecure defaults.
  • 85%+ line/function coverage on the server, with stricter 90% gates on security-critical code, backed by unit, API, UI, Supabase RLS, and Playwright E2E suites.
  • A fully working Codex MCP integration that lets the owner run the core product loop without spending a cent on the OpenAI API.
  • A complete, sanitized audit trail — 22 Build Ledger milestones and 9 architecture decision records — documenting exactly what changed, why, and how it was verified.
  • A sub-three-minute path from a vague one-line idea to an approved, Notion-synced brief.

What we learned

  • Separating "the model proposes, the server decides" turns AI output from a trust exercise into something you can actually test and reason about.
  • Loopback-to-browser communication under HTTPS has real, non-obvious security constraints — an origin-bound relay window ended up being simpler and safer than trying to fight the browser's mixed-content policy.
  • Supabase RLS plus AAL2-aware JWT claims is a powerful pattern for enforcing MFA at the data layer, not just the UI.
  • Writing ADRs and a build ledger while iterating fast with an AI pair programmer keeps decisions traceable instead of getting lost in commit history.

What's next for Lumixia Brief

  • Turn on the live GPT-5.6 Responses API path for all users once API budget is approved (the code path is already contract-tested and ready).
  • Richer Notion sync — mapping brief fields to database properties, not just creating a child page.
  • Multi-brief workspaces with team comments and shared review, not just single-owner approval.
  • Additional languages beyond EN/TH, and a lighter mobile-first interview flow.

Built With

Share this project:

Updates