Skip to main content

​
The basics

Modaal is an AI coding agent that turns plain-language product specifications into a production-ready native mobile app.Instead of generating snippets, it works through a structured Spec → Build workflow and keeps key artifacts aligned (PRD, flows, architecture, and code), so you end up with a real, scalable codebase you can ship.
Vibe coding is fast and fun, but it often breaks down on complex features, edge cases, and larger codebases—because decisions happen “in the moment” and aren’t captured cleanly.Spec-driven development keeps the speed, but adds structure:
  • define requirements and constraints up front
  • document system design + key decisions
  • break work into implementable tasks with acceptance criteria
  • keep everything traceable from intent → implementation
In practice: fewer misinterpretations, less drift, and higher-quality outputs when the app gets real.
Tools like Cursor/Claude are great at helping with code and debugging—especially inside an existing repo—but they usually don’t produce a complete, coherent app system by default.Modaal is built around:
  • generating full app structure (screens, navigation, data models, modules)
  • maintaining cross-artifact synchronization (spec ↔ design ↔ data ↔ code)
  • producing native code that compiles, runs, and is meant to ship

​
Getting started

You can start from this article to set up Quickstart , after setup you typically go through three steps:
  1. Describe what you want to build (users, key journeys, must-have features)
  2. Work on screens, flows, and logic (iterate in plain language, step by step)
  3. Check how it looks on simulator or real device
If you’re coming from a prototype (Lovable/v0/etc.), you need to rebuild your mobile app as the technology we use is Swift, not React so you can bring your MVP scope and your core flows and build this in Modaal.
The best inputs are concrete:
  • core user journeys (happy path + 2–3 key edge cases)
  • your MVP feature list and what “done” means
  • data objects you care about (e.g., User, Project, Session)
  • any must-have constraints (offline, background work, sensors, auth, etc.)
  • example apps you like (for UX reference)
Tip: start with one “end-to-end” flow you can ship fast (a vertical slice), then expand.
Today, Modaal can generate wireframes / UI structure and keep it aligned with your flows and architecture.Importing Figma is not ready yet, but will be till mif February 2026 for sure.
Modaal has 3 ways to start, depending on how clear your idea is:
  • Vibe -  “I have an idea, just go with it.”
    Use for: brainstorming, quick prototypes, exploratory coding, creative experiments.
Best when: you’re still discovering what you want; you want something working fast, even if it’s rough
  • Refine  -  “Turn my idea into a well-structured PRD.”
    Use for: PRD refinement, requirements clarification, specification writing.
Best when:  your idea is fuzzy; you want the agent to help you turn “thoughts” into a real PRD + scope
  • **Specify - ** Rigorous cycle: specification → planning → tasks → implementation.
    Use for: complex projects that benefit from structured execution, or when requirements are already clear.
Inside Specify, you’ll move through stages:
  • Clarify — close gaps in requirements, ask/answer key questions
  • Plan — propose architecture + approach
  • Tasks — break into executable tickets / steps
  • Analyze — sanity checks (edge cases, consistency, risks)
  • Implement — write the code and wire everything together
(* = stages where you usually want to read carefully and confirm intent before moving on.)
Default recommendation: if you’re not sure, start with Refine.
Once the PRD is solid, switch to Vibe (move fast) or Specify (go structured).

​
Code and ownership

Yes, you end up with a standard native codebase (e.g., SwiftUI for iOS) that you can export into Xcode and continue evolving.
Yes—after export, you can treat it like any other native project:
  • refactor
  • add libraries
  • integrate your backend
  • ship through your normal CI/CD
Modaal’s value is that the “spec → build” loop stays structured as you iterate.

​
Platforms and tech

iOS is supported today. Android is coming soon.
Modaal generates native UI and app structure, including:
  • SwiftUI screens for iOS
  • data models and API logic
  • background tasks where relevant

​
Capabilities

Modaal is designed for “native-advantaged” features where web/hybrid builders hit limits, like:
  • widgets and OS surfaces (e.g., Live Activities)
  • offline mode and background work
  • sensors / hardware access
  • watch companions (where relevant)
  • performance-critical experiences
Yes. If you already have APIs, you can provide:
  • endpoints + auth method
  • key request/response shapes
  • error states and retry behavior you want
Then Modaal can align the data models and flows around that contract.

​
How the workflow stays coherent

Modaal treats PRD, user flows, data flows, navigation, and architecture as connected artifacts.When you change one (e.g., add a new state to a flow), it updates the related pieces so you don’t get “version drift” between docs, design, and implementation.