Somewhere on the internet there is an old photo of me from my agency days wearing a blue Snuggie in the office.
Peak performance marketer.
This was back when we still called it Google AdWords, which already makes me feel 400 years old.
The funny part is I was probably avoiding logging into AdWords in that photo.
Because back then everything was manual.
You learned Google Ads by doing the annoying work.
Pulling search terms.
Building keyword lists.
Writing ads by hand.
Checking bids.
Checking budgets.
Checking conversion tracking.
Making the same mistake enough times that eventually your brain starts to build rules around it.
That is how most paid media judgment gets built.
Slowly.
Expensively.
With a lot of tabs open.
I have been doing this for almost 15 years now. Agencies, consulting, AppSumo, ecommerce, software, Google Search, Shopping, PMax, Merchant Center, YouTube, bidding, audiences, attribution, dashboards, reps, weird feed issues, all of it.
And the thing I keep coming back to is this:
AI agents make the mechanics easier.
They do not automatically give you judgment.
An agent can pull a search term report. Cool.
But does it know which terms to exclude, which ones deserve their own campaign, which ones are brand leakage, which ones are early signals, and which ones are just Google taking credit for demand you already had?
Usually no.
That is the gap.
So I built the thing I wish I had when I was starting.
A public Google Ads agent playbook.
Not a "prompt pack."
An actual operating repo an agent can load before it touches your account.
API access gives the agent hands
Most people are still stuck on the first layer of this.
Can the agent connect to Google Ads?
Can it pull spend?
Can it read campaign names?
Can it post a Slack message?
Yes, cool. That is useful.
But a generic agent with API access is like hiring an intern with every password in the company and no idea what good looks like.
It can move fast.
Not automatically a good thing.
I don't want an agent that just tells me:
Campaign A spent $1,200 and had a 2.4 ROAS.
I want it to tell me:
This campaign looks profitable in Google Ads, but most of the revenue is returning customers and two products are getting spend with weak margin. Hold budget, fix the product labels, and check whether this is actually new demand before scaling.
That is a completely different job.
One is reporting.
The other is operating.
The repo is public
I took as much of that judgment as I could and put it here:
github.com/nickyc1/google-ads-agent-playbook
The goal is simple.
If you are giving Claude Code, Codex, or any other agent access to Google Ads, do not just give it tools.
And if you are trying to start managing Google Ads for your company, or start an agency, do not make the agent learn from zero.
Give it taste.
Give it rules.
Give it the mental models an actual paid media operator uses before touching spend.
What is in it
The repo now has playbooks for the parts of Google Ads where people usually get lost:
- Monday memo reporting
- daily optimization
- Search campaigns
- AI Max for Search
- Google Shopping
- Merchant Center and feed health
- Performance Max
- bidding
- audiences
- Demand Gen and YouTube
- YouTube creator partnerships
- measurement
- safety and change management
The ecommerce stuff is the part I beefed up the most because this is where agents can be wildly useful and wildly dangerous.
Merchant Center is a perfect example.
A normal report says:
You have 800 feed issues.
An actually useful agent says:
Six live, in-stock, primary-market products are blocked from Shopping. Three are landing page errors. Two have missing required apparel attributes. One is a stale product that should be excluded, not fixed.
That is the difference between noise and a decision.
The agent needs product judgment too
Shopping and PMax are not keyword campaigns.
They run on product data.
If the feed is messy, Google is making decisions from bad inputs. Old URLs, bad titles, missing labels, wrong product types, duplicate product families, products that are live but missing from the feed, products in the feed that should not be advertised.
Most marketers try to fix that from the campaign screen.
Wrong room.
You need the agent to build a product truth table:
- what is live in the store
- what is in Merchant Center
- what is approved
- what is disapproved
- what is in stock
- what has margin
- what got spend
- what should be excluded
Then the campaign decisions get a lot easier.
Cut the product that should not be advertised.
Fix the product that is blocked.
Scale the product that is profitable but underfed.
Don't let PMax keep spending on low-margin revenue just because platform ROAS looks good.
None of that is hard once the system can see clearly.
The hard part is teaching the agent what to look for.
The Monday memo is the operating layer
The Monday memo format is built around one question:
What happened in the last seven days and what are we doing this week?
Not yesterday.
Not month to date.
The last seven.
That is the right rhythm for a weekly operator review.
The memo has four sections:
- Last seven performance
- Wins
- Opportunities
- This week's moves
Then I added a separate action item section that pulls from Slack and meeting notes.
That part matters more than people think.
Paid media work does not only happen inside Google Ads. Half the real work is in the messy follow-through:
- waiting on a feed fix
- checking if a landing page shipped
- getting a promo approved
- asking creative for another cut
- confirming margin on a product
- following up on a tracking issue
- making sure somebody actually did the thing from last week's meeting
The agent should not just report the account.
It should remember the work around the account.
This is why I like repos for agents
A chat prompt is disposable.
A repo compounds.
Every playbook you add makes the agent better the next time. Every template makes the output more consistent. Every safety rule makes reckless changes less likely. Every operating note turns one hard-earned lesson into reusable judgment.
This is where I think a lot of marketers are going to end up.
Not because GitHub is cute.
Because the real asset is not the prompt.
The real asset is the operating system.
If you have spent years learning how to manage ads, write it down in a way an agent can use.
If you run an agency, this is how you make junior people better faster.
If you are a growth lead, this is how you teach your team how you think.
If you are a founder, this is how you stop depending on one person remembering how everything works.
Use it as a starting point
You can clone it here:
github.com/nickyc1/google-ads-agent-playbook
Use it as the starting point for your own Google Ads agent.
Don't treat it like gospel.
That would be weird. Also, please do not let my repo become your new Google rep.
Take the structure, add your own business rules, add your own measurement truth, add your own product economics, and make it specific to your account.
That is where this gets powerful.
The agent does not need to be magical.
It needs access, context, and judgment.
The access lets it pull the numbers.
The context tells it what matters.
The judgment keeps the agent from learning Google Ads the slow, expensive way.