How to Build an AI System for Google Ads Without Coding

"Just drop Claude on top of your Google Ads account, add an MCP server, and you're done."

You've seen that post, and everyone and their mother is telling you it's that easy. It's not.

When I build a single good Google Ads skill, one that does one thing well, it takes me half a day, and not because the code is hard. It's because I'm pulling from 4-5 docs, checklists, mental models and SOPs just to teach the AI how to write one decent ad. The code was never the bottleneck.

So when people ask "how do I build an AI system for Google Ads without coding," the honest answer is: the no-code part is easy. The AI writes the logic. You describe what you want in plain English. The hard part is everything most agencies skip.

Let me walk you through what actually matters.

The thing nobody tells you: it's a documentation problem

Here's the test that tells you if you're ready. Is there a doc, a single place you can point Claude to so it writes an RSA the way you write RSAs? Not generic best practice, but your way, with your structure, your angles and your rules.

If yes, you're ready to build, and if no, you're not. Most agencies are not.

This is why the AI slop happens, because people expect the model to read their mind and it can't. An AI system is only as good as the context you feed it, and if that context only lives in your head, it doesn't exist. I wrote a whole post on why everything is a markdown file now, but the short version is: write down how you work first. That's step zero.

The three layers of a Google Ads account

The beauty of Google Ads is that execution happens in layers. Once you see them, the build makes sense.

Layer 1: best practices. The things that are true in every account, like good tracking, sane structure and no broken conversion actions. The AI mostly knows this already.

Layer 2: how you do things. This is your moat, the reason a client picks you over me. The model does not know this, so you have to give it.

Layer 3: the business. The account serves a business, which means margins, contribution margin, and what a conversion is actually worth. This is the hardest context to get into the system, and also the most valuable.

The trap is thinking the AI handles all three out of the box. It handles Layer 1 well, Layer 2 only if you've documented it, and Layer 3 only if you've wired in the data. Your job is to build Layer 2 and Layer 3 so the agent stops guessing and starts reasoning from real ground truth. More on building that context system here.

Clean folders are not optional

Before any building, sort your files, because files are the memory of the system. A messy folder means the AI burns its attention searching instead of thinking. I learned this the slow way, and now my whole setup is built around it. Your folder structure is wasting Claude's brain covers the why.

For Google Ads, the skeleton I use per client is simple:

Start with business.md. It barely changes and it's just text. That one file does more for output quality than any clever prompt. This is the same structure PPCOS scales across a whole community of accounts, one isolated workspace per client. You can see how that's set up on the PPCOS project page.

Not everything should be AI

Quick reality check before you automate the wrong thing.

If an if function can do the job, use a script, because it's cheaper and faster. Anomaly detection like "spend is too high" or "spend dropped to zero" is a script, and you shouldn't pay an LLM to do arithmetic.

One thing to get out of your head though: determinism was never the thing keeping accounts safe. A script with a wrong assumption runs that wrong assumption perfectly 120 times, silently, in the account, and fails just as confidently as any LLM ever could. Scripts are good for math, not for safety.

You reach for AI when you need to think through something. That's search term clustering by meaning, where synonyms and intent matter, or budget decisions that need to weigh five different sources at once, or feed enrichment for shopping. Those are real AI jobs because a rule tree can't capture them.

So the system isn't "AI does everything." It's "AI does the reasoning, scripts do the math, and you decide which is which."

The actual build: climb the ladder, don't jump

This is the part that matters most, so slow down here.

Don't try to build a self-driving account on day one. You build trust the way an airport adds traffic, where you're the air traffic controller deciding what lands, what takes off, in what shape and when.

Here are the rungs, from safest to scariest:

1. Observe. Ask the AI to read your search terms and tell you what it sees, with no changes and just eyes on the data. Something as simple as "read these search terms and group them by intent" is plane landings only, data coming in and nothing leaving.

2. Recommend. Now it suggests, so you ask "which of these should I negate?" and it hands you a list with reasoning. The system has an opinion, but you have the final say.

3. Simulate. You ask "what happens to spend and conversions if I cut these?" and the AI models the move before anyone touches the account, thinking out loud about the future.

4. Execute. Only once you trust the recommendations does the agent make the change, and even here you keep a blocker.

5. Self-improve. The agent logs what it did and why, so the next run is smarter.

Most people want to start at rung 4, but you should start at rung 1 and spend a week just observing. You'll be shocked how much value sits in observe and recommend alone, before you've given the AI a single ounce of control.

A real example with a real safety gate

Say you want the agent to make budget changes. Here's the flow that makes it safe, no coding required from you:

You read the logic and the CSV, and if it's good you approve and the deterministic file gets pushed. If it's not, you send it back to the agent with notes on what to fix.

The key is that the model has no apply button. It literally can't push a change, it can only write a proposed one to a file, and the deterministic script is what validates it against the hard gates and applies it. Judgment is probabilistic, execution is deterministic, typed, validated and logged. The probabilistic part proposes, the deterministic part decides and either executes or declines.

That's the whole trick, and it's not a dream, it's how I run accounts today. Most people aren't running fully autonomous agents in PPC, and the ones who do only let them loose on small, simple parts of the account. My own setups are half automatic and half setting work done that I review and apply when I want to.

If you want the deeper split on which parts run in your conversation versus their own, I broke that down in skills vs agents in Claude Code.

The honest part

Most of what you build first will be junk. 85% of my AI projects end up in the trash, and that's the process, not a failure. Each dead one teaches the next.

So don't start with the impressive thing, start with the boring task you do every single week. Automate the observe step for that one, climb one rung, then the next.

You don't need to code, you need to know what you do, write it down, keep your folders clean, and hand over control slowly enough that you're never surprised.

The terminal is the new ads editor, and the agencies that win the next two years aren't the ones with the fanciest model. They're the ones who did the boring work of documenting how they actually operate. Do that, and the rest is just describing what you want :D

About Alfred Simon

AI Systems Builder & Coach

I build custom AI systems for marketing teams — search term analysis, ad creation, competitor research, reporting — all automated. I write about context management, AI workflows, and the messy reality of building things with AI. No theory. No hype. Just what actually works after 30+ agents and a very healthy trash pile :D

Want to build something like this for your team? Let's talk.

LinkedInX (Twitter)Get in touch