By Daniel Goodrich
Target Painting is a premium residential painter serving MetroWest Boston. In one working session, a Claude agent pulled the account’s live Google Ads data, wrote the weekly Metrics-Analysis-Action report, investigated why the daily budget suddenly filled up, audited both landing pages, ran PageSpeed on each, generated a runnable negative-keyword script, and rendered the client-facing report with two trend charts. The human directed the run and made the calls that needed a human. Everything else the agent did on its own.
The methodology behind this
This run is a specific instance of the MAA framework. The general process, why Analysis matters ten times more than Metrics, and how each metric pairs with a counterbalancing metric, live in Dennis Yu’s MAA framework article. This meta-article does not restate that framework. It documents one real execution of it, so the next operator and the next agent can see exactly how the steps land on a live account. It follows the meta-article prompt template, the standard for documenting agentic work.
The MAA task
The agent was handed a scheduled weekly assignment: produce the Google Ads platform MAA for Target Painting using the BlitzBase system, as a draft for review. In scope: pull the data, write the report, update the internal status files. Out of scope without approval: rendering the client view, posting to Basecamp, or changing the account. Over the session the human extended the task four times: investigate the budget-loss spike, audit the landing pages, tighten the report and produce the negatives script, then render and post.
The account runs two Search campaigns on Maximize Conversions, Exterior and Interior painting, at a blended cost per lead around $180 to $300. The strategic question underneath every weekly read is whether a rebuilt set of landing pages is starting to move the account.
Source material the agent read
The agent read the account and the system before writing a line. From the BlitzBase knowledge base it read the cross-client Google Ads data contract, the GAQL query pack, the MAA generation procedure, the weekly MAA skill, and the client’s own metric spec, status files, and prior dated report. From Google Ads it pulled live data through the API.
The one rule that governs the data read is the Quality Score column mapping. On the API path the components come back correctly labeled, so there is no swap. The agent confirmed this with the account’s anchor keyword before trusting any component reading:
exterior house painters reads Expected CTR Below, Ad Relevance Above, Landing Page Below.
That anchor matched the pull, which is how the agent knew the API labels were correct and the email-fallback swap did not apply.
The data pull
The agent queried the Google Ads API through the MCP search tool, running the GAQL pack against the account: campaign summary, keyword report with Quality Score components, search terms, ad report, and conversion detail, each for a 7-day and a 30-day window. It converted micros to dollars and rate fractions to percentages, then saved the raw rows to a dated JSON file so the run is reproducible.
The headline numbers came out clean. Seven leads for the week at a blended $188.91 cost per lead, in line with a steady 30-day average of $196.27 across 24 leads. The agent verified every delta against the prior week’s report before writing.
The budget-loss investigation
The most useful analysis of the day started with a single odd metric. Budget lost impression share jumped from about 18 percent to 33 percent on Exterior while rank lost impression share fell from 63 to 42 percent. The human asked the right question: with our landing-page score improving, are we reaching new searches that caused this?
The agent pulled the search terms for the account’s biggest keyword, exterior painters near me, for this week and the prior week, each tagged with the keyword that triggered it, and diffed them. The finding reframed the whole report. Exterior impressions had climbed 68 percent on an unchanged budget, and every exterior keyword grew together, from plus 31 percent to plus 207 percent. That even, ad-group-wide growth is the fingerprint of a page-level Ad Rank lift, not one keyword drifting, because Landing Page Experience is a page signal that raises every keyword pointing at that page.
But the newly eligible auctions were mostly off-target: competitor-name lookups, retail and product searches, and off-service work. So the higher budget-loss number was inflated by auctions the account would not want to fund. That flipped the recommendation from “bring a budget increase to the client” to “tighten the match first, then read budget-loss cleanly.” Structure before budget.
The landing-page audit
With the report anchored on Landing Page Experience, the human asked the next question: what is the next step now that the page has held Average for two cycles? The agent opened both live pages in the browser, read the content, and confirmed the alignment and copy work was already done. That meant more copy would not move the page from Average to Above. The remaining lever was technical.
The agent ran PageSpeed Insights on each page through the browser, since the direct API is off the network allowlist. The exterior page scored 49 on mobile with a 6.6 second Largest Contentful Paint and 760 milliseconds of blocking time. The interior page scored 67. Cumulative Layout Shift was near zero on both, so layout was not the problem. The diagnostics named the cause: 734 KiB of unused JavaScript, 2 seconds of script execution, and a heavy hero image. Desktop was fine, so this was a mobile problem, and mobile is where the paid clicks land. The agent wrote the fix sequence into the page-improvement plan and added the page-speed workstream to the report as the Average-to-Above lever.
The negative-keyword script
The human asked for the script that would let the tightening action be marked done. The agent generated a one-time Google Ads change script that adds this week’s off-target search terms as negatives, built on the exact structure of the prior week’s script that had already run live. Competitor brands route to a shared account-level list, off-service and geo terms become campaign negatives, and retail noise applies to both campaigns. The script defaults to dry-run mode so the operator previews every change before executing.
Two entries were judgment calls the agent flagged rather than forced. Deck staining stayed servable because the exterior page sells deck staining, and pressure washing was left pending because house washing is an offered service. The human ran the script live after previewing it.
Critical decisions with rationale
Anchor the analysis on Landing Page Experience, not weekly keyword conversions. The head term ran zero, zero, zero, then four conversions across four weeks. Reading those swings directly had misled prior reads. The page score is the slow, stable layer that actually indicates structural change, so the report led with it and treated the keyword swings as noise.
Hold the budget increase despite 33 percent budget-loss. The obvious move on a third of impressions lost to budget is to raise the budget. The search-term diff showed that most of the new eligibility was junk, so raising budget would have funded off-target auctions. The agent sequenced the match-tightening first so the budget-loss number becomes trustworthy before any raise.
Protect converters and in-service terms in the negatives. Before adding any negative, the agent checked each term against the account’s conversions and the site’s service list. It kept angie’s list, townline paint malden, and framingham queries because they converted, and kept deck staining servable because the page sells it. A blunt negative list would have blocked real leads.
Read Quality Score components as labeled on the API path. The email export ships those columns swapped, but the API does not. The agent confirmed with the anchor keyword and applied no swap, which kept the component story accurate.
Omit a target line on the cost-per-lead chart. The account has no single target CPA set. Rather than invent one, the agent left the target line off, since the chart stage must derive from real data and never fabricate.
The QA marathon: real bugs and the fixes
The connector dropped mid-run, twice. Symptom: the Google Ads pull returned “the user’s connection to this connector was invalidated.” Cause: the session token for the MCP connector expired during the run. Fix: the agent stopped, told the human exactly which connector needed reconnecting, and re-ran the identical queries once it was restored. No partial data was written.
A filtered query rejected its own filter. Symptom: the search-terms query errored with “the following field must be present in SELECT clause: segments.keyword.info.text.” Cause: GAQL requires any segment used in a condition to also appear in the SELECT list. Fix: the agent added the keyword segment to the field list and the query returned cleanly.
The full search-term pull blew the output cap. Symptom: a 200-row pull returned 61,000 characters and was written to a temp file the sandbox could not read. Cause: the result exceeded the tool’s token limit, and the temp path sat outside the mounted workspace. Fix: rather than fight the large file, the agent narrowed the query to the single keyword that mattered and its two weeks of terms, which answered the question in a fraction of the tokens.
Em dashes slipped into the client-view titles. Symptom: the rendered client view carried five em dashes across its headers and title tag. Cause: the header template used em dashes as separators, which the BlitzBase canon forbids. Fix: the agent caught them in the required pre-publish check and replaced every em dash with a hyphen, then re-verified zero remained.
A generic Google Ads connector could not run the report. Symptom: the first available Google Ads tool exposed only a report builder with a fixed set of resources, no GAQL search and no keyword or search-term views. Cause: it was a different connector than the one the data contract expects. Fix: the agent recognized it could not produce Quality Score components or search terms, and waited for the correct search-capable connector before pulling, rather than shipping a partial report.
Effort and cost comparison
| Task | Agent time | Human time | Agent cost | Human cost ($50/hr) |
|---|---|---|---|---|
| Read contracts, specs, status files | ~1 min | ~5 min | $0.20 | $4 |
| Pull Google Ads data (5 datasets, 2 windows) | ~2 min | 10-15 min | $0.60 | $8-13 |
| Write and verify the MAA draft | ~3 min | 15-25 min | $0.80 | $13-21 |
| Search-term investigation (keyword-attributed diff) | ~2 min | 10-15 min | $0.50 | $8-13 |
| Landing-page audit plus PageSpeed on both pages | ~3 min | 10-15 min | $0.60 | $8-13 |
| Round 13 negatives script | ~1 min | 5-10 min | $0.30 | $4-8 |
| Client view render (markdown, HTML, two charts) | ~1 min | 5-10 min | $0.40 | $4-8 |
| State updates across five files | ~1 min | ~5 min | $0.30 | $4 |
| TOTAL | ~14 min | ~1-1.5 hrs | ~$3.70 | ~$53-84 |
Pricing basis: the run used Claude Opus at $5 per million input tokens and $25 per million output tokens, on roughly 550,000 input and 38,000 output tokens. Human cost is a blended $50 per hour for a skilled PPC analyst doing the same pulls, analysis, audit, script, and client report by hand. That puts the agent run at roughly 15x to 20x cheaper than the manual equivalent, and it compresses the manual workload into a 14-minute session.
What the agent handled versus what needed a human
Agent handled autonomously: reading the data contract and specs, pulling and unit-converting every dataset, verifying the anchor keyword, computing every week-over-week delta, diagnosing the budget-loss mechanism, running the keyword-attributed search-term diff, browsing both landing pages, running PageSpeed and reading the diagnostics, writing the report and trimming it on request, building the negatives script on the proven pattern, generating the two charts and both client-view formats, running the pre-publish checks, and updating all five status files.
Required human input: reconnecting the Google Ads connector when its session expired, the decision to hold versus raise budget, running the negatives script live, editing and posting the client report to the client, confirming lead quality from the CRM, deciding the pending pressure-washing negative, and the eventual Elementor work to fix page speed. The agent can specify those changes but cannot push them live.
Information ingestion inventory
- 8 knowledge-base and spec files read (data contract, GAQL pack, MAA procedure, weekly MAA skill, metric spec, paid-status, active-issues, prior report)
- 14 Google Ads API queries executed across two date windows
- 2 landing pages audited live in the browser
- 2 PageSpeed Insights runs (one per page, mobile)
- 1 raw data JSON saved, 1 trend row appended
- 6 deliverables produced (report, two client-view formats, two charts, negatives script) plus a page-improvement plan update
- 5 named critical decisions, 5 named bugs recovered
- ~590,000 total tokens estimated
Why this creates value for Target Painting
The account now has a reproducible weekly read that separates signal from noise. Instead of chasing a keyword that converted this week and stalled last week, the work anchors on the landing-page score that actually indicates whether the rebuild is paying off. This week that discipline caught a trap: it would have been easy to raise budget on a 33 percent budget-loss number and pour money into competitor-name and off-service searches. The agent traced the number to its cause, tightened the targeting first, and set up a clean read for next week. The page-speed finding gives the client a concrete, prioritized next step that lifts both campaigns at once.
Why this creates value for BlitzMetrics
This run shows the MAA framework executed end to end by an agent, with a human making only the calls a human should make. The analysis was not a metrics recap. It diagnosed a mechanism, reversed a tempting but wrong recommendation, and sequenced structure before tactics, which is exactly the standard Dennis holds MAAs to. At roughly 15x to 20x cheaper than the manual equivalent, the same weekly rigor becomes deliverable across a full book of local-service accounts, not just the ones that can carry a senior analyst’s hours. That is the segment this playbook unlocks.
The build pattern
This is the MAA framework applied to a Google Ads account with a landing-page thesis underneath it: read the page-level quality signal, connect it to the auction mechanics, sequence structure before budget, and hand the client a plain-language report with one clear ask. Read the MAA framework for the general method, see the meta-article prompt template for how this documentation is produced, and compare this run against the sibling dumpster rental run, where the agent closed its own blind spot with a mid-cycle keyword pull. The tool itself is documented in the Google Ads MAA Agent definitive article (localservicespotlight.com/maa-agent). If you run local-service ad accounts, the next step is to put every weekly report through this same read.