Claude Code for Growth: Complete Masterclass with James McAulay

Context

James McAulay led Creator Growth at ElevenLabs and now runs his own business largely from a Claude Code setup. The episode is about using AI agents for growth work that PMs often struggle to prioritize: SEO, analytics, experiment design, landing pages, and launch execution. The important product lesson is not that agents do growth for you. It is how to build a goal-linked operating system so AI work stays tied to customer demand, measurable outcomes, and documented learning. That matters most for PMs and founders who own growth but do not have a dedicated team behind them.

The Big Idea

AI now lets one PM or growth lead do work that used to require an agency, a backlog, and engineering time. The real advantage comes from pairing that speed with a system that keeps every session tied to goals, pulls live data into every experiment, and forces every test to end in a learning.

James's setup is intentionally less about flashy autonomy and more about disciplined leverage. He uses Claude Code as a growth operating system: connected tools, reusable skills, weekly reviews, and critic agents that challenge plans before time gets wasted.

Key Insights

One folder runs growth

• James runs growth from a single Claude Code folder that holds goals, context files, skills, tool connections, and recurring routines.
• The point is not file organization for its own sake. The point is that any agent entering the folder can immediately see the mission, current experiments, analytics setup, and past learnings.
• James's tool selection rule is practical: prefer tools with solid APIs or CLIs so the agent can actually read data and act on it, not just generate advice around a black box.

Goals must steer sessions

• James uses a goal cascade: yearly mission, quarterly OKRs, monthly review, weekly retro, and daily standup.
• He adds a session hook so Claude sees the current mission at the start of every session and can push back when work drifts.
• That matters because AI makes side quests cheap. James's point is that the limiting factor is no longer can we build it, but is this the highest-leverage thing to build.

Weekly retros catch drift

The weekly retro is the routine James treats as non-negotiable. Claude combines James's own reflection with real data from tools like Stripe, PostHog, Xero, and Atio, then checks whether the week matched the stated goals. James said the retro exposed a pattern where outreach and marketing tasks kept going stale while GitHub showed he had spent time refactoring product areas that were fun but unnecessary. For a PM, that is the useful role of AI as a mirror: not replacing judgment, but catching behavior that contradicts your stated priorities.

Disciplined tests need live data

• James starts experiments from a template that includes a hypothesis, baseline, primary metric, confounders, and stop conditions.
• He strongly argues that numbers like baseline conversion rate and traffic should come straight from analytics tools such as PostHog, Mixpanel, or Amplitude, not from manual guesswork.
• He also built routines that flag finished or stale experiments, so every test gets formally closed and written up instead of disappearing into a forgotten dashboard.

Cheap APIs compress SEO

James's SEO workflow shows how much growth work has collapsed from weeks into hours. He wires Claude Code to Firecrawl to read websites, DataForSEO for low-cost keyword research, and the Lighthouse CLI for page-speed analysis. In the episode he ran the audit live on Aakash Gupta's site, found crawlability issues, missing meta descriptions, long titles, duplication, and speed-related opportunities, then argued that the same report can be handed straight to an agent in the repo to make the fixes. His comparison was explicit: work that once meant paying an SEO agency, waiting weeks for a report, and then waiting again for engineering can now be done in a single workflow.

Critics improve plans early

• James runs a skill called multi-agent refine before important builds or major growth plans.
• The skill sends a plan to 3 to 10 critic agents, each using a different lens such as feasibility, measurement quality, simplicity, technical correctness, or missing angles.
• The specific critic James finds most valuable is the missing-angle critic, because teams often do not know what they have failed to consider.
• He also notes a practical constraint: use lighter subagents like Sonnet or Opus to avoid burning through limits.

Clean events scale analysis

James described a very unglamorous but high-leverage task: defining analytics events properly. He had Claude write definitions for roughly 350 PostHog events in about two hours, including when each event fires, where it fires, and what it should be used to measure. He also added a CI check so code cannot merge without the required tracking. For PMs, the lesson is that clean instrumentation is no longer an aspirational cleanup project. With agents, it can become a fast prerequisite for self-serve analysis, reliable funnel measurement, and clearer handoffs to contractors or growth partners.

Mental Models & Frameworks

Goal cascade

• James links every time horizon together: yearly mission, quarterly OKRs, monthly review, weekly retro, and daily standup.
• Use the model when AI work starts to feel busy but unmoored. The cascade asks a simple question at each layer: how does today's task support this week's priorities, this month's plan, this quarter's OKRs, and the annual mission?
• James uses a session hook so the agent sees that chain automatically rather than relying on the user to restate it every time.

Experiment closure loop

• The framework is simple: every experiment starts with a written hypothesis and ends with a documented learning.
• James bakes the loop into templates and recurring reviews so the system can flag experiments that finished, ran stale, or never got a conclusion.
• Use it when a team runs many tests but cannot answer, six weeks later, what was learned or why the next experiment was chosen.

Multi-agent critic panel

• One agent writes the initial plan. Several critic agents then attack the plan from different angles.
• James ranks the findings P0 to P3 so the output is actionable rather than just noisy.
• Use the critic panel on PRDs, growth plans, and infrastructure changes where the cost of a missed issue is higher than the cost of extra review.
• The core benefit is adversarial pressure before build time, when fixes are still cheap.

Agent-readable tool stack

James's tool heuristic is simple: if an agent cannot read the data or operate the tool through an API or CLI, the tool adds friction instead of leverage. That is why he prefers connected analytics, keyword APIs, repo access, and command-line tools over disconnected UIs. Use this model when choosing growth software, because an impressive dashboard is less valuable than a system an agent can actually work with.

Self-improving prompt system

James repeatedly asks the agent how to improve its own setup, including Claude.md, skills, and prompts. The model is not mystical self-improvement. It is a practical loop where the agent inspects past interactions, reviews documentation, proposes improvements, and then the human decides what to accept. Use it when your AI workflow feels brittle or repetitive, because the agent often spots structure you have not yet externalized.

Decision Principles

Principle: Connect data first

• When: a PM or growth lead is about to design an experiment, build a dashboard, or review conversion performance.
• Why: James argues that baseline conversion, traffic, event behavior, and historical performance should come from live systems like PostHog or Amplitude. Manual estimates make bad experiments look rigorous.

Principle: Review before autonomy

• When: an agent proposes code, a PRD, or a growth plan that will affect production, analytics, or customer-facing pages.
• Why: James is enthusiastic about agent leverage, but he is not claiming that unattended agents already run businesses well. He adds code review, error reporting, and critic passes because speed without review creates silent failure.

Principle: Prefer reusable instrumentation

• When: a team keeps forgetting analytics events, event definitions, or experiment readouts.
• Why: James's answer is to enforce tracking in CI and define events systematically. Reusable guardrails beat reminding people manually on every project.

Trade-offs & Nuance

Autonomy needs human steering

James is careful not to oversell autonomous agents. His setup is closer to an operating system than a self-running company. Some tasks run on schedules, such as a weekly SEO regression check, but most valuable work still starts with a human prompt and ends with human review. For PMs, the trade-off is clear: more autonomy sounds appealing, but directed agents often produce better work than always-on agents burning tokens without enough context.

Setup pain buys leverage

• The full onboarding can take up to two hours because Claude interviews the user about goals, role, context, and tools.
• James admits this feels slow and tedious at first.
• His argument is that once the context lives in files, every later session improves. The trade-off is front-loaded setup time in exchange for much better answers across months of work.

Speed still needs guardrails

• James sees AI as removing the wait for engineering on many growth experiments.
• He also says Claude can be confidently wrong and can introduce bugs.
• His response is not to slow down to old speeds. It is to keep speed while adding guardrails such as tests, code review, and Sentry-style error monitoring.

Common Mistakes

Mistake: Building interesting detours

AI makes it easy to build whatever looks fun in the moment. James's example was refactoring product areas that did not matter while outreach and marketing tasks sat untouched. The better approach is to make the agent confront a written mission and current OKRs before a session starts.

Mistake: Leaving tests unfinished

Growth teams often start experiments and never close them. James treats that as lost value twice over: the team wastes the original effort, then loses the learning that should inform the next test. The better approach is a template at the start and a retro process that flags stale or finished experiments until someone documents the result.

Mistake: Keeping tools disconnected

A disconnected stack forces humans to copy data between dashboards, spreadsheets, and prompts. James's advice is to connect every meaningful tool with an API, CLI, or repo access as early as possible. Otherwise the agent stays stuck at the level of generic brainstorming.

Mistake: Trusting code output

James said early excitement with Claude Code can make people believe it can do anything. His experience is that it can also ship bugs and state wrong facts with confidence. The better approach is to treat agent output like a fast junior teammate: powerful, useful, and never exempt from review.

Practical Application

Build a mission file

• Write one short annual mission file for the product or growth area you own.
• Add quarterly OKRs and a current-month focus file in the same repo or working folder.
• Add a session-start instruction so Claude sees the mission and current priorities automatically before every task.
• The value is not documentation for its own sake. The value is getting pushback when a request does not clearly support the mission.

Run Friday retro rigorously

• Reserve one hour every Friday for a Claude-assisted retro.
• Feed the retro both qualitative reflection and live numbers from the tools that matter most, such as revenue, funnel conversion, product usage, or CRM activity.
• Ask the retro to identify stale tasks, repeated avoidance patterns, and work shipped that did not support the week's stated goal.

Template every new experiment

• Create a single experiment template with fields for hypothesis, baseline, primary metric, confounders, stop conditions, and learning.
• Pull the baseline and traffic fields directly from analytics tools instead of filling them by hand.
• Add a weekly check that lists experiments with no conclusion or experiments that ran past their planned stop date.

Turn SEO into workflow

• Connect a crawler, a keyword API, and a page-speed tool to the same agent workflow.
• Run the workflow on your site and on a competitor set, then convert the findings into a PRD inside the repo that owns the website.
• Before build work starts, run a critic pass on the PRD so the fixes are prioritized and testable rather than a loose checklist.

Add event definitions early

• Ask Claude to audit existing analytics events, missing definitions, and inconsistent naming.
• Have Claude draft definitions for each event, including where it fires and what it should be used to measure.
• Add a CI rule that blocks merges when required tracking is missing.
• James used this approach to document about 350 events quickly, which made later funnel analysis far easier.

Questions to Consider

• Where is AI making your team faster at building, but not better at choosing what to build?
• Which recurring product or growth decision still depends on someone manually copying baseline numbers out of analytics instead of pulling them directly from PostHog, Mixpanel, or Amplitude?
• What experiments from the last quarter are still open, undocumented, or impossible to interpret because nobody wrote the hypothesis, confounders, or stop conditions at the start?
• If an agent reviewed your current growth stack, which tools would fail James's test of being usable through an API or CLI rather than only through a human-operated UI?
• What work keeps feeling urgent in weekly planning but keeps going stale in execution, and what would a data-backed Friday retro reveal about that pattern?

Bottom Line

James's real lesson is not that agents can do growth magically. It is that one PM or growth lead can now move much faster if the agent works inside a disciplined system: goals at the top, connected data underneath, critics before build, and a written learning after every experiment. When that system exists, AI stops being a novelty and becomes real operating leverage.

Concepts to Explore

Five Whys

James adapts the Five Whys idea away from root-cause analysis and toward product intent. Instead of only asking why a failure happened, he uses repeated why-questions to test whether a proposed page, feature, or campaign will actually move a meaningful metric. PMs who feel AI is encouraging feature sprawl should explore this technique.

Confounders in experiments

James highlights confounders as a required part of any experiment template. A confounder is any outside factor that can distort the readout, such as seasonality, a pricing change, or a simultaneous campaign. PMs should explore this further because AI can draft a clean-looking test plan that still produces unusable results if confounders are ignored.

Adversarial review

Adversarial review means asking separate agents to attack a plan rather than asking the original agent to self-grade it. James uses this for OKRs, PRDs, and growth plans. PMs can apply the same pattern to roadmap proposals, launch plans, and metric definitions.

Case Studies Mentioned

ElevenLabs launch process

James said ElevenLabs was ahead of the curve on AI in 2025, but much of the launch process still relied on custom GPTs rather than today's more formal skill-based workflows. The lesson is that the operational pattern mattered before the tools matured: codify launch steps, brand voice, and review flows first, then upgrade the tooling as the ecosystem improves.

Live SEO audit demo

During the episode, James ran his SEO audit workflow on Aakash Gupta's site and surfaced practical issues such as missing descriptions, crawlability problems, title length, duplicate elements, and performance opportunities. The useful lesson is not the specific website problem list. It is that a PM can now go from diagnosis to implementation in one chain, instead of splitting the work across an agency report, an engineering queue, and a later prioritization meeting.

Training business launch

James said his current business reached $100K revenue in 95 days without hiring a full-time employee. The relevant product lesson is how he found demand: he tested workshops first, saw strong response, then expanded into cohorts and company training. That is a simple product discovery pattern in business form, starting with a high-touch offer before building a broader system around it.

Tools & Products

People to Follow

James McAulay

James McAulay led Creator Growth at ElevenLabs and now teaches companies how to use AI agents for growth. He is especially relevant for PMs because his examples stay close to real operating work: experiment setup, analytics hygiene, SEO, launch workflows, and day-to-day prioritization.

Corey Haynes

James credits Corey Haynes for a strong set of marketing-oriented skills, especially an SEO audit workflow that James remixed for his own setup. PMs who own acquisition or website growth would likely find Corey's work relevant.

Experiments to Try

Experiment: Scheduled SEO regression

• Hypothesis: a weekly automated SEO and speed check will catch technical regressions earlier than ad hoc manual review.
• Change: connect a crawler, a keyword data source, and Lighthouse CLI to a scheduled workflow.
• Test: run the workflow every week on the same page set and send only meaningful changes to Slack or email.
• Measure: count regressions caught before they appear in traffic or conversion, and track time from detection to fix.

Experiment: Event coverage gate

• Hypothesis: a CI rule that blocks merges without analytics coverage will reduce missing or ambiguous funnel data.
• Change: define the required events for a product area and add a test that fails when code ships without those events.
• Test: apply the rule to one team or one flow first, such as onboarding or checkout.
• Measure: compare missing-event bugs, time spent debugging analytics, and confidence in experiment readouts before and after the rule.

Experiment: Critic panel before build

• Hypothesis: a multi-agent critic pass on PRDs or growth plans will find important gaps before implementation starts.
• Change: run 3 to 5 critic agents with different lenses, including a missing-angle critic, before approving a plan.
• Test: use the critic panel on the next three meaningful initiatives and log what issues it surfaces.
• Measure: track the number of pre-build issues caught, the severity of those issues, and whether downstream rework decreases.