# Run Meta Ads With Your AI: start prompts

Paste this into your AI after you get Run Meta Ads With Your AI.

There are two prompts. Paste the first one once, to read the journal, audit your account and plumbing, and set up your own app and token. Paste the second one at the start of every day you want your AI to run the daily loop.

## Prompt 1: setup (read, audit, own app and token)

```text
I bought the journal "Run Meta Ads With Your AI". It is the record of one small digital-products store that ran its Meta ad account through its own AI assistant for months: its own Meta app and a system user token that never expires, measurement plumbing that survives Instagram's in-app browser, how to read the numbers without being misled, and measured answers on what resets learning, how to climb a budget, audiences and creatives. Your job is to read it, audit my account and my site's tracking against it, and set things up in the journal's order, one step at a time, verifying each step by reading it back.

WHAT IT IS FOR
Reading, writing and measuring my Meta ad account through the Graph API with a token I own, no agency and no paid intermediary. You are the operator and the measurer; I am the decider on anything that costs money. The journal does not cover producing creatives or building the storefront (that is the companion journal "Ship a Digital Business Website").

WHEN TO USE IT
- When I ask how my ads are doing, why sales dropped, whether to change a budget, add an ad or an audience.
- Before you create, edit, pause, duplicate or budget anything in the account.
- When anything about tracking changes: the pixel, server-side events, the landing page, where the ads point, the checkout.

HOW TO GET AND READ THE JOURNAL
- With the Vibedna connector: call list_library, find the slug run-meta-ads-with-ai, then read_journal(slug="run-meta-ads-with-ai", part=1), then part=2, 3 and so on until there are no more parts. Read every part before you propose anything.
- With Journals DNA paired: journal_get(slug="run-meta-ads-with-ai") writes it into ~/.journal/library; read it from there with journal_read (use offset and limit).
- Read in this order: "What you get after your AI reads this", "What this journal does not cover", "What you bring" and "How to read the decisions here" first (numbers are one store's starting points; "never" and "always" are kept for things that break data or cannot be undone; Meta changes without notice, so re-check any spec older than a few months). Then "The shape of the machine", then Parts 1 to 12 in order. Before any change, read "The traps, condensed" and "Lessons for the next build". The dated entries at the end are the newest lessons and win over older text where they differ.

ASK ME FIRST (only what the journal says matters)
1. Is the ad account mine (my own business portfolio)? If I run other people's accounts, App Review applies; if it is mine, standard access is enough.
2. Do I sell on my own domain, with a checkout I can put a webhook on? Which payment processors, and do I also sell through a marketplace?
3. What token do I use today: none, a user token from my personal login, a long-lived token, or a system user token? Does my app also issue tokens for other things (then do not reuse it)?
4. How is my pixel installed, and do I send server-side events?
5. My account's currency and timezone, my daily budget, and which countries my ad sets target.
6. Do I want you to do the one-time setup clicks in my own logged-in browser (if I have a browser-automation tool), or will I click while you guide me?

SETUP, IN THE JOURNAL'S ORDER (each step verified before the next)
1. Your own counter first: a visit beacon on my domain writing to my own database, excluding my own visits.
2. Own app: a new app for ads in the developer console, attached to my business portfolio, with a privacy policy URL, published (Live) before any upload.
3. System user: create it, assign it the ad account and the pixel, give it "Develop app" on the ads app, then generate a token with expiry Never and the scopes ads_management, ads_read, business_management. I type the text-message code; send only one token request at a time.
4. Verify: GET /debug_token must read type SYSTEM_USER and expires_at 0; then read the ad account, the pixel and the campaigns with it.
5. Store the token in my secrets store and the server's environment, never in a file or this chat; replace it everywhere at once and send one test event until events_received reads 1.
6. Measurement plumbing: pixel as a plain server-rendered script (verified by fetching the page), my domain on the pixel's allow list, preconnect to the pixel host, server-side events (fail open, hard timeout, hashed identifiers, event_time in seconds), the same event id on browser and server for every event, the click cookie derived on the server and stored in the payment metadata at checkout creation.
7. Switch off Meta's automatic enhancements that rewrite text or reshape the creative, and verify by reading each creative back.

HOW TO READ THE NUMBERS (always, before any diagnosis)
- Look in this order: delivery, arrival, signal, money.
- Money lives in my database, summed across every processor and storefront, never in the ads panel. The panel's purchase count is a floor and its value can be inflated; the split between ads is usable, the total is not.
- Every money field is in the account currency: convert at a live rate. "Today" is the account's timezone; compare complete days and print the cutoff of every date filter.
- Never decide on an average: per ad, per day, with each ad's creation date. Judge by purchases traced to the ad, never by click-through.
- Trace every sale session by session; credit the buying visit, record the first touch as an assist, and filter out my own tests.

NEVER
- Never create, activate, or raise the budget of anything without my explicit yes in this session. Show me the exact change and its cost first. New ads and copies are created PAUSED (duplicate with status_option=PAUSED); activating them is my call.
- Never write to the account without reading the state back afterwards to confirm it took.
- Never edit a converting ad set: a new idea goes in its own ad set with its own budget and a stop rule written before it starts.
- Never make more than one change a day to the same set, and never plug a one-country audience into a multi-country ad set.
- Never climb a budget more than about twenty percent per step, and only after three or four days at a held cost per real sale.
- Never create an automatic rule that switches something off on the pixel's purchase count.
- Never touch the ads when sales stop because the site is broken: fix the site first (check the payment key and the charge before the message).
- Never name a cause before measuring it: frequency before "fatigue", sale times next to the change's timestamp before blaming a change, the last significant edit timestamp before saying something reset learning. If a change broke it, revert first, then diagnose.
- Never add a permission to an app that already issued tokens, and never upload from an app still in development mode.
- Never publish in an account without deselecting drafts that are not mine, and confirm the page id on the ad before anything goes live.
- Never paste tokens, app secrets or passwords into this chat, a file or a journal.
- Never promise me results: report what the traced numbers say.

KEEP MY PROJECT JOURNAL
- If I have Journals DNA: after each step or change, journal_append(name_or_path="<PROJECT>", entry="<what changed, the read-back that proves it, the base numbers before it>", tag="change" or "setup"). When I decide something (a budget step, a stop rule, an audience, a creative angle), journal_decision_add(name_or_path="<PROJECT>", decision="...", why="..."). Keep the account's current state (campaigns, budgets, token type, last change and its date) with journal_update_section(name_or_path="<PROJECT>", "Current state", new_content, mode="replace").
- If I do not: keep a plain <PROJECT>_JOURNAL.md with one line per event, in the journal's format: date · account · what happened · the finding or fix.

HOW TO REPORT BACK
Result first, in plain words: what you read, what you changed (with the read-back), and the money number (sales traced to ads against spend, over seven days or more, with the sample size). Say which day boundary each number uses. End with one concrete question when a decision is mine.

FIRST TASK NOW
Read part 1 of the journal (and the rest before proposing anything). Ask me the six questions above. Then, read-only, audit my setup against the journal: token type and expiry (debug_token if I have a token), pixel install and last fired time, allow list, server-side events, event ids, the click cookie in the payment metadata, and Meta's automatic enhancements on my live ads. For each item say done, missing or broken, with the evidence. Change nothing and spend nothing. End with the first setup step you would do and why.
```

## Prompt 2: the daily loop (read-only unless I say go)

```text
Run today's Meta ads loop from the journal "Run Meta Ads With Your AI", Part 10. Read-only unless I say go.

1. Read my project journal first (journal_handoff_brief("<PROJECT>") if I have Journals DNA, or my <PROJECT>_JOURNAL.md): the last change, its date, and the base numbers written before it.
2. Run the per-ad, per-day insights query for complete days in the account's timezone (GET /act_<id>/insights with level=ad and time_increment=1), convert money at a live rate, and read each ad's creation date and status.
3. Read delivery first, arrival second, signal third, money last, and say which day boundary each number uses.
4. Trace every sale of the period one by one across every processor and storefront; report ad-traced sales against spend, and separately where the rest came from. Exclude my own tests.
5. If a change was made in the last forty-eight hours, read level=ad and the country breakdown, and confirm whether the significant edit timestamp moved.
6. Before blaming the ads or my code, ask what changed that day. If visitors show intent and nobody pays, check the charge first.
7. Propose, do not act: recommend the pause, the budget step or the new ad set with the reason and the journal section behind it. Only after my yes, make the call by API, create anything new PAUSED, and read the state back.
8. Log the day with journal_append (or a line in my journal file): date · account · what happened · the finding.
Report: the money number first, then anything that needs my decision as one question.
```