Most teams scale by hiring. We scaled by building.
This is the story of how a 3-person team built a 47-command AI system that deploys complete Google Ads accounts - research, feeds, landing pages, search ads, shopping campaigns, demand gen creative, and reporting - in a single day.
Not a skeleton account. Not a "we'll finish the rest next week" situation. A full deployment with hundreds of live ads, 13 separate shopping feed strategies, pre-sell pages written and deployed, demand gen creative generated across 4 aspect ratios, and campaign architecture designed for compounding performance from day one.
Before we built this system, the same work took us 2-3 weeks. Same deliverables. Same quality. Just humans doing it step by step, file by file, upload by upload.
This article breaks down every phase of the pipeline - what each agent does, why the architecture works the way it does, and how the system compounds over time. Not to show off the tech. To show what becomes possible when you stop hiring for scale and start building for it.
Why Traditional Onboarding Takes 2-3 Weeks
Here's what a standard Google Ads onboarding looks like at most agencies.
Week one is research and setup. A strategist spends 2-3 days analyzing the brand, pulling competitor data, doing keyword research, and building a campaign plan. Then someone else takes the plan and starts building - account structure, extensions, negative keyword lists, audience segments.
Week two is creative and feeds. If the brand runs Shopping, someone manually optimizes the product feed - usually one generic feed with basic title rewrites. Search ad copy gets written, reviewed, revised, approved. If there's a landing page component, that's a separate team with a separate timeline.
Week three (if it happens at all) is launch and QA. Campaigns go live, tracking gets verified, initial optimizations happen.
Three weeks. Multiple handoffs. Multiple people.
The bottleneck isn't talent. It's architecture. Every step depends on the previous step. The feed can't be optimized until research is done. Campaigns can't be built until the feed is deployed. Ads can't be written until landing pages exist.
Sequential execution. That's what makes it slow.
The question we asked: what if every phase could run in parallel, managed by specialized agents that don't need handoffs, don't need sleep, and don't lose context between steps?
Research: 21 Queries, 620 Angles, Zero Assumptions
Every onboarding starts with the /brand-onboard command. One command. What comes out the other side is 65+ files per market.
Here's what actually happens inside that one command.
The system runs 21 research queries per market. Not generic keyword searches. Structured queries across DataForSEO and Brave Search designed to map the entire competitive landscape:
- Brand keyword baseline (volume, CPC, competition for every relevant term)
- Competitor ad copy analysis on both Google and Meta
- SERP structure analysis (who ranks for what, what content types dominate)
- Seasonal patterns and trend data
- Product-level keyword mapping
From those 21 queries, the system builds what we call the angle explosion - taking core product benefits and multiplying them across purchase intents, use cases, audiences, and seasonal contexts.
A typical catalog produces 380-620 angle variations. Each one scored for search volume, competition density, and conversion potential. The top performers become the foundation for everything that follows - feed strategies, ad copy, landing page angles, and campaign structure.
This isn't just data collection. It's the decision layer. The angles that score highest determine which feeds get built, which landing pages get written, and which campaigns get priority budget.
The output includes an 18-section brand guide, a keyword baseline with hundreds of terms, an angle registry with scored angles, 4 RSA foundation files, seasonal calendar, and bid strategy recommendations.
One command. 65+ files. Every strategic decision pre-loaded.
Most agencies do this with a strategist, a spreadsheet, and 2-3 days of manual work. The agent does it in about 40 minutes.
13 Feeds, Not 1: Why We Segment by Purchase Intent
This is the part of the system that takes most people by surprise.
Standard approach: one product feed, basic title optimization, upload to Merchant Center, run Shopping campaigns against it.
Our approach: the product catalog segmented into 13 separate feed strategies, each built around a different purchase intent.
Why 13? Because the same product gets searched 13 different ways, and Google's algorithm treats each variation as a different opportunity. A customer searching "lightweight camping blanket" has different intent than someone searching "emergency survival gear" or "gift for hiker." Same product. Different angle. Different title. Different description. Different keyword priority in the first 70 characters.
The /feed-segment command handles the segmentation. It uses LLM-powered analysis to assign products to keyword pockets based on funnel layer (top, middle, bottom), purchase intent, and search behavior patterns.
Then /feed-rewrite takes each segment and rewrites every product:
- Titles: 140-150 characters, front-loaded with keywords in Zone 1 (first 70 chars where Google's algorithm places the most weight)
- Descriptions: 800-1,100 characters, completely unique per variant - not template-generated, not spun
- Product highlights: Angle-specific benefit statements
- 30+ other GMC attributes: Product type, custom labels, shipping info, all optimized per segment
Every feed runs through a 152-point validation before it touches Merchant Center. The quality threshold is 98/152 (rated STELLAR). Anything below gets auto-fixed - formatting issues, length violations, missing fields - and re-validated until it passes.
All 13 feeds deployed to Google Merchant Center through API - Python scripts that handle the formatting, validation, and upload in one pass.
This part used to take us a full week. The 13-feed strategy alone - the segmentation, the rewrites, the validation, the deployment - was a 5-day process. Now it's hours. Same depth. Same quality. Same 152-point validation. Just faster.
Here's the part most people miss: the 13 feeds aren't just for Shopping. They become the foundation for PMax campaigns, demand gen creative angles, search ad themes, and landing page strategies. Build the feeds right, and everything downstream inherits that intelligence.
Pre-Sell Pages: Building the Mid-Funnel From Scratch
Most Google Ads accounts go straight from ad to product page.
That works for bottom-funnel, high-intent search. But for top-of-funnel and mid-funnel traffic - where you're creating demand, not just capturing it - you need something between the ad and the checkout.
That's what pre-sell pages do. They educate, build trust, and position the product before the visitor lands on the product page. Advertorials, listicles, comparison pages, guides - content that matches the intent behind the search query.
Our system builds these from scratch. The full pipeline:
/presell-discover - Angle discovery through keyword research and SERP analysis. The system identifies which page types (advertorial, listicle, comparison, guide) match the search intent for each product. Output: scored angle recommendations with keyword data.
/presell-write - Full copy generation. 2,000-3,500 words per page, written with brand voice calibration and conversion architecture. Not thin content. Not AI-generated filler. Research-backed copy with specific claims, product data, and conversion architecture.
/presell-build - Production-ready HTML/CSS/JS. Scroll animations. Mobile-first responsive design. Lighthouse scores above 90. Theme extraction from high-performing competitor pages means every build matches proven visual patterns.
/presell-deploy - Deployed to Cloudflare Pages or directly to Shopify as native pages. SSL, global CDN, cross-domain tracking to the store - all configured automatically.
The funnel flow: Ad -> Pre-sell page -> Product page (or offer page) -> Cart -> Checkout.
Each pre-sell page then feeds into its own PMax campaign via /presell-pmax-prep and /presell-pmax-upload. The system generates PMax assets (headlines, descriptions, AI-generated images across multiple aspect ratios) directly from the deployed page content.
This means every pre-sell page becomes its own acquisition channel - with its own campaign, its own budget, its own performance data.
Our research across practitioner forums and Google's own documentation confirmed what we were already seeing: PMax with page feeds is the dominant strategy for scaling pre-sell pages. Demand Gen runs alongside it for top-of-funnel awareness. Search campaigns complement for high-intent informational queries. But PMax does the heavy lifting.
Separate campaigns per page type (advertorial campaign, listicle campaign, comparison campaign) lets us scale what works and pause what doesn't - without campaigns competing against each other.
Offer Pages: Behavioral Economics Built Into the Code
Offer pages sit between the pre-sell and checkout. They present bundle tiers, pricing, and value stacking in a way that's designed to convert.
What makes ours different: Kahneman's behavioral economics principles aren't just applied to the copy. They're built into the code.
The /offer-discover command researches bundle opportunities and designs the tier structure. The /offer-write command generates copy following the offer stack framework. The /offer-build command produces HTML/CSS/JS with interactive tier selection, threshold progress bars, and dynamic CTAs.
Here's what's happening under the hood:
Decoy Effect. The tier structure is engineered so the starter tier is close in price but far in value from the popular tier. This makes the popular tier the "obvious" best choice. Starter exists to make popular look like a steal.
Default Selection. The recommended tier is pre-selected on page load. Pre-selected options are chosen 2-3x more often than non-defaults. The popular tier loads with visual emphasis, social proof ("75% choose this"), and ownership language.
Loss Aversion. Threshold messaging uses loss framing, not gain framing. "Don't miss $28 in savings" hits harder than "Save $28." The progress bar intensifies at 75% and 90% thresholds - urgency increases as the customer gets closer to an unlock.
Peak-End Rule. The selection experience is designed for positive memory: CSS pulse animation on tier selection, haptic feedback on mobile, confirmation toast with "Great choice!" messaging. The end of the interaction shapes how they remember it.
Endowment Effect. Ownership language before purchase: "Your complete kit includes..." not "The bundle includes..." The shift from third-person to possessive changes the psychological relationship with the product.
Every one of these principles is implemented in JavaScript, CSS, and HTML structure. Not as copywriting advice. As functioning code that applies behavioral economics automatically across every offer page the system builds.
The offer page links directly to Shopify via cart URLs. No API integration needed. Each bundle tier maps to a hidden Shopify product variant. Tier selection updates the CTA, the CTA links to /cart/VARIANT_ID:1, and the customer lands in checkout with the right product already in their cart.
The entire offer pipeline - research, copy, build, deploy - runs through 4 commands.
Campaign Architecture: Everything Live on Day One
By this point in the day, we have:
- Research complete (380-620 scored angles)
- 13 feeds deployed to Merchant Center
- Pre-sell pages written, built, and deployed
- Offer pages live with behavioral economics baked in
Now the campaigns.
Brand campaigns. Product URLs matched to ads matched to keyword clusters. Multiple ad groups, each with tight relevance between the landing page, the ad copy, and the keyword set. This isn't "throw it at Smart Bidding and hope." It's structured for Quality Score from the start.
Cold acquisition search campaigns. For top products, each with 3 to 6 ad groups. Same URL x ads x keyword matching structure. RSAs built from the angle research, not generic copy. The /search-ad-create command generates Shopping Domination RSAs - meaning the search ads mirror the Shopping feed angles, so the brand owns more real estate on the same SERP.
Counter-competitor campaigns. Built directly from the competitor research in /brand-onboard. Targeting competitor brand terms with our positioning. We know their ads, their landing pages, their gaps - because we already pulled them in the research phase.
Direct response campaigns for pre-sell pages. Each pre-sell page gets its own campaign structure with matched keywords and custom ad copy.
13 Shopping campaigns with separate segments for keyword data mining. These aren't just for revenue. They're intelligence-gathering instruments. Search term data from Shopping campaigns feeds directly back into feed title improvements and uncovers new angles for additional feeds.
13 PMax feed-only campaigns. One per segment, optimized for performance and scaling.
Demand Gen image campaigns. AI-generated creative across 4 aspect ratios - landscape (1.91:1), square (1:1), portrait (4:5), and Shorts (9:16). The system supports 5 AI models for image generation, from budget options at $0.009/image to premium at $0.134/image. Product images are used as references, and the AI generates lifestyle and contextual variations for each angle.
Demand Gen video campaigns. Existing brand video assets get scanned, analyzed, uploaded to YouTube as unlisted videos, and deployed as in-stream and Shorts campaigns. The system handles batch processing of 200+ video variants with automatic deduplication and rotation management.
Account-level infrastructure runs alongside everything else: sitelinks, callouts, price extensions, structured snippets - all generated and deployed through API. Negative keyword lists across junk terms, brand protection, and competitor segments deployed as shared sets. Placement exclusions across YouTube, Display, and mobile apps.
Everything through API. Everything before the first campaign impression.
The Compounding Loop: Why the System Gets Smarter
Here's what separates this from "fast setup."
Most onboarding processes are linear. Research -> build -> launch -> done. The system produces a static output and then you optimize manually.
This system compounds.
The 13 Shopping campaigns generate search term data from day one. That data feeds directly back into the feed pipeline:
- Search terms reveal new keyword patterns the original research didn't catch
- New patterns suggest new angles for additional feed segments
- New segments get built, validated, and deployed
- New feeds generate new Shopping campaigns
- New campaigns generate new search term data
The optimization feedback loop (/brand-optimize) takes this further. It's a 2-stage system: Stage 1 analyzes performance across all channels - shopping, search, presell, demand gen, organic. Stage 2 detects opportunities and automatically queues new commands:
- Underperforming segments trigger new RSA creation via
/search-ad-create - High-performing angles trigger new presell pages via
/presell-write->/presell-build->/presell-deploy - Gaps in feed coverage trigger new segments via
/feed-segment->/feed-rewrite->/feed-deploy
The system doesn't just run campaigns. It identifies what's working, finds what's missing, and builds more of what works.
The unified reporting command (/brand-report) pulls analytics across every channel in one view - Shopping performance, Search term analysis, presell page metrics, demand gen engagement, PMax asset performance, even Google Search Console organic data. One command, full picture.
This is the part that's hard to explain until you see it running. The account doesn't just launch on day one. It starts learning on day one. And every week it runs, the data layer gets richer, the angles get sharper, and the campaigns get more precise.
The Agent Architecture: 47 Commands, 6 Pipelines
Let me pull back the curtain on how this actually works.
47 commands. Each one handles a specific phase of a specific pipeline. They're not generic AI tools. They're purpose-built agents with 1,500-2,000 lines of instructions, access to Python scripts for API operations, and strict validation contracts that enforce quality standards.
The 6 main pipelines:
Shopping Feed Pipeline (10 commands): From brand research through feed segmentation, rewriting, AI image generation for product photos, validation, and upload to both GMC and Google Ads. Handles Shopping campaigns, PMax campaigns, and the Thief/Protector ad rank strategy.
Search Ads Pipeline (4 commands): Competitor intelligence through the Google Ads Transparency Center, RSA creation with angle-mirrored structure, and upload to Google Ads with keyword match types (phrase + exact only - never broad).
Demand Gen Pipeline (4 commands): Image generation with 5 AI models across 4 aspect ratios, video scanning and YouTube upload, and campaign deployment for both image and video formats.
Pre-Sell Pages Pipeline (8 commands): Angle discovery, copy generation, HTML/CSS/JS build, deployment to Cloudflare or Shopify, PMax asset generation, and campaign upload. Plus theme extraction from competitor pages and GA4 tracking setup.
Offer Pages Pipeline (4 commands): Bundle opportunity research, offer stack copy, interactive page build with behavioral economics, and deployment with Shopify cart integration.
Account Setup Pipeline (5 commands): Extensions (sitelinks, callouts, price, structured snippets), negative keyword lists, and placement exclusions - all generated and deployed through the Google Ads API.
Each agent has strict quality gates. The feed agent won't deploy anything scoring below 98/152 on validation. The presell agent won't build a page without passing copy quality checks. The search ad agent enforces 26-column CSV format and keyword match type restrictions.
They run in parallel where possible. While the feed agent rewrites and validates, the presell agent discovers angles. While the search agent builds RSAs, the demand gen agent generates images. While all of them do their work, I'm on tracking fixes and page tagging.
(The agents build faster than I can configure GTM. I've made my peace with that.)
The system currently manages 16+ brands across 19+ markets - from US-en to DE-de to FR-fr to NL-nl. Every command supports multi-language operation. The research runs in the target language. The feeds get localized. The presell pages get translated. One architecture, every market.
What a Month Looks Like at This Speed
Day one: full deployment. Hundreds of ads live. Pre-sell pages deployed. Demand gen running. 13 Shopping campaigns generating search term data.
Week two: the compounding loop kicks in. Search term data reveals new angles. New feeds get built. Underperforming campaigns get new creative. High-performing pre-sell pages get additional PMax budget.
Week three: the optimization feedback loop starts suggesting new presell pages for gaps the system detected. New offer page variations test different tier structures. Demand gen creative rotates based on performance data.
Week four: the account is operating at a level most teams don't reach in 90 days. Not because we're working harder. Because the system that runs the account was built to learn, compound, and scale without adding headcount.
This is the part that makes the work fun. Not the speed itself - speed is just a side effect of good architecture. The fun part is watching a system you spent years building do in hours what used to take weeks. Watching it find angles you didn't think of. Watching it compound.
3 people. 16+ brands. 19+ markets. 47 commands.
And systems we spent years building.
Gate Scores: insight:11/15 | hook:8/11 | viral:8/10 | authority:5/5 | entertainment:7/10 | info_density:7/10 | composite:7.6
Ruslan co-founded Tegra in 2017. Runs the Google Ads practice - feed, PMax, search, attribution. Writes weekly about the parts of paid search operators are afraid to touch.