Shopping feed audit prompt writer

What it does

A Google Shopping campaign can hold thousands of products. A few earn most of the sales, and some spend money for months without a sale. Looking at them one by one does not scale, so owners and developers build a Shopping feed audit into code. This prompt briefs your coding AI to build that audit. Each product lands in one tier: hero, steady, potential, underperformer or zombie. The tests run in a set order, so a product only lands in one place. A product with too little data is counted as not enough data, never forced into a tier. Every cost and ROAS cut-off is a setting you choose, and a pause idea always shows its cost to date and its click count. The module only reads and recommends. It never changes a bid, a product group or an account.

What goes in and out

You give it

• A code project and a coding AI, such as Claude Code, that can edit it
• Product rows with cost, impressions, clicks, conversions, conversion value and campaign type, from the Google Ads API or sample rows
• Your target ROAS, worked out from your margin
• Your date range, account currency and cost cut-offs (the prompt gives example values)
• Category benchmarks for click rate (optional)

You get

• A prompt that builds one read-only audit function with typed input and output
• Five tiers with tests in a set order, plus a not enough data group
• Three lists, feed fixes, bid tests and pause candidates, each sorted by cost
• A list of every setting and assumption for you to review
• Tests on sample rows, with no real account used

How the task works

• Looks at your project. Finds your language, test setup and any existing fetch code or result type, and reports what is missing.
• Sorts products into tiers. Tests in this order: zombie, hero, steady, underperformer, potential. Products below the impression floor go to not enough data.
• Sets benchmarks from your data. Uses the median click rate for each product type, only if the type has enough products. Otherwise the test is marked not evaluated.
• Writes findings. Gives each tier a finding or a count, names the campaign type, and shows the cost behind each one.
• Builds three lists. Feed fixes, bid tests and pause candidates, each sorted by cost with a cap on length.
• Tests the edge cases. Checks each tier, the order of tests, the 50-click rule for pauses and the missing benchmark case.

Full instructions

• Work out your target ROAS from your margin. The audit cannot run without it.
• Decide where product data comes from. If you have code that fetches it, tell the AI where it is. If not, the prompt builds the function to take typed rows.
• Copy the prompt from the skill and fill in the angle brackets, including your cost cut-offs. Paste it into your coding AI with your project open.
• Read the settings list the AI gives back, and change any cut-off that does not suit your account.
• Run the tests on sample rows. Run it on a live account only when you decide to, read-only.
• Hand the three lists to a person to approve. Nothing is changed for you.

Change the instructions

• Your target ROAS. Work it out from your margin before you start. Hero and steady tiers depend on it.
• Your cost cut-offs. Set the zombie and underperformer costs for your account. The example values suit only a small account.
• Your date range. Use a range long enough for products to get clicks, such as 30 days or more.
• Campaign type. Include it for each product. Standard Shopping and Performance Max show different product data.

Words used in this task

• ROAS: Sales from ads divided by what you spent on them.
• Zombie product: A product that gets many clicks and no sales.
• Feed: The list of your products, with titles, prices and images, that you send to Google.
• Product type: The category label on a product in your feed, such as shoes or kitchen.
• Read-only: The code can look at data but cannot change bids, products or accounts.

Full instruction file

Shopping feed audit coding prompt

This is a prompt you paste into a coding AI (Claude Code, Cursor, Codex or similar) that can read and edit your project. It builds one read-only module that reviews your Google Shopping products one by one. It sorts them into tiers by results, then lists what to fix in the feed, which bids to test and which products to consider pausing.

If you only want a feed review from Merchant Center reports, not software, use the Merchant Center feed health checker.

Before you start

Use the material below to do this job. If facts or tool access are missing, explain what you can finish and what must wait.

What you need (use your own material or the linked skill):

• A codebase (yours): a project's code, in a folder or repo the AI can open.

How to start:

1. Look first. Use what they've already attached, pasted or put in their about-me note. In a coding assistant with file access, look in the project too for these by name.
2. Check what's missing. Look for a codebase. They can attach files, paste the details, or share a file path your assistant can read. Ask only for missing facts that change the result. If they ask you to start with what they have, complete the parts you can and mark the gaps.
3. Do the job. Follow the method with the facts and tools you have. Mark each gap with MISSING: where it belongs and never invent a fact to fill it. Keep the answer tight: say each point once and merge steps that give the same thing. In CHECKS MISSED, list checks that failed or could not run. If every required check ran and passed, write “none”.

What you need first

• A project with code you can edit, and a coding AI with access to it.
• Product-level Shopping results for a date range: product ID, title, product type, cost, impressions, clicks, conversions, conversion value, and the campaign type (standard Shopping or Performance Max). Google Ads gives you these through its API. Fetching them live needs a Google Ads API developer token and read access to the account, and Merchant Center access if you also want product disapprovals. Setting that up is a separate job: see the Google Ads token and access check planner. Without access, the prompt builds the module to take typed product rows, so it works and can be tested on sample rows.
• Your target ROAS: the return you need on ad spend, worked out from your margin. The module will not guess it.
• Your own cost cut-offs in your account currency. The prompt starts with example values you should change.

Paste this into your coding AI

Fill in the angle brackets first.

Build a read-only Shopping product auditor that sorts every product into a tier and lists feed fixes, bid ideas and pause candidates. It must never change a bid, product group or account.

First, look at my project: language, folder layout, how tests run, whether a result type for findings already exists, and whether code already fetches Google Ads data. Tell me what you found. If something I need is missing, list it and build the part that does not depend on it.

## What to build

Function: auditShoppingProducts(input) returns DiagnosticOutput. Put it in <the folder where my analysis code lives>, in my project's language and style.

Input:
- products: rows of { offerId, title, productType, campaignType (standard or performance-max), cost, impressions, clicks, conversions, conversionValue, disapprovals? }
- dateRange and currency
- targetRoas: required. If missing, stop and say so. Never guess it.
- benchmarks (optional): { ctr, conversionRate } per product type. If missing, work them out inside the data, see below.
- settings, all configurable. These are starting assumptions I must review:
  minImpressions = 100, minClicksToPause = 50, zombieMinCost = <50>, criticalCost = <250>, underperformerMinCost = <25>, heroMinConversions = 3, heroRoasMultiple = 1.2, steadyRoasMultiple = 0.8, ctrFloorVsMedian = 0.7, minProductsPerBenchmark = 5, listCap = 50.
  Money values are in account currency.

If the project has no result type yet, use:
  Finding = { checkId, severity: critical|high|medium|low|info, title, recommendation, affectedProducts, evidence }
  DiagnosticOutput = { findings, summary, notEvaluated, dateRange, currency }

## Tiers
Put each product in one tier. Test in this order and stop at the first match. ROAS = conversionValue / cost.
1. zombie: clicks at least minClicksToPause, zero conversions, cost above zombieMinCost.
2. hero: impressions at least minImpressions, conversions at least heroMinConversions, ROAS at least heroRoasMultiple times targetRoas.
3. steady: impressions at least minImpressions, at least 1 conversion, ROAS at least steadyRoasMultiple times targetRoas (and not hero).
4. underperformer: impressions at least minImpressions and either (a) at least 1 conversion with ROAS below steadyRoasMultiple times targetRoas, or (b) zero conversions, CTR below the benchmark and cost above underperformerMinCost.
5. potential: impressions at least minImpressions, zero conversions and CTR at or above the benchmark.
6. Anything else is "not enough data". Count it. Never call it a tier.

## Benchmarks
If no benchmark is given, use the median CTR of products in the same product type, only when that type has at least minProductsPerBenchmark products. If not, mark the CTR test "not evaluated" for those products and say why. Do not invent a benchmark.

## Findings
- hero: "shopping-hero-scale" (medium). Suggest a small bid increase test, or moving it into its own campaign with higher priority. Do not state an amount as a promise.
- steady: no finding, counted in the summary only.
- potential: "shopping-potential-feed-optimize" (medium). Suggest a title that starts with the brand and main search words, and that I check it is in the right campaign.
- underperformer: "shopping-underperformer-feed-fix" (high). Suggest checking the title, GTIN or MPN, image, price against competitors, then testing a bid reduction.
- zombie: "shopping-zombie-pause" (critical if cost is above criticalCost, otherwise high). Suggest excluding the product or pausing its product group, and state "<cost> spent with 0 conversions in <date range>".
Always name the campaign type. Standard Shopping and Performance Max treat priority and product data differently, and Performance Max may show fewer products. Say so in the finding.

## Three action lists in the summary
- feedFixes: { offerId, title, issues[] }
- bidChanges: { offerId, direction, reason } (no exact new bid unless a current bid is in the input)
- pauses: { offerId, reason, costToDate }
Sort each list by cost, highest first, and cap at listCap. Say how many were left off.

## Tests
Write tests with sample rows only, no real accounts:
- each tier reached by at least one row
- a product that fits two tiers goes to the first in order, zombie before the rest
- a product with 40 clicks and zero conversions is NOT a pause candidate
- missing benchmark and a small product type give "not evaluated", not an invented number
- list sort and cap

## Rules
- Read-only. Do not call the Google Ads API from this module. Fetching is separate.
- Every pause suggestion shows the cost to date. A person decides.
- Do not install packages, change config, add a schedule or run against a live account. Ask me first.
- Do not invent numbers. Say what you ran and what you did not.

## When you are done, show me
1. The function signature and types
2. Sample output from the test rows, including the three action lists
3. The test results (say if you could not run them)
4. A list of the settings and assumptions I need to review

Check the result

• Every cut-off is a named setting, with your own number in it. None is hidden in the code.
• Products with too little data are counted as "not enough data", not placed in a tier.
• A pause idea always shows its cost and click count.
• Nothing in the module can change an account.

After it works

Fixing the titles it flags is a separate job: use the Shopping feed title writer. For a feed-level review from Merchant Center reports, use the Merchant Center feed health checker. A weekly run suits feed work, because feed changes show up within days. Add a schedule only if you want one: ask the AI to propose it, then approve it yourself.

After this

When you've handed it back, suggest what they could do next in one short question. It's a suggestion: if they're done, that's fine. Offer these, and say they can type their own:

• The Simple code coach. It takes the code change. If they pick one and that skill is added here, carry straight on with what you just made. If not, give the link and say what to bring.