The argument in one line.
A two-layer Claude Code folder architecture separating orchestration (CLAUDE.md) from target-specific detail (YAML per ICP) lets you describe an audience in plain language and get a clean Google Sheet of leads without touching a scraper UI.
Read if. Skip if.
- You run a cold outbound agency and currently export leads manually from Apollo, LinkedIn, or scraper dashboards.
- You have a Claude Pro or Max plan and want to extend it into async business automation beyond coding tasks.
- You want to delegate lead generation to an agent that self-qualifies results before asking you to proceed.
- You manage multiple clients with different ICPs and want a single workspace that keeps each audience isolated.
- You have no cold outbound use case -- the system requires Apify plus Google Cloud credentials.
- You are looking for a no-code tool; this requires terminal comfort and OAuth setup.
- Your leads come from inbound or referrals and you have no need for volume prospecting.
The full version, fast.
The system works by giving Claude Code a two-layer workspace: a CLAUDE.md that defines the agent role, and YAML files per client encoding specific ICP filters. When you ask Claude to scrape leads for a client, it reads the ICP YAML, calls the Apify actor with the right parameters, runs a test batch to self-qualify, then exports to Google Sheets via OAuth credentials.json. Lead generation becomes a background task -- you speak, Claude runs it while you do other work, and a clean sheet appears when done.
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.

01 · Live demo
Full working system shown cold: ICP prompt to Claude, Apify test runs with self-qualification, export to Google Sheets. Viewer sees the end state before any setup.

02 · Prerequisites
Claude Code (Pro/Max plan), terminal choice (Cursor or Antigravity), Apify account ($29/mo), Google Cloud project with Sheets API.

03 · Folder architecture
The two-layer design: CLAUDE.md as root orchestration file, .env for keys, clients/ with per-client README + ICP YAMLs, execution/ with generic Python scripts.

04 · Setting up the scrape
Paste CLAUDE.md into terminal to instantiate folder structure; add lead-scraping skill; supply Apify actor slug and API token via .env.

05 · Google Sheets OAuth
Create Google Cloud project, enable Sheets API, create OAuth desktop client ID, download credentials.json, drop in project folder, complete browser auth flow.

06 · Final result and CTA
Clean lead sheet with industry, job title, email. Instruction to save scripts for reuse. Soft CTA: free Skool resources and paid implementation call.
Lines worth screenshotting.
- Separating orchestration from target configuration lets one Claude Code workspace serve unlimited clients without rewriting prompts.
- Claude Code will self-qualify a test batch before a full run if CLAUDE.md asks for confirmation -- so bad filters surface before you burn API credits.
- The Apify actor slug is the only scraper-specific thing you swap; the Python execution script stays generic across all ICPs.
- Dropping credentials.json in the project root is all Claude needs to authenticate Google Sheets OAuth -- no manual token exchange required.
- The two-layer architecture improves over time: Claude updates skills files after each successful run, making the system more accurate per ICP with use.
- The demo-first video structure (show result at 00:00, explain setup at 06:47) lets skeptical viewers validate the outcome before committing to a 23-minute tutorial.
- Antigravity and Cursor are used purely as terminal UIs -- no paid plan needed since Claude Code runs inside its own terminal context.
- Storing session context in a .tmp file lets Claude carry ICP details across fresh sessions without re-prompting.
- The agency CTA is soft: free resources via Skool first, paid implementation call second -- authority-before-ask structure.
- Running Claude Code with dangerously-skip-permissions means the agent never pauses for approval; safe only once you trust the system.
Build the workspace once, describe the audience every time.
When the agent knows what kind of agent it is, a simple ICP description is all it needs to run a full scrape, qualify results, and deliver a clean sheet.
- Separating orchestration from configuration means the same agent can serve a new client without rewriting any prompts -- just add a new YAML with their ICP.
- A demo-first video structure that shows the finished result before the tutorial lets skeptical viewers confirm the outcome is real before committing to the walkthrough.
- Having Claude run a small test batch and report quality metrics before a full run is a built-in quality gate that catches bad filter configs before you burn API credits.
- Dropping credentials.json in the project root is enough for Claude to handle the full Google OAuth flow -- no manual token management needed.
- Instructing the agent to save scripts to their appropriate locations at the end of a session makes the system compound: each new scrape refines the execution layer for the next one.
Terms worth knowing.
- CLAUDE.md
- A markdown file in the project root that Claude Code reads at session start. It defines the agent purpose, capabilities, and folder conventions.
- Apify
- A cloud platform with over 1,500 pre-built web scrapers (called actors) that extract structured data from websites. Billed per actor run.
- ICP
- Ideal Customer Profile -- the attributes (industry, company size, job titles, location) that define the target audience for a sales outreach campaign.
- Two-layer architecture
- A folder pattern separating generic execution logic (Python scripts) from client-specific configuration (YAML files encoding ICP details), so logic and data never mix.
- credentials.json
- An OAuth client secret file from Google Cloud Console that allows a desktop application to authenticate and write to Google Sheets on your behalf.
- Antigravity
- A terminal application with a built-in AI agent panel. Used here purely as a terminal wrapper for Claude Code -- no paid plan required.
Things they pointed at.
Lines you could clip.
“Claude Code is now my orchestration layer, and it is how I run my business.”
“Things that might have taken all of your focus can now just be running in the background while you are on a call or filming a YouTube video.”
“Once you configure it, it only gets better.”
Word for word.
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
The bait, then the rug-pull.
Every lead list starts the same way: open the scraper, set the filters, wait, export, clean the columns, repeat for every client. David Mendoza collapsed that entire chain into a single natural-language prompt -- and this video shows the working system before explaining how to build it.
Named ideas worth stealing.
Two-Layer Claude Code Architecture
- CLAUDE.md (orchestration)
- .env (credentials)
- clients/<name>/icps/<icp>.yaml (target config)
- execution/<task>.py (generic scripts)
Separates generic execution logic from client-specific ICP configuration so one workspace handles unlimited clients without rewriting prompts.
How they asked for the click.
“If you want to leverage AI inside of your business, go ahead and book a call with me.”
Soft close after the working system is shown; free Skool resources offered first, paid implementation second.










































































