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

# Draft a full deck

> Give Pretty a brief and it plans the deck, then builds it slide by slide on your template.

Open the deck whose master you want the output to inherit (your firm's template, or any deck
already on brand) and describe the whole thing in one message. Pretty writes a plan, then works
down it one slide at a time.

## What happens after you send a brief

<Steps>
  <Step title="It plans">
    A **Planning steps** row appears with a task list, roughly one task per slide, named by what
    that slide has to do. Tasks move through pending, in progress, completed.
  </Step>

  <Step title="It builds one slide at a time">
    For each task you will see the same short cycle: a **PowerPoint** row writing shapes into
    your deck, a **Snapshot** row where Pretty looks at what it just made, and often a
    **Reviewing design** row where it critiques the result.
  </Step>

  <Step title="It fixes before moving on">
    Overflowing text, a collision, a column that does not line up. Pretty catches most of these
    on its own snapshot and corrects them before starting the next slide.
  </Step>
</Steps>

Because it finishes each slide before starting the next, you can read the deck as it lands rather
than waiting for the whole run.

## What to put in the brief

The plan is only as good as the brief. Five things carry most of the weight.

| Give it               | Why it matters                                                                        |
| --------------------- | ------------------------------------------------------------------------------------- |
| **Audience**          | Board, prospect, internal team. Sets tone, density, and how much you have to explain. |
| **The argument**      | The one thing you want them to believe. Without it you get a summary, not a case.     |
| **Section structure** | Your running order beats one it invents. Name the sections.                           |
| **Length**            | A slide count anchors the plan. "Twelve slides" produces roughly twelve tasks.        |
| **Source material**   | Attach the reports, transcripts and numbers you want it to work from.                 |

<Tip>
  If you already have approved slides for this kind of deck, upload them as a
  [slide pool](/slide-pools/overview) first. Pretty will search those layouts and reuse them
  rather than inventing a structure from scratch.
</Tip>

## A worked example

```text theme={null}
Build a 12-slide board update for our Q3 review. Audience is our board -
three investors and two independent directors. They know the business, so
skip the company intro and be dense.

The argument: growth slowed in Q3 because we under-hired in sales, not
because demand softened, and the fix is already underway.

Structure:
1. Title
2. Executive summary - three takeaways, one line each
3. Q3 vs plan - revenue, net new logos, churn against target
4. Where the gap came from - quota capacity vs pipeline
5. Demand is intact - pipeline coverage and win rate by quarter
6. Hiring plan and ramp timeline
7-9. One slide per product line, same layout each time
10. Cash and runway
11. Risks - three, with the mitigation next to each
12. What we need from the board

Use the numbers in the attached Q3 board pack. Do not invent any figure
that is not in it. Where the pack disagrees with itself, say so on the
slide rather than picking one.
```

Copy two habits from that brief: name the repeated layout ("same layout each time"), and tell
Pretty what to do when the source is ambiguous.

## Steer it while it runs

You do not have to wait for the run to finish.

* **Send a correction now.** Type and send while it is working. The message shows as **Queued**,
  and Pretty picks it up at the next step. **Send now** pushes it in sooner; **Dismiss** drops it.
* **Point at something.** Select shapes on a slide it already built, then send. The composer
  shows a selection badge and the agent works on exactly those shapes.
* **Answer its questions.** If the brief is ambiguous, an **Asking you** row appears with two to
  four options plus a free-text **Other**. Answering is faster than letting it guess.

Useful mid-run corrections:

```text theme={null}
Stop using the icon row on the product slides. Same layout, but replace
the icons with the metric in large type.
```

```text theme={null}
Slide 4 is the whole argument. Give it a full slide of its own and move
the supporting table to slide 5.
```

## Stop and restart

**Stop generation** in the composer halts the run. Slides already written stay in your deck.
Pretty only rolls back a step that failed part-way, not work that finished.

To restart, send a new message in the same chat. Pretty still has the plan and the slides it
built, so "carry on from task 7" works. Start a **New Chat** instead when you want a clean slate,
or when the deck has changed direction enough that the old plan is noise.

<Note>
  Long runs use a lot of context. Pretty compacts the conversation automatically. You will see
  **Compacting…** and a note that older messages were summarized. See
  [Context and compaction](/chat/context).
</Note>

## Where the content comes from

A brief with no source material gets you structure and prose, not facts. Two ways to ground it:

<Columns cols={2}>
  <Card title="Your own documents" icon="file-lines" href="/slides/research">
    Attach the board pack, the transcript, the model. Pretty reads them and builds from what is
    actually in them.
  </Card>

  <Card title="Live web research" icon="globe" href="/slides/research">
    Ask it to research a market or a competitor and it adds a **Sources:** footer to the slides
    that came out of that research.
  </Card>
</Columns>