# Prompts to try

> Ready-to-copy prompts for Claude, ChatGPT and other assistants connected to odo: what’s working, what’s leaking, heatmaps, posts, tests, changes and earnings.

Copy one into Claude, ChatGPT or any assistant [connected to odo](https://odo.gg/docs/mcp). Each names a range, says what to compare and asks for the numbers behind the answer, so the assistant reaches for the right tools and you can check what it says. Change the paths, names and ranges to yours.

With several projects, add *in the project Shop* (or its id): without one, odo reads all of your own projects together.

Most work in [Ask odo](https://odo.gg/docs/ask-odo) too, the chat with Claude in odo’s dashboard, where the project on screen is already chosen. It makes at most 12 lookups for one question, so split the longest prompts in two there.

## Find what’s working

**Channels and sources by money per visitor.** Leans on `get_channels` and `breakdown`.

```prompt
Over the last 30 days, which channels and sources bring the visitors worth the most money? Use odo: revenue per visitor by channel, then by source, leaving out sources with fewer than 50 visits. For the top three and the bottom three, give visitors, conversion with its 95% range, revenue and revenue per visitor. Say which differences are real and which rest on too few buyers to mean much.
```

**Landing pages that sell.** Leans on `analyze_pages`, `breakdown` and `analyze_page`.

```prompt
Over the last 90 days, which landing pages bring the most money per visitor? Use odo to rank the pages visits start on (at least 100 visits each) by revenue per visit. For the top five, give entries, bounce rate, conversion with its 95% range, lift over the site average, and revenue. Then look at the best one up close and tell me what its visitors do that other visitors don't.
```

**What buyers have in common.** Leans on `analyze_conversions` and `get_customer_journeys`.

```prompt
Over the last 90 days, what do the visitors who paid have in common? Use odo to compare conversion by channel, source, campaign, landing page, device, country and new or returning, with 95% ranges, and the pages and events buyers see far more than others. Then open the journeys of the five latest customers. Tell me where to focus, what to stop doing, and how sure each point is.
```

## Fix what’s leaking

**Where buyers drop off.** Leans on `analyze_funnel` and `get_funnels`.

```prompt
Over the last 30 days, where do visitors drop out on the way to buying? Use odo to follow these steps in order: /, /pricing, /signup (change them to my site’s main path; an event like Signup works as a step too), broken down by device. For each step, give how many continued, the share kept from the step before and the median time between steps, and where those who stopped went next. Name the step that loses the most people, and whether it’s worse on mobile.
```

**What frustrates visitors.** Leans on `find_friction`, `analyze_errors`, `analyze_forms` and `get_visit`.

```prompt
What’s broken or frustrating on my site over the last 7 days? Use odo to list it worst first: script errors, rage and dead clicks, fields forms refuse, forms left unsent, and slow pages. For each, give its page, how many visitors it hit, the share of that page’s viewers, and how they converted next to the page’s other viewers. Start with anything on the pages buyers go through, and open an example visit for the worst one to show what happened.
```

**Where they stop reading.** Leans on `scroll_depth`, `page_attention` and `page_heatmap`. See [heatmaps](https://odo.gg/docs/heatmaps).

```prompt
Use odo’s heatmaps of my /pricing page over the last 30 days, phones and desktops apart: how far down half of visitors get, which parts of the page most of them never see, and what they click, with rage and dead clicks. If the plans or the signup button sit below where most visitors stop, say so with the numbers, point out anything people click that isn’t a link or a button, and suggest one change to test.
```

**Slow pages, and what they cost.** Leans on `analyze_performance`.

```prompt
Which pages are slow for real visitors over the last 30 days, and does it cost me sales? Use odo’s Core Web Vitals by page, then by device: the 75th percentile LCP, INP and CLS, and the share of poor readings. Then compare bounce and conversion of visits by how fast their landing page loaded. Rank what to speed up by visitors affected.
```

## Posts

odo reads posts by the tags of their [links for posts](https://odo.gg/docs/links-for-posts): each link’s `utm_campaign` is the post’s name, and its `utm_source` the platform. Claude’s read of each post you add by its link is on the **Links for posts** card itself: see [what each post did](https://odo.gg/docs/analysis#what-each-post-did).

**Which post made the money, and why.** Leans on `breakdown` and `get_customer_journeys`.

```prompt
Which of my posts made money over the last 30 days? Use odo to break down visits from social platforms by utm_source and utm_campaign, sorted by revenue: for each post, visitors, conversion with its 95% range, revenue, and revenue per visit against the site’s average. Then open the journeys of a few customers from the top post and tell me what they did between the post and the sale.
```

**One post against the rest.** Leans on `compare_segments`.

```prompt
Over the last 30 days, compare visitors from my post tagged utm_campaign october-hero-video with Organic Social visitors as a whole: bounce rate, pages per visit, engaged time, conversion with its 95% range and revenue per visitor, and whether each difference is beyond chance. What did this post do that the others didn’t?
```

**Posts by topic and format.** Leans on `breakdown`. It works when your links’ names say what each post was, like *pricing-walkthrough-video* or *behind-the-scenes-carousel*.

```prompt
Over the last 90 days, use odo to list every utm_campaign from social platforms with its visitors, conversion and revenue. My campaign names say each post’s topic and format: group the posts by topic, then by format, and tell me which bring buyers rather than only visitors, with how many visitors and buyers each group rests on.
```

## Experiments

odo runs experiments itself: it changes the page for each visitor’s version, or reads one your code runs, and calls it on its own. Making, starting, pausing, stopping and shipping one needs **Run experiments**, turned on when you approved the assistant (it’s off unless you do), or a key with **Experiments**: see [experiments](https://odo.gg/docs/experiments#with-an-ai-assistant). Reading them and getting suggestions doesn’t.

**What to test next.** Leans on `get_next_moves`, `analyze_pages`, `analyze_funnel` and `find_friction`.

```prompt
Find the one change most worth testing on my site. Use odo’s Next moves, then the last 30 days: pages that leak visitors (by exit rate and bounce rate), the main path to checkout as a funnel by device, and friction on pages buyers go through. Pick the biggest opportunity by visitors affected × how far below the site average they convert, and propose an experiment: the page, the control and one variant, the outcome that counts as converting, and roughly how many visitors each version needs at my current conversion rate.
```

**Versions to try.** Leans on `suggest_experiment_variants`. On the Growth plan odo’s analyst proposes the versions; otherwise the assistant proposes its own from the facts odo gives it.

```prompt
Suggest two versions to test against the headline on my /pricing page, judged by the Signup event. Use odo’s suggest_experiment_variants for the page (the element is h1, and it says “Simple pricing for every size” now), and show me each version’s exact changes, why it might win, and the page numbers behind it. Don’t create anything yet.
```

**Let odo run it, no code change.** Leans on `create_experiment` and `update_experiment`, with **Run experiments**.

```prompt
Make that a content experiment odo runs on /pricing, judged by the Signup event: the original first, then the versions we agreed, each with exactly the changes you showed me. Create it with odo’s create_experiment as a draft, read it back to me, and start it only once I say yes. Then give me the ?odo_variant= links to check each version on the page.
```

**Set it up in your code.** For a coding assistant with your site’s code. Leans on `create_experiment` and `update_experiment` (with **Run experiments**) and `analyze_experiment`.

```prompt
Set up that experiment in my site’s code with odo.experiment(): the current version as "control" first, then one variant, keeping the change small. Register it with odo’s create_experiment in code mode, under the same name and variant keys and judged by the outcome it should move, and start it once the code is deployed and I say yes. Check each renders by opening the page with ?odo_variant=NAME:control and ?odo_variant=NAME:VARIANT, and once visitors come in, confirm with odo that both variants are being shown.
```

**Read the results.** Leans on `list_experiments` and `analyze_experiment`.

```prompt
How are my experiments doing? Use odo’s list_experiments for the ones odo runs and the ones found in my code, then read each in depth against the goal, event or page it was meant to move: its verdict, each variant’s conversion with its 95% range and lift over the control, how far along its plan it is, whether the sample ratio check passed, and which segments odo flags as worth testing. Tell me which odo has called, which to leave running and for how long, and which found in my code to register so odo calls them too. Act only on the verdict, not on an early lead.
```

**Act on a call.** Leans on `list_experiments` and `update_experiment`, with **Run experiments**.

```prompt
Go through the experiments odo has called on my site. For each winner that lives in my code, tell me exactly what to change, and once I confirm it’s deployed, mark it shipped in odo with update_experiment. For each winner odo now shows to everyone, give me the change to make permanent in my code, and archive the experiment once I say it’s live. Pause anything odo says is broken, and tell me why it broke. Ask me before each change in odo.
```

## Site changes

**What my last change did.** Leans on `list_site_updates`.

```prompt
What did my latest site change do? Use odo’s site updates from the last 30 days: for the newest one, compare visitors, conversion and revenue in the whole days after it went live with as many days before, say whether the change in conversion is beyond chance, and name anything else that went live in the same days.
```

**Note a change after deploying.** Leans on `record_site_update`, which a connection has when you leave **Note site changes** on, or a key has the **Updates** permission. See [site updates](https://odo.gg/docs/site-updates).

```prompt
We just deployed the new pricing page. Note it in odo as a site update: "New pricing page", path /pricing, kind pricing.
```

So a coding assistant notes every change it ships, add this to the project’s `CLAUDE.md` (or `AGENTS.md`):

```md
After you deploy or publish a change to the website that visitors will see (a new page, copy, design, pricing, a checkout fix), call odo’s record_site_update tool once with a few plain words of what changed and the page’s path, so odo marks it on its charts and shows what it did to visitors, conversion and revenue.
```

## Weekly check-in

**A short review of the week.** Leans on `get_summary`, `get_traffic`, `get_earnings_history` and `get_next_moves`. On the Growth plan, odo also writes [a review of its own](https://odo.gg/docs/analysis#the-weekly-review) every Monday.

```prompt
Give me a short check-in on the last 7 days against the 7 before, from odo. Lead with earnings and visitors and what changed most, then the channel, source or page behind it, conversion and revenue per visitor, and the top item from odo’s Next moves. Numbers first, under 150 words, and say when a change rests on too few sales to mean much.
```

## Earnings

**Why this week is different from last.** Leans on `get_earnings_history`, `get_source_metrics` and `get_traffic`.

```prompt
Why are this week’s earnings different from last week’s? Use odo’s earnings by day and by source for the last 14 days, and each source’s payments, average payment, refunds and fees for the last 30 days against the 30 before. Tell me which sources moved, whether it’s more payments or bigger ones, and whether visits or conversion on the site changed in the same days.
```

**Is today on pace?** Leans on `get_earnings`, `get_earning_patterns` and `get_recent_transactions`.

```prompt
Is today on pace? Use odo to compare today’s earnings so far with the same time yesterday and with a typical day at this hour, say where today should end, and point out any payment or refund that stands out.
```

## odo’s built-in prompts

odo’s MCP server also offers 9 ready-made prompts of its own, read here from the server’s registry. Each takes a project if you like; without one it reads all of your projects.

- **How’s today going?** `/mcp__odo__daily_briefing`: Today’s earnings against a usual day, the pace, notable payments, and who’s on the site.
- **Weekly review** `/mcp__odo__weekly_review`: The last 7 days against the week before: earnings, sources, traffic and conversions, with ideas.
- **What brings paying customers?** `/mcp__odo__what_brings_customers`: Which channels, campaigns and landing pages bring people who pay, and where to focus.
- **Find conversion leaks** `/mcp__odo__optimise_conversion`: A full conversion audit: where visitors leak, which pages and journeys sell, and what to fix first.
- **Improve the site, and prove it** `/mcp__odo__improve_site`: The closed loop: find the biggest leak, change the site as an experiment, and read the result.
- **Fix what frustrates visitors** `/mcp__odo__fix_friction`: Script errors, rage and dead clicks and failing form fields: their causes in the code, and fixes.
- **Review experiments** `/mcp__odo__review_experiments`: Every A/B experiment of the last 90 days: verdicts, broken splits, and what to stop or keep running.
- **Help odo see the site** `/mcp__odo__instrument_site`: Audit the site’s code against what odo records: names, labels, sections, forms, privacy, goals.
- **Review one page** `/mcp__odo__page_review`: How one page performs and what to change on it.

- **In Claude Code,** type `/` and they’re listed as `/odo:daily_briefing (MCP)` and so on; typing `/mcp__odo__daily_briefing` runs one too. `odo` is the name you gave the connection in `claude mcp add`: if you named it something else, use that. To pick a project, put its id after the command (`/mcp__odo__weekly_review PROJECT_ID`): Claude Code splits what follows on spaces, so a name with a space in it won’t work.
- **In other apps** that support MCP prompts, they’re in a menu of the app’s own, under odo. Where an app doesn’t, copy a prompt from this page instead.

## Writing your own

- **Name a range:** today, or the last 7 days, 30 days, 90 days or 12 months. That’s what odo’s tools take.
- **Say what converting means.** By default it’s a sale traced to the visit; name a goal, an event (*Signup*) or a page (*/thanks*) to count that instead.
- **Ask for the numbers,** with how many people each rests on and the 95% range, and for a comparison: with the week before, the site’s average, or another segment.
- **Use the names odo uses:** channels like *Organic Search* or *Organic Social*, sources like *Google* or *TikTok*, pages as paths like */pricing*.
- **Ask what to do,** and how you’d know it worked. odo’s **Next moves** are a good start: *what are my next moves in odo, and which one is worth the most?*