> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mythos.new/llms.txt
> Use this file to discover all available pages before exploring further.

# Building and editing

> How Mythos turns a plain-language prompt into a real git commit — what a build costs, what an edit costs, the progress card, and Build vs Plan mode.

Every time you prompt Mythos, it runs an agent that writes real code and saves it as a **git commit**.
Mythos keeps each project in a private repository and builds it commit by commit. A new project
scaffolds a whole app from your description; an edit changes the app you already have — each result is
committed source you can publish, open in the editor, or export to your own GitHub.

The mental model: **one prompt → one agent run → one commit.** A new build and an edit are the same
pipeline; they differ only in what the agent starts from.

<Note>**Cost:** building a new project costs **3 credits**; an edit costs **2**. New accounts start
with **5 free credits**, and a failed build is refunded in full. See
[Credits & pricing](/introduction/credits-and-usage).</Note>

<Note>**Build mode vs Plan mode.** In **Build mode** Mythos builds straight from your prompt. In
[Plan mode](/features/plan-mode) it asks a few questions, shows a handful of design directions, and
gets a short plan approved *before* writing any code. Planning is free — you spend credits only when
the build runs. Toggle the mode next to the composer.</Note>

## Why it works this way

* **Real output, not a demo.** Each build is committed code in a private repo, so you can keep
  iterating, publish it, or take it with you.
* **Edits are cheap and incremental.** Changing an existing project costs less than a fresh build and
  only touches the files that need to change.
* **A failed build costs nothing.** If a generation can't deliver, you get a plain message and a full
  refund — you are never charged for a result you didn't get.

## How a build runs

<Steps>
  <Step title="Describe what you want">
    Type your prompt in the composer. For a new project, describe the app — its sections, tone, and
    any data it should handle. For an edit, describe the change.
  </Step>

  <Step title="Mythos seeds the workspace">
    A new build starts from a starter template (Vite + React or Next.js 16). An edit starts from your
    project's current files. Either way the agent gets a working file tree to build on.
  </Step>

  <Step title="The agent writes code">
    The agent reads, writes, and edits files to satisfy your prompt. The live progress card shows it
    working — this is the step that takes real time.
  </Step>

  <Step title="The result is committed">
    When the agent finishes, the changed files are committed to your project's repo and the preview
    updates. A new build is one commit on a fresh repo; an edit is a new commit on top of your
    history.
  </Step>
</Steps>

## The live progress card

While a build runs, a card in the chat shows live progress so you know it's working rather than stuck.
A generation always reaches exactly one of two ends — a delivered result or a clean refund.

| State         | What you see                                          | What you do                                        |
| ------------- | ----------------------------------------------------- | -------------------------------------------------- |
| **Building**  | A live progress card in the chat                      | Wait — a build typically finishes in a few minutes |
| **Delivered** | A result card with a preview                          | Open the preview, then iterate or publish          |
| **Refunded**  | A short "something went wrong" message + credits back | Re-prompt; you were not charged                    |

<Note>The technical reason for a failure is recorded for support, but the message you see stays plain
and human. You never see a raw error string in the chat.</Note>

## New project vs edit

|                 | New project                      | Edit                              |
| --------------- | -------------------------------- | --------------------------------- |
| **Cost**        | 3 credits                        | 2 credits                         |
| **Starts from** | A starter template               | Your project's current files      |
| **Result**      | A full app in a new private repo | A new commit on the existing repo |
| **When to use** | Building something from scratch  | Changing an app you already have  |

## Example prompts

A clear first prompt for a **new project**:

```
Build a landing page for a small coffee roastery called Ember & Oak.
Sections: hero with a tagline, our story, three featured roasts with prices,
a wholesale enquiry form, and a footer with social links. Warm, earthy palette.
```

An **edit** prompt on an existing project:

```
Add a second pricing tier called Team at $49/month between the existing
Starter and Enterprise cards, and make the Team card the highlighted one.
```

<Tip>Describe the sections, tone, and any data model in your first prompt. Getting there in one build
instead of three saves credits. See [Writing good prompts](/prompting/writing-good-prompts).</Tip>

## Limitations & good to know

* In **Build mode** Mythos builds from your prompt and only asks a clarifying question if the brief is
  genuinely ambiguous. If you want it to ask questions and show design options up front, use
  [Plan mode](/features/plan-mode).
* Edits apply to the project's **current state**. To change something, edit the latest version, not
  an older one — though you can always [revert to an earlier version](/features/version-history) first.
* A run has a time budget. If it can't finish in time, Mythos tries to salvage a complete result; if
  it still can't deliver, you get a clean refund rather than a half-built app.
* Mythos builds **frontend** apps. To save form submissions or other data, connect your own Supabase
  backend.

## Troubleshooting

| Problem                              | Fix                                                                                     |
| ------------------------------------ | --------------------------------------------------------------------------------------- |
| The build came back refunded         | Nothing was charged. Re-prompt — often a slightly clearer or shorter prompt succeeds.   |
| The result isn't what you described  | Send a follow-up edit naming exactly what to change. Edits are cheaper than rebuilding. |
| You wanted it to ask questions first | Turn on [Plan mode](/features/plan-mode) before sending the prompt.                     |

## FAQ

<AccordionGroup>
  <Accordion title="What's the difference between a build and an edit?">A build creates a new project from a starter template (3 credits). An edit changes an existing project (2 credits). Both end in a git commit.</Accordion>
  <Accordion title="Is each result really committed code?">Yes. Every build and edit is a real git commit in the project's private repository — not a throwaway preview. Connect your GitHub account to export it to your own GitHub anytime.</Accordion>
  <Accordion title="What happens if a build fails?">You get a plain message and a full refund. You are only ever charged for a build that delivers a result.</Accordion>
  <Accordion title="Should I use Build mode or Plan mode?">Use Build mode to build directly. Use Plan mode when you want to answer a few questions and pick a design direction before any credits are spent.</Accordion>
  <Accordion title="How long does a build take?">Usually a few minutes — a fresh scaffold is the slowest. The live progress card shows it working the whole time.</Accordion>
</AccordionGroup>

## Related

* [Plan mode](/features/plan-mode) — question, design, and plan before building.
* [Version history](/features/version-history) — every build and edit is a commit you can revert to.
* [Workspace editor](/features/workspace-editor) — hand-edit the files a build produced.
* [Credits & pricing](/introduction/credits-and-usage) — what builds and edits cost.
* [Writing good prompts](/prompting/writing-good-prompts) — fewer edits, fewer credits.