Dots Voice Notes to App Prototype: Build a Reviewable First Version

Turn a spoken idea into a scoped app brief, compare candidate approaches, and review a prototype with explicit checks and approval boundaries.

Editorial recipe, reviewed October 1, 2026. This workflow is inspired by Altman’s reported use of dots, not a first-hand prototype benchmark. The sample app is fictional. We do not promise overnight completion, a fixed number of versions, or production-ready code.

Prerequisites: a conversation and a safe workspace

Check eligibility and limits first. OpenAI’s channels guide says to start a call with the phone button in your dot’s conversation, or Call in its desktop profile. Set up your dot on desktop first; use mobile-app access when available. A typed brief is a valid fallback if voice is unavailable.

Choose a disposable project with synthetic data. Your dot has a cloud computer; connecting your own computer is optional. If your project needs an existing local repository or Codex environment, arrange that access deliberately using OpenAI’s setup documentation. Do not grant local access just to dictate an idea. Review permissions and approval rules before building.

Tasks delegated to Work or Codex use those products’ allowances; see OpenAI’s access documentation. Limit the scope and request a checkpoint if capacity is exhausted rather than buying more capacity automatically.

1. Say the goal, then ask for a written brief

For a sample “idea inbox,” dictate or paste this prompt:

I want a disposable browser prototype for capturing product ideas.
Audience: one person reviewing their own fictional notes.
Goal: add an idea, tag it, and move it between Inbox and Reviewed.
Use synthetic examples only. No login, sync, analytics, external API,
paid service, production data, or deployment. No purchases.
Turn this into a written brief before coding. Include user stories,
acceptance checks, assumptions, open questions, and a bounded plan.
Confirm what you heard, especially names, numbers and constraints.
Wait for my approval of that brief before implementation.

Read the written brief. Correct speech-recognition mistakes and missing constraints. Choose whether reload should preserve data; for this example, specify that data remains only for the current page session and resets on reload. Ask it to show that limitation in the interface. A brief should make an ambiguous voice idea testable.

2. Compare candidate approaches before multiplying code

Propose two lightweight approaches for the approved idea inbox.
Compare interaction, accessibility, state handling, dependencies,
and tradeoffs. Sketch the screens. Do not build both yet.
Recommend one and ask me to select the implementation scope.
Work only in the disposable project we agreed; do not touch other
repositories, install unapproved software, or change production.

Select one approach or approve a bounded comparison. Altman reported reviewing several implementations; that is not a reason to demand five versions for every task. A short comparison can answer a design question without consuming unnecessary work.

3. Implement one candidate and review evidence

Build the selected candidate using the approved brief and workspace.
Stay within the agreed tools and dependencies. If a new permission,
service, install, secret or paid step is needed, stop and explain it.
Return the changed files, run instructions, checks actually executed,
known limitations and a preview I can inspect. Do not deploy or merge.
If interrupted, report completed work, remaining work and how to resume.

Open the preview yourself. Try adding a blank idea (it should be rejected), adding a real sample (it should appear), tagging it, moving it to Reviewed and back, and reloading (the agreed reset behavior should occur). Try keyboard navigation and a 390px viewport. Check that text is readable, controls fit, and focus is visible. Ask for errors from the browser console and meaningful checks; distinguish a test run from a proposed test.

4. Give specific feedback and rerun the affected checks

On the current preview, the Reviewed state is hard to distinguish.
Change its visible label and keyboard-accessible control. Preserve
our agreed data-reset behavior. Explain the change and rerun the
state-transition, reload, keyboard and narrow-screen checks.
Return evidence and limitations. Do not expand the scope or publish.

Attach observations about the current version rather than a new unbounded feature list. Confirm what changed before assigning the next iteration. The useful loop is idea, written brief, candidate, evidence, feedback—not an assumption that generated code is correct.

Voice, stopping, and failed builds

Ending a voice call does not necessarily stop assigned work, according to the channels guide. Explicitly stop the active task, check Activity for delegated work, and cancel any scheduled work separately if you created it. If transcription fails, switch to text and reconfirm the brief. If a build fails, ask for the exact error and the smallest repair within scope; keep the last reviewable version.

If the dot cannot access the project, fix the named permission or use a permitted disposable workspace; do not send credentials in chat. If usage limits interrupt work, request a checkpoint and resume when capacity permits. If a preview is inaccessible, ask for files and local run instructions; an inaccessible preview is not a passed review.

Before using real data or releasing an app, conduct a separate code, dependency, privacy and security review and explicitly approve publishing. Our safety reference explains that custom rules do not override built-in guardrails. A successful prototype interaction is not a production-readiness assessment.

Expected result

Expect a scoped brief, one reviewable candidate, evidence from agreed checks, and a list of unresolved issues. For the complementary attention-management workflow, see morning briefing and email triage. Return to the interview analysis for the distinction between reported experience and official capabilities.