Zagvo

Resources · Documentation

Documentation

Everything you need to learn how to plan, build and launch software with AI — using Zagvo and the AI builders you already use.

Suggested:

Start here

Getting started

Eight guides that take you from an idea you can describe to a product you can launch. Read them in order the first time.

Start here

What is Zagvo and what should I do first?

Zagvo is an AI workspace that plans your software before you build it, then hands the plan to whichever AI builder you use. Start by describing your idea in one paragraph — everything else follows from that.

What you’ll learn

  • What Zagvo does and, just as importantly, what it does not do
  • Why planning before prompting reduces rebuilt work
  • The shape of a first session, end to end
Who this is for:
Anyone opening Zagvo for the first time.
Prerequisites:
None.
Beginner4 min readGetting Started

Create your first project

How do I create a project in Zagvo?

Describe your idea in plain language on the workspace home screen. Zagvo reads it, asks a small number of clarifying questions, and creates a project you can build against.

What you’ll learn

  • How much detail your first description needs
  • What the clarifying questions are actually looking for
  • How to rename, re-scope or archive a project later
Who this is for:
First-time users with an idea they can describe out loud.
Prerequisites:
A Zagvo account.
Beginner5 min readGetting Started

Understand the Zagvo workflow

How does the Zagvo workflow actually work?

Idea → understanding → roadmap → phases → tasks → builder prompts → progress → launch readiness. Each step narrows ambiguity so the next one produces something concrete.

What you’ll learn

  • What each stage produces and why it exists
  • Where your AI builder enters the loop
  • Which steps you can skip and which you should not
Who this is for:
Builders who want the mental model before clicking around.
Prerequisites:
None.
Beginner6 min readGetting Started

Choose an AI builder

Which AI builder should I use for my project?

It depends on what you are building and how much code you want to touch. Prompt-first builders suit new web products; editor-based assistants suit existing codebases.

What you’ll learn

  • The three families of AI builder and how they differ
  • Which project types each family handles well
  • How to make a reversible choice instead of a permanent one
Who this is for:
Anyone deciding between Lovable, Cursor, Claude Code, Bolt, Replit, Windsurf or Emergent.
Prerequisites:
A rough sense of what you want to build.
Beginner8 min readGetting Started

Generate your first roadmap

How do I get a roadmap for my idea?

Once your project understands the idea, Zagvo generates a phased roadmap with concrete tasks. Read it end to end before building anything — that read is where most scope problems get caught.

What you’ll learn

  • What a good first roadmap looks like
  • How phases are ordered and why
  • How to trim a roadmap that is too ambitious
Who this is for:
Builders with a created project and no plan yet.
Prerequisites:
A created project.
Beginner6 min readGetting Started

Create AI-ready prompts

How do I turn a task into a prompt my builder can execute?

Open a task and Zagvo writes a prompt that carries the project context, the specific outcome, and the constraints. Paste it into your builder without editing the intent.

What you’ll learn

  • What separates a buildable prompt from a wish
  • Why context beats cleverness
  • How to adapt a prompt for a different builder
Who this is for:
Anyone about to paste something into an AI builder.
Prerequisites:
A roadmap with at least one task.
Beginner5 min readGetting Started

Track progress

How do I keep track of what is done and what is next?

Mark tasks complete as you finish them. Zagvo uses that signal to advance phases, update your timeline, and decide what to recommend next.

What you’ll learn

  • What 'done' should mean for a task
  • How the timeline records what happened and when
  • How progress changes the guidance you receive
Who this is for:
Builders mid-project.
Prerequisites:
An active roadmap.
Beginner4 min readGetting Started

Prepare for launch

How do I know my product is ready to launch?

Launch readiness checks the things people forget under deadline pressure: accounts, payments, error states, data safety, and a working destination URL.

What you’ll learn

  • The readiness categories and why each one exists
  • How to interpret a partially complete checklist
  • What is genuinely blocking versus merely nice to have
Who this is for:
Builders approaching a first release.
Prerequisites:
A product that runs end to end.
Intermediate7 min readGetting Started

Browse

Documentation categories

Every hub collects the guides for one part of building software with AI, from first idea to post-launch.

Getting Started

8 guides

Create your first project, understand the workflow, and get to a roadmap in one sitting.

Core Concepts

7 guides

The ideas Zagvo is built on: projects, phases, tasks, prompts, memory and readiness.

Planning

6 guides

How to turn a vague idea into a scope you can actually build without rewriting it twice.

Roadmaps

5 guides

How Zagvo structures work into phases, why order matters, and how to adjust a plan mid-build.

Tasks

5 guides

Working task by task, marking progress, and knowing when something is genuinely done.

AI-ready Prompts

6 guides

What makes a prompt buildable, how Zagvo writes them, and how to adapt them per builder.

Memory

4 guides

How project context is retained across sessions so you stop re-explaining your product.

Launch Readiness

5 guides

The checks that matter before you put software in front of real users.

Projects

4 guides

Managing more than one product, switching between them, and keeping each one coherent.

Builder Integrations

7 guides

Using Zagvo alongside Lovable, Cursor, Claude Code, Bolt, Replit, Windsurf and Emergent.

Account & Billing

4 guides

Plans, invoices, entitlements, and what happens when you upgrade or cancel.

Pricing

3 guides

How pricing works, what is included on each plan, and how usage is counted.

Templates

3 guides

Starting from proven blueprints instead of a blank page.

Best Practices

7 guides

Habits that separate builders who ship from builders who keep restarting.

Troubleshooting

7 guides

What to do when the plan, the prompt or the builder goes sideways.

API

Coming soon

Programmatic access to projects, roadmaps and prompts.

Popular topics

  • Roadmaps
  • Prompts
  • MVP scope
  • Lovable
  • Cursor
  • Memory
  • Launch readiness
  • Billing

Recently updated

  • Preparing for launch — 2026-07-25
  • Understanding project memory — 2026-07-25
  • Common beginner mistakes — 2026-07-25
  • How to switch builders — 2026-07-25
  • Planning before coding — 2026-07-25
  • How to structure an MVP — 2026-07-25

Most viewed

  • How Zagvo works — 7 min
  • How to build your first SaaS — 12 min
  • Choosing between Lovable and Cursor — 9 min
  • How AI-ready prompts work — 8 min
  • How to structure an MVP — 10 min

Featured

The ten guides people read most often, each answering one question directly before explaining the reasoning behind it.

How Zagvo works

How does Zagvo work under the hood?

Zagvo holds the thinking layer — understanding, planning, context and review — while your AI builder holds the making layer. The handoff between them is a prompt carrying full project context.

What you’ll learn

  • The separation between planning and building
  • What Zagvo remembers between sessions
  • Why that separation reduces wasted builder credits
Who this is for:
Anyone evaluating whether Zagvo fits their workflow.
Prerequisites:
None.
Beginner7 min readCore Concepts

How to build your first SaaS

What is the right order to build a SaaS product with AI?

Accounts, then the single core action, then persistence, then billing, then polish. Building billing before the core action is the most common and most expensive ordering mistake.

What you’ll learn

  • A dependency-correct build order for a subscription product
  • Which features to deliberately postpone
  • How to test each layer before stacking the next one
Who this is for:
Founders building a multi-user paid product.
Prerequisites:
A clear idea of who pays and for what.
Intermediate12 min readPlanning

Choosing between Lovable and Cursor

Should I use Lovable or Cursor?

Lovable suits building a new web product from a description without managing a codebase. Cursor suits working inside code that already exists, with fine-grained control.

What you’ll learn

  • The honest trade-offs of each, including the popular one
  • Signals that you picked the wrong one
  • How to move a project between them without losing the plan
Who this is for:
Builders deciding between prompt-first and editor-first tools.
Prerequisites:
None.
Beginner9 min readBuilder Integrations

How AI-ready prompts work

What makes a prompt AI-ready?

An AI-ready prompt states the outcome, the context it fits into, the constraints, and what must not change. Vague prompts produce plausible code that solves the wrong problem.

What you’ll learn

  • The four components of a buildable instruction
  • Why 'do not change X' is as important as 'add Y'
  • How context from earlier tasks is carried forward
Who this is for:
Anyone whose builder keeps producing near-misses.
Prerequisites:
Some experience prompting an AI builder.
Intermediate8 min readAI-ready Prompts

How to structure an MVP

What belongs in an MVP and what does not?

An MVP contains the shortest path to the value your user came for, plus whatever is required to deliver it safely. Everything else is version two.

What you’ll learn

  • How to identify the single core loop
  • A test for cutting a feature without regret
  • Why 'minimum' is about scope, not quality
Who this is for:
Builders whose plan keeps growing.
Prerequisites:
None.
Beginner10 min readPlanning

Planning before coding

Why plan when an AI builder can just start building?

Because AI builders are fast at producing code and slow at recovering from the wrong architecture. Ten minutes of planning routinely saves hours of regeneration.

What you’ll learn

  • The specific failures that planning prevents
  • How much planning is enough before the first build
  • How to plan without stalling
Who this is for:
Builders who prefer to start immediately.
Prerequisites:
None.
Beginner6 min readBest Practices

How to switch builders

Can I change AI builders mid-project?

Yes. The plan, context and history live in Zagvo, not in the builder, so switching means regenerating prompts in the new builder's idiom rather than starting over.

What you’ll learn

  • When switching is the right call and when it is avoidance
  • What transfers cleanly and what does not
  • How to carry existing code across
Who this is for:
Builders hitting a ceiling with their current tool.
Prerequisites:
An in-progress project.
Intermediate7 min readBuilder Integrations

Common beginner mistakes

What do first-time AI builders get wrong most often?

Building features before deciding the core loop, prompting without context, and treating a running prototype as a finished product. All three are recoverable if caught early.

What you’ll learn

  • Nine mistakes, each with the fix
  • The warning signs that appear before each one
  • How to audit a project you have already started
Who this is for:
Anyone in their first few AI-built projects.
Prerequisites:
None.
Beginner8 min readBest Practices

Understanding project memory

What does Zagvo remember about my project?

Decisions, constraints, the shape of your product, and what you have already built. That memory is what stops you re-explaining your product at the start of every session.

What you’ll learn

  • What gets stored and what does not
  • How decisions are captured from conversations
  • How to correct memory when your direction changes
Who this is for:
Builders returning to a project after a break.
Prerequisites:
An existing project.
Intermediate7 min readMemory

Preparing for launch

What should I check before launching?

Sign-up and sign-in, the core action end to end, payment if you charge, error and empty states, data handling, and a reachable public URL.

What you’ll learn

  • A pre-launch checklist you can work through in an afternoon
  • Which failures users forgive and which they do not
  • How to verify the destination before announcing it
Who this is for:
Builders within a week of shipping.
Prerequisites:
A working product.
Intermediate9 min readLaunch Readiness

Guided journeys

Learning paths

If you are not sure what to read next, pick the path that matches where you are today. Each one is a sequence, not a menu.

Never built software before

You have an idea and no engineering background. This path takes you from concept to a launched first version without assuming you know what a database is.

6 steps · ~42 min total

  1. 1
    Understand the basics

    What an AI builder does, and what it cannot do for you.

  2. 2
    Describe your idea well

    The one paragraph that determines the quality of everything after it.

  3. 3
    Create your first roadmap

    Turn the idea into ordered phases you can actually work through.

  4. 4
    Generate prompts

    Convert the first task into something your builder can execute.

  5. 5
    Build

    Work task by task, verifying each one before moving on.

  6. 6
    Launch

    Run the readiness checks and put it in front of real people.

Already using an AI builder

You can already get a prototype running. This path is about stopping the rebuild loop and turning prototypes into products.

4 steps · ~31 min total

  1. 1
    Add a planning layer

    Why your builder keeps solving the wrong problem confidently.

  2. 2
    Use Zagvo alongside your builder

    Where the handoff happens and what crosses it.

  3. 3
    Generate better prompts

    Context-carrying instructions instead of one-line requests.

  4. 4
    Improve your workflow

    Habits that reduce regeneration and credit burn.

Professional developer

You do not need help writing code. This path is about scoping, sequencing and keeping AI-assisted work coherent across sessions and teammates.

4 steps · ~29 min total

  1. 1
    Project planning

    Dependency-correct phasing that survives contact with reality.

  2. 2
    Builder integration

    Fitting Zagvo around Cursor, Claude Code or Windsurf.

  3. 3
    Context discipline

    Durable decisions instead of chat history archaeology.

  4. 4
    Launch readiness

    The operational checks before a production release.

Integrations

Builder documentation

Zagvo is builder-neutral. Each hub covers how that tool prefers to be prompted, what it handles well, where it struggles, and how the plan hands off to it.

Comparing tools rather than reading about one? Read the AI builders guide.

Craft

Best practices

The habits that separate builders who ship from builders who keep restarting. None of these are specific to Zagvo.

How to write a good idea

How should I describe my idea so AI understands it?

Name the user, the problem, and the moment they would use it. Skip the feature list — features are an output of planning, not an input.

What you’ll learn

  • A three-sentence template that works
  • Why feature lists mislead planning
  • Examples of weak and strong descriptions
Who this is for:
Everyone, at the start of every project.
Prerequisites:
None.
Beginner5 min readBest Practices

How to scope an MVP

How small should a first version be?

Small enough to finish in weeks, complete enough that one user can get real value without you in the room.

What you’ll learn

  • The one-user completeness test
  • How to defer without losing the thread
  • Scope creep warning signs
Who this is for:
Founders and indie builders.
Prerequisites:
A described idea.
Beginner6 min readBest Practices

Common AI prompting mistakes

Why does my AI builder keep producing the wrong thing?

Usually because the prompt described a feature without describing the system it lives in. Models fill missing context with confident guesses.

What you’ll learn

  • Six recurring prompt failures
  • How to phrase constraints
  • When to start a fresh session instead of correcting
Who this is for:
Anyone prompting daily.
Prerequisites:
None.
Intermediate7 min readBest Practices

How to avoid rebuilding features

How do I stop my builder from breaking what already works?

State explicitly what must not change, work in small verifiable increments, and confirm each increment before starting the next.

What you’ll learn

  • Protective phrasing for prompts
  • Increment sizing
  • Recovering from a destructive change
Who this is for:
Builders past the prototype stage.
Prerequisites:
A project with working features.
Intermediate6 min readBest Practices

How to plan software properly

What does a good software plan contain?

Ordered phases with dependencies made explicit, a definition of done per task, and named risks. Anything else is a wish list.

What you’ll learn

  • Dependency-first sequencing
  • Writing a definition of done
  • Naming risks early
Who this is for:
Anyone responsible for delivery.
Prerequisites:
None.
Intermediate9 min readBest Practices

How to collaborate using AI

How does a team work on one AI-built project?

Share the plan, not the chat. When the roadmap and decisions are the shared artefact, two people can work without duplicating or contradicting each other.

What you’ll learn

  • Splitting work by phase
  • Keeping decisions in one place
  • Avoiding contradictory prompts
Who this is for:
Small teams and co-founders.
Prerequisites:
A shared project.
Intermediate6 min readBest Practices

How to launch confidently

How do I launch without dreading the first user?

Walk your own product as a stranger would, on a device you did not build it on, before anyone else does.

What you’ll learn

  • A cold-walkthrough script
  • The five states people hit first
  • What to monitor on day one
Who this is for:
Builders about to announce.
Prerequisites:
A deployed product.
Beginner5 min readBest Practices

When things go wrong

Troubleshooting

Every one of these is normal and recoverable. What matters is diagnosing the cause before prompting again.

My roadmap is too large

Usual cause: The idea description contained a product vision rather than a first version.

  1. Identify the single action a user must be able to complete.
  2. Move every phase that does not serve that action to a later stage.
  3. Regenerate the plan with the narrowed scope stated explicitly.

My builder generated incorrect code

Usual cause: The prompt described the feature but not the system it has to fit into.

  1. Describe the observable wrong behaviour, not your theory about the cause.
  2. Restate the surrounding context and what must not change.
  3. Ask for the smallest correction rather than a rewrite.

The prompt is not producing the expected output

Usual cause: Missing constraints, or an outcome stated as an adjective rather than a behaviour.

  1. Replace adjectives like 'better' with a specific end-state.
  2. Add the acceptance checks to the prompt itself.
  3. If two attempts fail, start a fresh session with full context instead of a third correction.

My project changed direction

Usual cause: You learned something real. The plan needs to catch up, not be abandoned.

  1. Record the new decision so it becomes part of project memory.
  2. Re-scope the remaining phases against the new direction.
  3. Keep completed work that still serves the new goal; archive the rest deliberately.

I need to switch builders

Usual cause: The current tool is a poor fit for what the project has become.

  1. Confirm it is a fit problem, not a prompting problem.
  2. Export or keep the existing code accessible before moving.
  3. Regenerate prompts in the new builder's idiom from the same plan.

I lost context

Usual cause: The conversation history in your builder was truncated or a session ended.

  1. Return to the project plan — it is the durable record, not the chat.
  2. Re-open the current task to regenerate a context-carrying prompt.
  3. Confirm the decisions in memory still match reality before continuing.

Everything is broken and I want to restart

Usual cause: Several small unverified changes accumulated into an unclear state.

  1. Stop prompting. Write down what currently works and what does not.
  2. Roll back to the last state you trusted, if your builder supports it.
  3. Rebuild forward one verified increment at a time.

FAQ

Documentation questions

Questions about the documentation itself — how it is organised, who it is for, and how to find what you need.

Still have questions?

The fastest way from a question to an answer is usually to start the project. Describe your idea and let Zagvo build the roadmap.