The mind map
The mind map is the canvas where your whole app lives. Everything you plan sits here as connected nodes, so you can see the shape of what you are building and so can your agent.
The map
Note Taker app
Connect your AI agent
Claude Code, Cursor, Codex, Gemini CLI & more
Core Features
Core features and functionality
Dashboard
this is a dashboard to view all projects
Scanner
Scan documents straight into a note
Sub-features
Child features
Analytics
Users can see the top level analytics, like revenue, cost, CPM and profit for example
Notes
The first screen users land on. It lists every project with its status and last activity, plus a rollup of open tasks so nothing slips.
PRD Bridge
Get Started Creating Your PRD
Select the type of Product Requirements Document you'd like to generate
Frontend / UI
Generate requirements for user interface and frontend features
Backend Features
Generate requirements for backend logic and API endpoints
Database Design
Generate requirements for database schema and data models
The canvas is an open space you can pan and zoom. You drop nodes onto it and join them with edges, so the whole app is visible at once. The map above is one coming together: a project node at the root, a feature branching off it, a bridge, a note written in plain language, and the sub features that make the feature work.
How the map grows
A map grows outward from one root. You start with the project node, then branch as the app takes shape, adding only what each part actually needs.
- Project node. The root that names your app and holds everything else.
- Features. One node for each main part a user can use, branching off the project.
- Bridges. A hub you branch off a feature when it needs more context grouped in one place.
- Notes. Plain language descriptions that tell the agent how something should behave.
- Sub features. The individual screens or flows inside a feature, built one at a time.
For a full reference of every node type, see Nodes explained.
Why it exists
The map is not decoration. Your agent reads it, so you plan once and stop re-explaining your app from memory. Every node you add is context the agent can use, which means fewer long messages and fewer tokens spent repeating yourself.
Because the connections are visible, you can also see how a change in one place affects the rest, which is how you avoid fixing one thing and quietly breaking another.