---
title: How to ask
summary: The habits that turn a prompt into publishable work instead of a plausible guess, with a real ask taken apart clause by clause.
lede: What separates publishable work from a plausible guess
eyebrow: Best practice
accent: arc
order: 0
---

You do not call tools. You describe the finished thing, and your agent drives GroundSlate to build it. The more precise the description, the better the work.

## A real ask, clause by clause

> Create a 10 minute video in GroundSlate, 5 to 10 seconds per clip of p394 (Bob Murphy) in different locations around the world. Lower third in Montserrat, white text on black with blue and purple accents, animate each location in. Use fill and make sure they are the right orientation. Keep him centred. Colourful wipes and transitions. Generate backing music with ducking for anything fun he says. Upper right, add his age at the date each clip was shot. He was born January 1, 2012. YouTube safe titles.

Every clause does work:

| The clause | What it decides |
| --- | --- |
| `p394 (Bob Murphy)` | The person id, so the agent picks the right Bob. |
| 10 minutes, 5 to 10 seconds per clip | Total length and clip length, so the planner has both limits. |
| different locations around the world | The selection rule: variety of place, not the most recent clips. |
| use fill | Scale to fill and centre crop, no letterbox bars. |
| right orientation | A fixed canvas, so mixed horizontal and vertical footage is normalised, not stretched. |
| keep him centred | The crop follows his face in every clip, through `reframe_person`, not the middle of the frame. |
| Montserrat, white on black, blue and purple | Just enough of the overlay spec to build it. |
| animate each location in | Overlay timing comes from the cut plan, not typed by hand. |
| colourful wipes and transitions | Rendered camera moves between clips from GroundSlate's transition catalogue, instead of hard cuts. |
| generate backing music | An instrumental bed made on your Mac from the brief, laid under the voice and ducked. Name instruments, tempo, mood and arc; a genre alone gets you a generic track. |
| ducking for anything fun he says | The bed is keyed to the clip's own audio, so the compressor finds those moments. |
| his age at the date each clip was shot | Worked out per clip from the capture date and the birthday. |
| YouTube safe titles | The deliverable is more than the file. |

Two of those patterns belong in every ask you write.

**A rule instead of a list.** "Different locations around the world" is a rule the planner can apply to eight hundred clips. Picking the clips yourself is slower and makes a worse cut.

**Data that becomes graphics.** "His age at the date each clip was shot" is arithmetic on metadata the library already holds, put on screen. Anything a clip knows about itself can go in a corner of the frame the same way: the city, the camera, the time since the first clip, how many people are in shot.

The whole ask is broken down tool by tool in [One person, every place, ten minutes of it](/resources/groundslate/recipes/one-person-many-places).

## Describe the result, not the machinery

A detailed ask is not a technical one. Do not name tools, parameters or settings. Your agent already knows them. What it cannot know is what you want.

So instead of "fill and centre crop on the tracked subject", say **"fill the frame rather than letterbox, and keep Bob centred even when the footage is vertical"**. Instead of "cut on the section boundaries in the phrase grid", say **"cut where the music changes phrase, not on every beat, so it breathes"**.

Those are more specific than the technical versions, because they describe the result instead of the lever. If there are two ways to get there, the agent can pick the better one. If you name the lever, it cannot.

Read your ask out loud. It should sound like something you would say to a good editor who works very fast, not like a config file.

## Say GroundSlate

You always talk to your agent, never to GroundSlate directly. The agent does the thinking. GroundSlate is the library and toolkit it drives over MCP, and it only does what the agent asks. Naming GroundSlate sends your agent to the place where your transcripts, face catalog and render engine are. Leave it out and the agent may reason about your footage instead of looking at it.

Instead of *make a 9:16 version of the interview*, say *make a 9:16 version of the interview at the beach from my GroundSlate library*.

## The ids in a recipe are placeholders

Ids like `p394` (a person), `beach-day-1a2b3c4d` (a clip), `evt_5d6e7f8a9b` (an event), `prj_0a1b2c3d4e` (a project) and `av_4d5e6f7a` (an avatar) are placeholders, in the same format the app's Copy for AI gives you. Swap in your own.

Use the id rather than the name whenever you have one. `search_people` turns "Mila" into her record, `search_events` and `search_projects` do the same for events and projects, and every tool after that wants the id. Otherwise, two people called Bob is a problem you find at the render.

Paths are the fragile way to name a clip. A path containing a non-ASCII character does not survive being retyped from another result, and the tools will tell you so rather than guess. Most tools also accept a clip id, a filename or a bare stem.

## Name the format

Duration, aspect ratio, frame rate, destination. "1080x1920 at 30fps, to the Desktop" leaves nothing to guess. When GroundSlate draws the frames itself, it uses the frame rate you name. When cutting real footage, your agent sets the rate as it extracts, so clips from mixed cameras come out at one rate instead of the default.

## Only what you name goes on screen

Left alone, an agent decorates video the way it decorates a slide deck: slide numbers, section labels, a caption naming the chart, a footer on every scene. That text is the model labeling the page for itself, and nothing makes a film look undesigned faster.

Say what the overlay holds, then add "and nothing else on screen". Everything on screen should be content you chose: a name, a place, a number.

## Name people

Once the People catalog knows a face, "the shots with Mila in them" is a lookup, not a guess. If it does not know them yet, spend half an hour naming people first. Nothing else in the app pays off as much.

## Name the pacing rule

"Nothing longer than six seconds." "Cut on the section boundaries." "Hold the establishing shot for four." "No shot where the camera is still moving at the cut."

A rule the plan can follow beats a mood it has to interpret. The shot log already records camera movement, shot size and who is in shot, so rules like these are cheap to enforce and save twenty rounds of "not that one".

## Read the plan before the render

The planners return a running order before anything renders: `quick_cut_plan`, `produce_reel` and `make_highlights` return a plan and write no media. The renderers (`render_sequence`, `render_concat`, `render_html` and `render_composition`) encode whatever they are given. So ask for the plan first, as a list with durations.

It takes ten seconds to read, and nothing has been encoded yet, so it is the cheapest moment to change your mind.

## Check the pacing on a rough one

A rough render has the same frames at the same rate as a finished one. Only the compression differs, so you can judge timing, easing and whether the cuts land on the music.

Ask for a rough one first, then render properly once. Across a run of forty videos, that habit saves hours.

## Ask it to look at the frames

Your agent can pull real frames out of GroundSlate: from a composition it is still writing, before anything encodes, and from the file it just rendered. A filename tells it nothing. A frame shows the wrong typeface, the clipped line, the overlay on the wrong shot.

End a render ask with "sample the output and tell me what you see", and you skip the round where you watch it and describe the fault yourself.

## Let the long jobs run

Indexing, transcription and renders run in the background. A reframe counts as a render: `reframe_person` queues one, while `make_reframe` only plans one and `render_ffmpeg` runs that plan as a job. Ask to be told when they finish, and your agent will get on with the next part meanwhile.

## Correct once

A name, a place, a trim, a look: each correction writes back to the library, and every later cut inherits it.

Fix a mistake in the library, not in the output, and it stays fixed.

## Give it your vocabulary

Before you index a big batch, tell your agent what it is about to see: who the people are, what the place is, what the objects are called.

A single frame cannot tell the model that the pan is a kadai. Two sentences from you improve the tagging on everything indexed afterwards. If your library's tags read as generic, this is usually why.