---
title: Prompting tips | FLORA API
description: How to ask any MCP-compatible agent to use FLORA effectively.
---

These prompting patterns work across any MCP-compatible agent — Claude, Cursor, VS Code, Hermes Agent, OpenClaw, and others. The agent and the model behind it may differ, but the FLORA MCP surface is the same.

## Name the Technique if you know it

Vague: *“Make me some thumbnails.”*\
Better: *“Use the Thumbnail v3 Technique to make 3 thumbnails for this brief.”*

Skipping discovery saves a tool call and removes ambiguity. If you don’t remember the name, ask: *“What thumbnail Techniques do I have?”*

## Lead with structure

Briefs work best when they’re skimmable. Agents map fields onto Technique inputs more reliably when the structure is explicit.

```
Run the Thumbnail v3 Technique with:
- Audience: 25-40, design-conscious
- Hook: "Smart living, simple"
- Do: warm minimalism, soft shadows
- Don't: clip-art, gradients


Give me a 3×3 grid.
```

## Reference prior outputs by number

After a grid renders, refer to outputs by their position: *“Use #4 and #7 as references”*, *“Make 5 more like #2”*. The agent resolves these to the underlying URLs and passes them as inputs to the next call.

## Ask for inspection before kicking off big runs

For batches, run cost adds up. Ask the agent to confirm cost first:

> Before running this for 50 SKUs, tell me the cost per run and the total in USD.

The agent will call `client.techniques.retrieve(techniqueId)` and report the `run_cost`, multiplied by your batch size.

## Switch surfaces explicitly

Most agents pick the right surface automatically (inline chat for fast iteration, background mode for long jobs, a code editor for batches). You can override:

- *“Do this in the background — I want to keep working.”*
- *“Stay inline — I want to watch each one render.”*
- *“Open this in a code editor — I want to see the script.”*

The exact terminology varies by client (Claude’s “Cowork”, Cursor’s “agent run”, VS Code’s “agent mode”) — say what you want in plain English and the agent translates.

## Be specific about output count and shape

Vague: *“Make some variations.”*\
Better: *“Make 5 variations, 1:1 aspect ratio, lock the color palette of #4.”*

Techniques expose count, aspect ratio, and reference-locking as inputs. Naming them in your prompt sets them directly.

## Tell the agent when to stop

For exploratory work, set a stop condition so you don’t accidentally chew through your balance:

- *“Run the Technique 3 times, then stop and ask me what to do next.”*
- *“For each market, generate one thumbnail. Stop after the first three and show me before continuing.”*

## When something looks off

The agent can re-run with adjustments. The fastest way to course-correct:

- *“#3 has the wrong headline — re-run that one with ‘Smart living, simpler.’”*
- *“All of these are too saturated. Re-run with brand-do updated: ‘muted, low-saturation palette.’”*
- *“The Technique isn’t picking up the brand color. Show me the Technique’s inputs so we can debug.”*

## Helpful one-liners

> Show me everything FLORA MCP can do.

The agent can call `search_docs` to explore what the SDK supports, or describe the available capabilities from its context.

> What’s in my Q3 Campaign project right now?

The agent calls `client.projects.retrieve(projectId)` and `client.projects.listNodes(projectId)` and shows the contents inline.

> What did this run cost?

The agent calls `client.techniques.runs.retrieve(runId, { techniqueId })` on the most recent run and reports `charged_cost` (USD).

## Review and resume past runs

Both Technique runs and one-off generations keep a history you can query — newest first, filterable by workspace, project, and status. Because that history survives across sessions, you can close the chat on a long job and pick it back up later.

- *“Show me my last 5 Technique runs.”* → the agent calls `client.techniques.runs.list({ limit: 5 })`.
- *“Did the generation I started earlier finish?”* → the agent calls `client.generations.list({ status: "completed" })` and matches your `run_id`.
- *“Poll the run I kicked off an hour ago and show me the result.”* → the agent lists recent runs, finds yours, and renders the outputs once `status` is `completed` — no need to keep the original chat open.
- *“Re-attach this morning’s output to the Q3 project.”* → the agent lists history to find the run, then calls `client.projects.assets.attachAsset(...)`.

This is also how the agent polls a generation: generations are listed and matched by `run_id`, rather than polled individually.

## What FLORA MCP can’t do (today)

- **No streaming inside a single run.** Outputs render when each run completes, not progressively. Multi-output runs (grids) appear tile-by-tile.
- **No webhooks.** All result-checking happens by polling.
- **No editing assets in place.** To modify an asset, run it through a Technique that produces a new asset.

These limitations match the [API](/index.md) — anything you hit in MCP, you’d also hit calling the REST endpoints directly.