# Search Engine Marketing meets Marketing Engineering.

By Bryce Liggins · Growth Mind · Updated November 4, 2026

In this playbook, you'll get what you need to start optimizing Google Ads with an AI agent: open-source code and configuration, step-by-step setup instructions for Codex and Claude Code, reusable prompts and workflows, and a complete multi-file brand-workbench starter. Use the guide to connect your account, analyze search terms and ad performance, and manage changes with your approval.

Want to try this? Literally give the link to this page to Claude Cowork or ChatGPT Work and say, “Can we implement this? I want your help.”

Marketing engineering is changing how marketers get work done. With the right tools and connections, work that used to require exports, spreadsheets and development handoffs can happen inside Codex or Claude Code.

Search engine marketing is a very practical example. I can ask Codex to inspect my Google Ads campaigns, analyze search terms, consolidate ad performance and help build a landing page for the next test. By managing in Codex, I can work with inputs from the top to the bottom of the funnel, run more analysis and get more precise direction, all within the same UI.

That changes the economics of managing an account. A tiny $50-a-day account can get a similar level of attention and care that used to be limited to $1,000-a-day-plus accounts simply because of the cost of management.

My three biggest time drains used to be search-term mining, responsive search ad analysis and matching landing-page production. Now, I make all three happen with a conversation, spending my time passing judgment and giving direction instead of clicking buttons.

## What is marketing engineering?

In this playbook, marketing engineering means connecting software, data and AI to execute marketing work against a defined business goal. The marketer supplies the customer understanding, strategy and judgment. The system makes it faster to analyze evidence, prepare changes and check what happened.

For Google Ads, the system combines a brand workbench, account access, MCP connectors and repeatable operating instructions. MCP, or Model Context Protocol, lets an AI agent use connected tools. A Google Ads MCP server makes supported account operations available through those tools.

My working setup uses Codex. Claude Code can connect to the same reporting and management tools; the agent setup guide includes commands for both.

## How AI changes search engine marketing

Here are some of the biggest differences between pre-AI growth marketing and Marketing Engineering.

| Work | Manual process | Agent-assisted process |
| --- | --- | --- |
| Search-term mining | Review weekly or every two weeks; stop when rows fall to roughly 10–50 impressions | Have Codex review my campaigns twice daily, including low-volume terms, and prepare proposed actions |
| Responsive search ad reporting | Join repeated headlines across ad groups with VLOOKUPs and pivot tables | Have Codex consolidate comparable observations in minutes so I can choose the next test |
| Matching landing pages | Move an idea through design and development over a week or two | Build the page alongside the ad and use GitHub and Railway for testing and deployment |
| Conversion and destination monitoring | Discover broken tracking, unavailable pages or disapproved ads during reports and manual spot checks | Check destinations, ad status and measurement signals; flag problems with evidence for review |
| Budget pacing and allocation | Reconcile campaign spend against the plan and manually investigate underdelivery | Forecast pacing, distinguish budget and rank constraints, and prepare reallocation options for review |
| Lead-quality and revenue analysis | Join Ads, analytics and CRM reports periodically | Analyze spend alongside qualified leads, bookings and revenue using verified data connections |
| Change-impact review | Reconstruct account changes before explaining a performance swing | Maintain a dated change log and review subsequent results with conversion lag and other factors in view |

The advantage is how much work gets reviewed and how quickly I can act on it.

If you're a marketing leader sitting through monthly account reviews, ask your team how this work happens between meetings. How much of the search-term report gets inspected? How quickly can a useful finding become a reviewed change or a new landing page?

Those answers tell you more than whether someone says they're using AI.

## What you need to build the workflow

You will create your own Google authorization app. Mine is called Growth Mind Ads Operations. There is also software behind the workflow: a reporting connector and a custom Python MCP server for supported account changes. Don't let this scare you. Your AI agent knows how to set this up for you. It's even easier if you give it browser access.

| Component | Purpose | What to verify |
| --- | --- | --- |
| Brand workbench | Explain the customer, offer, voice and goals | The owner agrees on what the account should accomplish |
| Google Ads and Google Cloud access | Authorize the intended user and accounts | Account permissions, API access and credentials work together |
| Google Ads reporting connector | Retrieve account structure and performance | A successful report identifies the correct account, dates, timezone and currency |
| Management connector | Validate and apply supported changes | Exact operations are reviewed, approved and checked afterward |
| Supported agent client | Run the tools and follow the workflow | The client can discover and call the connector |
| Instructions and a scheduler | Repeat the review and save its results | A real scheduled run succeeds and records what it covered |

Start with Google's [Google Ads MCP repository](https://github.com/googleads/google-ads-mcp) for the reporting connection. Use the separate [Growth Mind management bridge](https://github.com/bryce-liggins/growth-mind-ads-mcp) for supported account changes.

The [agent setup guide](https://github.com/bryce-liggins/growth-mind-ads-mcp/blob/main/docs/AGENT_SETUP.md) provides installation instructions, breaks setup into checkpoints and defines the evidence to save.

## Step 1: Build the brand workbench

Before I let Codex analyze an account, I build the brand workbench. My workbenches span several Markdown files. They hold the customer understanding, product details, strategic decisions and creative judgment that I want the agent to use every time it works on that business.

Sometimes we're chasing profitability. Sometimes we're chasing volume, awareness or reach. I record the goal and why we've chosen it. That direction needs to survive into the recommendations, the ads and the landing pages.

The [multi-file workbench starter](https://github.com/bryce-liggins/growth-mind-ads-mcp/tree/main/examples/brand-workbench) gives you the structure. The [build guide](https://github.com/bryce-liggins/growth-mind-ads-mcp/blob/main/docs/BRAND_WORKBENCH.md) tells your agent how to populate it from your existing materials and your answers.

| File | What goes in it | How it improves the work |
| --- | --- | --- |
| `README.md` | Where to start, business scope, current priorities and open decisions | The agent finds the right context and sees what's changed |
| `offering.md` | What you sell, who qualifies, offer limits, and wanted and unwanted demand | Search-term recommendations reflect the customers and work you want |
| `goals.md` | Business objectives, success criteria, priorities, constraints and tradeoffs | The agent optimizes for the outcome you have chosen |
| `brand-foundations.md` | Customer situations, buying triggers, positioning, differentiation and proof | Ads and pages connect the customer's problem to a credible reason to choose you |
| `taste.md` | Voice, personality, customer nuance and examples you approve or reject, with your reasons | The agent has concrete direction for writing and evaluating creative |
| `visual-system.md` | Typography, colors, layout, imagery and channel-specific rules | Landing pages use your established design system |
| `asset-inventory.md` | Where assets live, how to retrieve and review them, which versions are approved and how they can be used | The agent can find the correct logo, image or editable source |
| `performance.md` | Metric definitions, baselines, conversion lag, measurement gaps and experiment results | Reports use the same definition of success as the business |
| `decisions.md` | Source evidence and dates, what you've decided, why, and what remains unresolved | Your reasoning and corrections carry into future work |

“Confident and approachable” doesn't give an agent much to work with. An actual headline you approved, one you rejected and your explanation of the difference give it something useful. The same applies to customer insight: record the situation that makes someone buy, the objections they raise and the product details that change the answer.

That context changes the search-term review. A competitor search might be unwanted demand in one campaign and exactly what we're pursuing in another. The agent needs the business's decision before it can recommend what to exclude.

You can start without formal brand guidelines. Your agent should ask what you already have, read it, and request permission to learn from your website where needed. Then it should explain the gaps and interview you one question at a time, building the workbench as you answer.

```text
Build or improve my private brand workbench using the linked starter
and build guide. Guide me through the process one question at a time.
Wait for my answer before asking the next question. Reuse answers,
materials and permissions I have already provided.

Start by asking whether I have brand guidelines, an existing workbench
or other business materials to use. If I do, help me share or locate
them and read them first. If I don't, or they leave gaps, ask permission
to review and scrape my official website. Ask for the URL if needed.
If I decline or you can't access it, continue with my answers.

Summarize what you've learned and the gaps that remain. Interview me
one question at a time to fill them. Cover the customer and buying
situation, offering and limits, goals and tradeoffs, voice and examples,
visual direction and assets, performance definitions and constraints.
Ask for my reasoning and real examples when they would clarify a choice.
Don't ask me to repeat information you already have or send a long form.

Build the linked Markdown files as we go. Preserve my language and
reasoning, source dates and decisions. Label confirmed facts,
observations, proposals and unknowns. Don't treat website copy as my
confirmed strategy. Keep a list of unresolved gaps so we can resume.

Show me the resulting workbench and ask what needs correcting or adding.
Before account recommendations, confirm the objective, success metric,
demand policy and constraints. Show a sample search-term decision and
an ad or landing-page brief grounded in the workbench.
Keep my completed workbench private. Do not make account changes.
```

**Expected output:** a linked folder of usable business context, with source evidence, owner decisions and explicit gaps. The agent starts at the README and loads the files relevant to the job. A search-term review needs the offering, goals and demand policy; a landing page also needs taste, visual rules, assets and measurement requirements.

Keep it current as you work. When I correct the agent, that correction and my reasoning should go back into the relevant file. The next review should benefit from the decision we already made.

## Step 2: Connect Google Ads and verify access

Google API access, OAuth authorization and the MCP connector are separate parts of setup. The connector needs permission to read the intended account; installing it alone doesn't establish that access.

Follow the [Google setup checkpoints](https://github.com/bryce-liggins/growth-mind-ads-mcp/blob/main/docs/GOOGLE_SETUP.md). Create your own app, record the login manager and target account separately, and keep credentials in private local storage. Before recurring reviews, move an External app out of Testing and into production, or use Internal for an eligible organization-only app. Testing authorizations for Ads expire after seven days. Production removes that restriction; it does not create a fixed 180-day token. The guide includes authentication health checks and alert handling.

Google's MCP now includes tools that can change assets and labels. Use the [reporting-only configuration](https://github.com/bryce-liggins/growth-mind-ads-mcp/blob/main/docs/REPORTING.md) to disable them and verify the actual tool list. Then follow the [Codex or Claude Code connection instructions](https://github.com/bryce-liggins/growth-mind-ads-mcp/blob/main/docs/CLIENTS.md).

```text
Use the reporting connector to identify the selected Google Ads account.
Return its customer ID, name, timezone and currency.
Retrieve a small campaign report for a stated date range.
Confirm which account was queried and whether any data was missing.
Do not make account changes.
```

**Expected output:** an account identity check and a successful report. If the account is wrong or access fails, resolve that before doing any analysis.

Congratulations. You can now start managing your Google Ads with your AI agent. Tell it about your workflows, the KPIs you care about and the decisions you make, then build your own skills. Start with analysis and recommendations; account changes follow the approval process in Step 6. Some of my favorites are below.

## Step 3: Review search terms and prepare exclusions

When a search-term report had thousands of rows, I would usually stop reviewing once I got down to roughly 10–50 impressions. I'd run that review once a week, sometimes once every two weeks.

I would have caught many of the same mismatches Codex finds. It would have taken me longer.

Now Codex reviews my campaigns twice a day, regardless of how much they're spending. It can inspect the low-volume terms that were hard to justify reviewing manually and bring the mismatches to me sooner.

```text
Read the brand workbench first. If the goal, demand policy or scope is
unclear, interview me one question at a time before the affected recommendations.
Reuse saved answers and record any clarified business rules.
Review every search-term row returned
for the agreed date range, without an impression or spend cutoff.
Group terms by intent and flag mismatches with the offering or goals.
For each proposed exclusion, show the observed search, reason,
negative keyword, match type, account scope and demand it could block.
Check existing negatives and identify possible conflicts.
Separate clear business mismatches from weak performance evidence.
Save the review queue. Do not apply changes.
Report dates, row count, coverage limits and missing data.
```

**Expected output:** a review queue with specific proposed actions and business reasons. “All rows returned” means the data Google makes available, not every search that ever triggered an ad.

My judgment changes what happens next. If Codex finds a competitor name with a long tail, it often proposes blocking that exact search. If we don't want that competitor's traffic, I hit it with a sledgehammer: exclude the competitor name as a phrase-match negative.

| Fictional search | Narrow proposal | Decision to review |
| --- | --- | --- |
| `Northstar Drain phone number` | Exclude that exact query | If competitor demand is unwanted, consider `northstar drain` as a phrase negative at the appropriate scope |

The broader exclusion reflects a business decision. Another company might want competitor traffic. Phrase negatives also don't automatically cover every spelling or close variant. [Google's negative keyword guidance](https://support.google.com/google-ads/answer/2453972?hl=en).

Use the [tested search-term query](https://github.com/bryce-liggins/growth-mind-ads-mcp/blob/main/docs/QUERIES.md#search-terms) to get started. The [negative-keyword examples](https://github.com/bryce-liggins/growth-mind-ads-mcp/blob/main/docs/OPERATIONS.md#campaign-level-phrase-negative) cover a campaign-level phrase negative and a shared negative list.

## Step 4: Analyze responsive search ads across ad groups

Responsive search ads combine multiple headlines and descriptions. Understanding which messages are working can turn into a substantial spreadsheet project.

I pull the data across my ads and combine repeated headlines across ad groups. A value proposition or CTA headline may appear in several places. Consolidating those observations helps me spot patterns sooner than waiting for each individual occurrence to accumulate enough volume.

Previously, I'd build VLOOKUPs and pivot tables to join the information. Codex can prepare that analysis in a couple of minutes.

```text
Read the workbench's goals and performance definitions. Ask me one
question at a time about missing objectives or comparison scope.
Use saved voice examples; ask about gaps before proposing new creative.
Analyze responsive search ad assets for the agreed reporting period.
Group identical headlines and descriptions within comparable campaigns.
Preserve account, campaign, ad group, ad, asset, field type and pinning context.
Deduplicate source observations before aggregating.
Where supported, combine impressions, clicks, cost and conversions;
calculate CTR from total clicks / total impressions and CPA from
total cost / total conversions. Do not average row-level ratios.
Label unavailable metrics and zero denominators explicitly.
Show pooled observations alongside their original context.
Identify messages worth testing and explain the evidence limits.
Do not call these results isolated proof of a headline's effect.
```

**Expected output:** a message-level review table and proposed tests. Asset metrics can overlap because multiple assets appear together. Google describes asset-level ratios as directional; don't add different assets together and call that the campaign total. [Google's asset-report guidance](https://support.google.com/google-ads/answer/9564897?hl=en).

Finding a winner still leaves you with the job of writing an ad that can beat it. I use Codex as a sparring partner for opportunities and phrasing. The best-performing ads in my own work are still ads I'm writing myself.

The [RSA starter query](https://github.com/bryce-liggins/growth-mind-ads-mcp/blob/main/docs/QUERIES.md#responsive-search-ad-assets) retrieves the asset text, ad relationship and performance metrics. Start with its small connection check, then expand the report to your agreed scope.

## Step 5: Build a landing page that matches the ad

A new target keyword or ad group can need a different landing-page experience. The page should carry through the offer, message and action promised in the ad.

That used to mean a week or two of design and development, or working within a landing-page builder's constraints. Now I can create the matching page alongside the ad and use GitHub and Railway for deployment, with automated tests in the process.

```text
Read the brand workbench, target search intent and proposed ad.
If the offer, audience, conversion, voice, design or available assets
are unclear, interview me one question at a time to fill those gaps.
Use existing answers and save my clarifications in the workbench.
Then draft a matching landing page. Preserve the offer and intended conversion.
Define behavior capture, completed-conversion tracking and attribution.
Prepare the implementation and tests in the website repository.
Show the page and the test results before requesting release approval.
Verify that the completed action reaches its destination and retains
the permitted attribution data. Report any missing measurement.
```

**Expected output:** a reviewable page with a working conversion path and measurement evidence. A passing build alone doesn't prove that a form submission arrived or that attribution survived.

**Bonus:** Tell your agent this is a landing page for SEM and will be assessed by Google's ads crawler. Give it this instruction:

```text
Build this page for paid search. Make the content relevant to the keyword
and ad promise, easy to navigate on mobile and fast to load.
Use clear semantic HTML, accessible markup and a crawlable page structure.
Check that Google's ads crawler can reach the content and destination.
Apply relevant technical best practices to support a strong landing-page
experience, then show me what you tested and what still needs work.
```

Google evaluates landing-page relevance and usefulness as part of ad quality. Quality Score reports a diagnostic of that experience; markup alone doesn't guarantee a higher score. [Google's Quality Score guidance](https://support.google.com/google-ads/answer/6167118?hl=en).


## Step 6: Approve changes and verify the account

My management workflow follows this sequence:

**Read → analyze → prepare → validate → approve → apply → read back.**

The review should identify the account, exact operations, affected campaigns or ad groups, reason for the change and expected result. Approval applies to that specific batch. A changed proposal needs another review.

The custom bridge validates supported operations and records successful and failed attempts. Configure your agent host to ask before either apply tool; the [client guide](https://github.com/bryce-liggins/growth-mind-ads-mcp/blob/main/docs/CLIENTS.md#claude-code-require-a-human-at-both-apply-tools) provides the exact Claude permission rules. A validation ticket alone is not proof that a person approved. New campaigns, ad groups, ads and positive keyword criteria start paused. After an approved operation, the agent reads the account again to check that the intended change exists.

**Expected output:** a change record with validation, approval, application result and readback evidence. Creating an object and turning it on are separate decisions.

Once the manual workflow works, configure recurring reviews. My cadence is twice daily. The [schedule recipes](https://github.com/bryce-liggins/growth-mind-ads-mcp/blob/main/docs/SCHEDULING.md) walk through Codex and Claude Code setups, including the prompt, timezone, reporting-only tools, authentication alerts and first-run check.

Scheduled reviews save a proposal queue. They do not load the management bridge or generate approval tickets. When you return, your interactive session checks current account state and validates the proposal again. Tickets live inside one server process; a new session usually needs a new ticket, even before the eight-hour limit. That keeps the approval tied to the change you are reviewing now.

## Connect keyword research, website behavior and CRM outcomes

The next extension connects more of the customer journey to the same working process:

| Source | Question it helps answer | Required context |
| --- | --- | --- |
| DataForSEO | What keyword opportunities should we investigate? | Market, language, intent and estimated demand |
| Google Search Console | Which searches already bring organic visibility and clicks? | Property, query, page, dates and available coverage |
| Landing-page tools and repository | Can we create an experience for that intent? | Offer, ad, destination, conversion and release process |
| PostHog | What happens after someone reaches the website? | Events, consent, attribution and conversion steps |
| CRM | Do leads become qualified opportunities or customers? | Lead identity mapping, stages, revenue definitions and time lag |

This is how the workflow can move beyond ad clicks and toward down-funnel performance. Each connection needs its own test. A form submission, booked appointment and paying customer are different outcomes; don't combine them under one conversion label.

The [workflow recipes](https://github.com/bryce-liggins/growth-mind-ads-mcp/blob/main/docs/WORKFLOWS.md) specify what each connection should produce. These extensions need account-specific implementation and verification.

## Give the playbook to your AI agent

Copy this prompt into your AI agent. It includes the playbook and agent setup guide URLs:

```text
Help me implement this Google Ads marketing-engineering workflow.
Read both documents in full before starting:

Playbook (Markdown):
https://growth-mind.com/blog/search-engine-marketing-meets-marketing-engineering.md

Agent setup guide:
https://raw.githubusercontent.com/bryce-liggins/growth-mind-ads-mcp/main/docs/AGENT_SETUP.md

Inspect my environment and reuse working authorized connections.
Guide me through the brand workbench setup in Step 1: start with existing
guidelines or materials, ask permission for website research where needed,
then interview me one question at a time to fill the remaining gaps.
Wait for each answer, reuse what we already know and save progress as we go.
Work through the setup checkpoints and save evidence for each result.
Never request secret values in chat.
Complete read-only verification before preparing account changes.
Hold live changes for approval of the exact account and operation batch.
Report missing release assets or unsupported client routes explicitly.
Do not invent a download URL or say a step passed without testing it.
Leave a progress record another agent can resume.
```

The [open-source package](https://github.com/bryce-liggins/growth-mind-ads-mcp) includes the management code, locked dependencies, tests, installation commands and agent setup instructions. A clean local installation and tool-discovery test have passed. Your agent should still verify your Google access, selected client and connected data sources, then record the results.

## Frequently asked questions

### Is Growth Mind Ads Operations software or a Google configuration?

Both configuration and software are involved. The name identifies my Google authorization app. You create your own app and use your own credentials. The workflow also uses a reporting connector, a custom Python MCP management server, business context and operating instructions.

### Can I manage Google Ads with Claude Code instead of Codex?

Yes. Both reporting and management server registrations connected successfully in an isolated Claude Code setup. The [client guide](https://github.com/bryce-liggins/growth-mind-ads-mcp/blob/main/docs/CLIENTS.md) includes both commands and the human-approval rules. Your own Google login, account permissions and approval prompts still need verification; connection testing is not a live-write test.

### Does this work for both small and large Google Ads accounts?

Yes. Smaller accounts gain access to attention and analysis that used to be hard to justify at their budget. Larger accounts can get even more value: more campaigns, search terms, ads and conversion data give the agent more to analyze and the marketer more opportunities to act. This workflow makes detailed review practical at the small end and helps teams handle complexity at the large end.

### Do I need my own Google access and privacy policy?

You need authorized access to your own accounts and a correctly configured application. Its documentation must describe your actual operator, data use and deployment. The [Google and privacy checkpoints](https://github.com/bryce-liggins/growth-mind-ads-mcp/blob/main/docs/PRIVACY.md) explain what to establish; copying Growth Mind's identity or policy doesn't grant access or approval.

### Is the management code open source?

Yes. The [Growth Mind management bridge](https://github.com/bryce-liggins/growth-mind-ads-mcp) is available under the MIT license, with setup documentation and tests. You supply your own Google access and credentials. Google's reporting MCP is a separate component.

## Get help implementing the workflow

You can use this playbook to understand the approach, work through it with your team or build with your own agent using the agent setup guide.

If you don't want to do this all yourself and you're nervous about the process, [let's talk](/contact?interest=partner). I can help you through it.
