Skip to main content
The plan is what makes Archie different. Here’s what it is, why it comes first, and how it drives the build.

​
What is the Archie plan?

The plan is Archie’s structured definition of your app. Archie generates it from your idea, and you edit it until it says what you mean. It has five sections, each editable on its own:
  • Overview — what the app is for
  • Modules — the features and capabilities the app offers
  • User types — the people who use the app, and what each can do
  • System services — built-in services like authentication, file storage, and roles
  • Integrations — the third-party services the app talks to
A preview section shows sample screens so you can see how the plan becomes UI. When you build, Archie reads the plan as its source of truth. See Plan overview.

​
Why does Archie create a plan instead of jumping straight to code?

Because code generated straight from a prompt has nothing underneath it. It can look right on the first try, but there’s no defined user model, no clear structure, and no shared idea of what the app is supposed to be — so every change after that is a guess. That’s where most AI-built apps start to fall apart. The plan fixes the order. You decide what the app is while decisions are cheap — the plan is structured text, and changing it costs almost nothing. A build is expensive: it takes time and credits, and a build from the wrong idea gets thrown away. Steer the plan, then build once. See Why the plan comes first.

​
Other tools have a “plan mode” now. How is Archie’s plan different?

Several AI builders now offer a planning step: before a change, the agent writes a task list for you to approve. That’s useful, but the plan is about one change, and it’s gone once the change is made. Archie’s plan is the lasting definition of the whole app. It stays with the project, and everything is generated from it: the UI architecture that lays out every screen and who can access it, the spec for each screen, and the backend with its data model and permissions. When you want a structural change, you change the plan — and the next build follows it.

​
How does the plan turn into an app?

Generation splits into two tracks, both started from the plan. Generate Frontend lays out every screen in a sitemap, lets you review each screen’s spec, and builds a click-through prototype from the screens you choose. Generate Backend builds the database schema and APIs on Archie Core. The tracks don’t depend on each other. Once the prototype is ready, Generate Full-Stack turns it into a real, deployed application. See When to run the build.

​
How do I know my plan is ready to build?

You’re ready when you’ve read every section, the modules list everything you need and nothing you don’t, your user types have real names and concrete descriptions (not placeholders like “User” and “Admin”), and you can describe what the built app should do without looking back at the plan. If a section feels off, fix it first — a few minutes of editing saves a wasted build. The full checklist is in When to run the build.

​
Can I edit the plan after I’ve built the app?

Yes. Edit the plan and generate again; the next build picks up your changes. Each project has one plan — to explore a different direction, create a new project.

​
Can I export the plan?

Yes. You can export your plan as a PDF at any time, including on the Free plan. It’s a clean way to share what you’re building with cofounders, investors, developers, or anyone else who needs the full picture.

​
What tech stack does Archie use?

Archie chooses and manages the tech stack for you, so it isn’t shown or edited in the plan. The frontend is a generated React application, hosted on a global CDN. The backend runs on Archie Core: a PostgreSQL or MySQL database with auto-generated GraphQL and REST APIs, authentication, role-based access, file storage, and real-time subscriptions. If you have a hard requirement, mention it in your prompt before you generate.

​
What are Specifications?

Specifications are coming soon. They add a detailed layer between the plan and the code: functional, visual, and technical design documents — features with user stories and acceptance criteria, styling and layout, the data model and technical strategy — that the build agents read before writing anything. When Specifications ships, the flow becomes prompt → plan → specifications → code. See the Specifications preview.

​
Is Archie’s plan the same as “spec-driven development”?

It’s the same idea. Spec-driven development means defining what software should do before generating it, and Archie’s plan does exactly that for your whole app. Specifications, coming soon, take it further with detailed functional, visual, and technical documents for every feature.