---
title: "Shopping feed audit prompt writer"
type: "prompt"
url: "https://useaiblocks.com/prompts/build-the-shopping-feed-auditor-builder-prompt"
updated: "2026-11-03"
first_published: "2026-10-25"
job: "Build and ship software"
tested: true
instructions: "https://useaiblocks.com/skills/build-the-shopping-feed-auditor-builder-prompt/SKILL.md"
---

# Shopping feed audit prompt writer

> Build a read-only Google Shopping product audit in your code. Get a prompt that sorts products into five tiers with fix, bid and pause lists.

Paste one prompt into a coding AI such as Claude Code. It builds a read-only module that sorts every product in your Google Shopping campaigns into five tiers by results. You get three lists, feed fixes, bid tests and pause candidates, each with the cost behind it.

Free prompt for the job "Build and ship software" · Level: intermediate · Thinking: medium · Tested · Updated 2026-11-03

## Links

- Page: https://useaiblocks.com/prompts/build-the-shopping-feed-auditor-builder-prompt
- Instructions (SKILL.md): https://useaiblocks.com/skills/build-the-shopping-feed-auditor-builder-prompt/SKILL.md
- All files (zip): https://useaiblocks.com/skills/build-the-shopping-feed-auditor-builder-prompt.zip
- JSON version: https://useaiblocks.com/prompts/build-the-shopping-feed-auditor-builder-prompt.json
- In your AI: connect https://useaiblocks.com/mcp and ask "Use AI Blocks to get build-the-shopping-feed-auditor-builder-prompt"

## 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 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)

## What 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

## Example: what goes in and what comes out

### What goes in

- Your code project, open in a coding AI
- Product rows with cost, impressions, clicks, conversions, conversion value and campaign type
- Your target ROAS, date range and account currency
- Your cost cut-offs and category benchmarks (optional)

### Before you start

- Google Ads API read access, or typed sample rows to start with
- A coding AI that can read and edit your project

### What comes out

- **auditShoppingProducts function**: One read-only function with typed input and output, in your project's language and style.
- **Tier rules**: Zombie, hero, steady, underperformer and potential tests in a fixed order, plus a not enough data group.
- **Findings**: Per tier, with the campaign type, the products, the cost and a starting recommendation.
- **Action lists**: Feed fixes, bid tests and pause candidates, each sorted by cost and capped in length.
- **Not enough data count**: Products without enough impressions or benchmark data, so none are guessed into a tier.
- **Tests and settings**: Tests for every tier and the cut-offs you need to review.

## The layout of every result

```text
Function: auditShoppingProducts(input) -> DiagnosticOutput
Tiers: <count per tier, plus not enough data>
Findings: <checkId | severity | campaign type | products | cost | recommendation>
Action lists (sorted by cost, capped):
  feedFixes: <offerId, title, issues>
  bidChanges: <offerId, direction, reason>
  pauses: <offerId, reason, cost to date, clicks>
Settings and assumptions to review: <list>
Tests: <results, or "not run">
```

## Use it when

- You are building your own Google Ads tool and want a Shopping product review in it.
- Your Shopping spend is high and you suspect many products earn nothing.
- A developer needs a clear brief for a product tiering module, with the tier tests set out in order.
- You want fix, bid and pause lists you can hand to a person to approve.

## Skip it when

- You only want a feed review from your Merchant Center reports, with no software: use the Google Merchant Center feed checker.
- You have no Shopping campaigns or no product-level results: nothing here can run, so start with the Google Ads campaign structure planner.
- You only need better product titles: use the Shopping feed title writer.
- You are looking for wasted spend on Display placements: use the Display ad audit tool planner.

## How to use it

1. Work out your target ROAS from your margin. The audit cannot run without it.
2. 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.
3. 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.
4. Read the settings list the AI gives back, and change any cut-off that does not suit your account.
5. Run the tests on sample rows. Run it on a live account only when you decide to, read-only.
6. Hand the three lists to a person to approve. Nothing is changed for you.

## What to do next

- [Simple code coach](https://useaiblocks.com/skills/simple-code-coach): Build it

## Instructions (SKILL.md)

## 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.

<!-- needs: written by tools/add-needs.mjs from the blocks' inputs. Edit that tool, not this section. -->
### 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”.
<!-- /needs -->

### 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.

<!-- next: written by tools/add-needs.mjs from the blocks' outputs. Edit that tool, not this section. -->
### 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](https://useaiblocks.com/skills/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.
<!-- /next -->
