The PRD you already write becomes the native app — not the handoff

Job 1 — prototype to learn. The question is “should we build this?” or “how complex is this really?” You attach the PRD, the agent builds the feature on a phone, and you put it in front of five users and your stakeholders as an installed app, not a link. The difference from a web prototype: the answers you get are about the thing that will ship — feel, notifications, the one-handed flow — and the build is kept when the answer is yes. Mobile app prototyping has the three fidelities and when each is enough.

Job 2 — ship the v1. The decision is made and mobile capacity is three sprints away. You scope the v1 in the PRD’s out-of-scope list, the agent builds it feature by feature with a spec you approve each time, and it goes to TestFlight on the Pro plan and to the stores on your own Apple and Google accounts. Engineering joins on the code it would have written anyway — an Xcode project and an Android Studio project — for the parts that need judgment: an unusual integration, a performance question, a security review.

The web builders describe a different second job. Lovable’s page for product managers: “Turn PRDs, docs, screenshots, or pull in any context to create a custom internal tool or prototype a feature.” The output is a web prototype or an internal tool, and the FAQ on the same page asks “Do I need an engineer to go live?”. For a mobile product that question is the job; Modaal answers it in the FAQ below.

1. Attach what you have. The first prompt takes “text, images, Figma links — whatever you provide”, and “you can attach a PRD, design doc, or screenshot with no text at all. The agent reads the attachment and works from its content.” If the PRD is not written yet, the PRD prompt produces a one-page one in seven sections from six questions.

2. Approve the plan. With Plan on, the agent “produces a structured implementation plan (a feature spec) without writing code”: overview, user scenarios, technical approach, implementation steps, files to create or modify, risks and open questions, testing strategy. You read it the way you read an engineer’s plan — is this the feature I described, is anything out of scope creeping in — and approve or correct. On a new project the Refine flow also “writes a structured PRD to PRD.md” at the root, so the document lives in the project.

3. Build and run. The agent writes Swift and Kotlin, compiles with Xcode and the Android toolchain on your Mac, reads its own errors, fixes them, and shows the result in the simulator. You correct in sentences — “sign-up without an account too”, “list first, map second” — and the loop runs until the scenarios pass. The AI is the subscription you already pay for: “Already subscribed to Claude, ChatGPT/Codex, Gemini, or Copilot? Sign in and Modaal runs on that plan — no separate API bill.”

4. Test with people, then ship. Install on your own phone for a week; five users from the target group with one task; TestFlight for the wider group. Then App Store Connect and Google Play Console on your accounts — $99 per year and $25 once — with the store page built from the three screenshots you designed in the PRD stage. PRD to app walks one document through all four steps.

The classic PM trade-off — iPhone first and Android in a later quarter, or a cross-platform framework and a non-native feel — is the one Duet was built to remove. Pick a Duet template when the project starts and each feature’s logic is written once; the iPhone app renders it in SwiftUI and the Android app in Jetpack Compose, each with its own native screens. Choose “iPhone now, Android later” and every feature is still recorded as in the two-platform version: “Ask the agent for Android when you want it.” Android is included in every account.

The proof point is our own app: Memory Lane, a digital memory box for families, went from iPhone to Android with zero logic files changed and six entries in the divergence ledger — the record of where the two platforms were allowed to differ on purpose. It is live at /examples/memory-lane.

What it is: an Xcode project and an Android Studio project in Git, with a PRD.md at the root, a spec per feature, and tests written from your scenarios. An iOS or Android engineer opens it and continues; a designer opens the Figma file that was the input. The designers page is their side of the same project.

What it is not: a prototype that engineering rebuilds, a web app in a wrapper, or a platform the app has to stay on. The code is on your Mac from the first build, and the plan that governs each feature is yours to approve.

What still needs an engineer: the things that need judgment rather than execution — an unusual integration, a performance problem, a security review, an App Review rejection that is about policy rather than code. Many product teams now run in this order: the PM ships v1, real users use it, and the engineer’s hours go to the parts of a running app that need them.

Write the PRD with the PRD prompt — six questions, one page. If the design exists in Figma, design-to-code tools explains what the file supplies and what the PRD has to. Download Modaal, attach both, and read the first spec the agent writes: it is the document you would have handed to engineering, and approving it is the first build. The Free plan covers a full project with unlimited prompts on one platform, no card; /pricing has the Pro plan for both platforms and distribution. The argument for why this is possible now, for people who work in product language rather than Swift, is in vibe coding for product managers; the honest answer to can a product manager build an app is on its own page.