Run AI Agents Like a Team: Lessons from Claude Code

Most teams treat AI like autocomplete. Boris Cherny (the creator and head of Claude Code) treats it like a staffed engineering org—and his workflow is making developers rethink what “one person’s output” even means.

The part that matters for Agentic Marketing isn’t which model he uses or which terminal he prefers. It’s the operating pattern: multiple autonomous agents working in parallel, guided by lightweight human direction, and improved through a tight feedback loop. That pattern is exactly what modern growth teams are starting to build: AI agents that plan, execute, verify, and learn.

If you’re experimenting with agentic marketing systems (or you’re about to), you’ll get more value by copying the shape of Cherny’s workflow than by copying any specific tool. I’ll break down what’s happening, why it works, and how to apply the same ideas to marketing workflows—especially if your goal is leads.

If you want a practical way to turn these ideas into a working agent stack, start here: agentic marketing systems.

The real shift: from “assistant” to “workforce”

The core idea is simple: stop running tasks in a single file, single chat, single queue. Start running multiple agents concurrently, each owning a workstream. Cherny described running five instances in parallel, each in its own tab, plus more in the browser. That’s not a gimmick—it’s an org chart.

In agentic marketing terms, it’s the difference between:

• One AI helping you write an email
• A system where one agent drafts the email, another checks brand voice, a third validates claims against approved sources, and a fourth monitors performance after it’s sent

A lot of “AI marketing” disappoints because it’s trapped in the inner loop: generate → edit → generate → edit. Parallel agents move you into an outer loop: plan → execute → verify → learn.

Why parallel agents beat “one big prompt”

Parallelism changes your bottleneck. In most teams, the bottleneck isn’t ideation—it’s the messy middle:

• collecting inputs
• aligning stakeholders
• QA and compliance
• implementation details
• checking that the thing actually works

A single mega-prompt can’t own all that without turning into a fragile, hard-to-debug blob. Multiple specialized agents can.

Snippet-worthy rule: When work has multiple failure modes, you want multiple agents—each watching for a different type of failure.

Copy this: the “5-tab” model for marketing execution

Cherny’s “five Claudes in parallel” maps cleanly to a marketing team’s day-to-day. Here’s a version I’ve used that holds up under real deadlines.

A practical agent lineup (lead-gen edition)

Run 4–6 agents at once. Give each a narrow mandate, a definition of done, and a way to verify.

1. Strategy Agent (Planner)

   • Inputs: ICP, offer, channel constraints, budget
   • Output: campaign brief + hypotheses + success metrics

2. Production Agent (Builder)

   • Output: landing page copy variants, ad drafts, email sequences, UTM plan

3. Compliance/Claims Agent (Skeptic)

   • Output: flagged claims, required disclaimers, “prove-it” checklist

4. Analytics Agent (Instrumenter)

   • Output: tracking plan, event schema, dashboards, attribution assumptions

5. QA/Verification Agent (Tester)

   • Output: link checks, form tests, mobile issues, page speed notes, broken-step report

You (the human) act like Cherny does: short steering inputs, not constant micro-editing. Your job becomes prioritization and taste, not keystrokes.

If you’re building these systems internally, the fastest path is to standardize the “handoffs” between agents—what they produce, how they name things, where outputs live. That’s where most teams lose time.

For a blueprint approach to orchestrating agents across planning, content, and optimization, see how we structure agent workflows.

The counterintuitive performance trick: pick “slower” intelligence

Cherny’s most useful claim is also the least intuitive: he prefers a slower, heavier model because it reduces correction time.

Marketing teams fall into the same trap as dev teams: they optimize for speed of generation instead of speed of shipping. A fast model that produces “pretty good” copy can still be expensive if it creates:

• compliance rework
• brand voice drift
• inconsistent offers
• broken links and mismatched UTMs
• performance analysis that’s numerically wrong (this happens more than teams admit)

Operational stance: Token speed is rarely your bottleneck. Human correction is.

How to decide which model belongs where

A simple allocation rule:

• Use your “smartest” model for planning, reasoning, and verification (high consequence)
• Use smaller models for bulk production (low consequence) once guardrails exist

In lead-gen, the highest consequence work is usually:

• offer positioning
• claims and proof
• targeting logic
• measurement and attribution assumptions

If an agent is allowed to make or break these, give it the strongest reasoning you can afford.

The CLAUDE.md idea is the missing piece in most agentic marketing stacks

The most transferable part of Cherny’s workflow is the shared instruction file: a living document where every AI mistake becomes a rule.

Most marketing teams are stuck in “prompt amnesia.” They repeat the same feedback:

• “Don’t say ‘best-in-class’.”
• “We never mention that feature.”
• “Use our POV on agentic marketing.”
• “Our landing pages always have one CTA above the fold.”

Then they repeat it again next week.

Create your own “MARKETING.md” (and keep it in source control)

For marketing, I recommend a repo (or shared workspace) file that functions like CLAUDE.md. Call it:

• MARKETING.md, BRAND_RULES.md, or AGENT_PLAYBOOK.md

Update it whenever an agent output is wrong. Not when it’s bad—when it’s predictably wrong.

Include:

• Voice rules (what to say, what not to say)
• Proof policy (what needs a source, what can be opinion)
• Offer + ICP canonical phrasing
• SEO rules (keyword patterns, internal linking norms)
• Formatting templates (landing page sections, email structure)
• Compliance rules (regulated language, disclaimers)

Snippet-worthy rule: If feedback repeats twice, it belongs in the instruction file—not in your head.

This is how agentic marketing becomes self-optimizing instead of “AI-powered busywork.”

Slash commands for marketers: automate the boring, protect the quality

Cherny uses slash commands to compress multi-step actions into single invocations (e.g., a commit/push/PR flow). Marketing has the same repetitive bureaucracy:

• create campaign folder structure
• generate UTMs consistently
• produce 3 ad variants per angle
• add tracking pixels / events
• publish to CMS with metadata
• run pre-flight QA

Examples of marketer-friendly “slash commands”

If your agent framework supports it (or you’re building it), create commands like:

• /campaign-brief → produces a one-page brief + hypotheses
• /landing-page-v1 → drafts page with headline variants + FAQ + CTA
• /ad-variants → generates 10 ads constrained by platform limits
• /utm-plan → outputs a full UTM matrix + naming conventions
• /preflight-qa → checks links, forms, tracking, mobile layout, page speed
• /weekly-growth-report → pulls results + highlights anomalies + actions

This is where teams start feeling that “RTS game” effect developers described: you’re not manually doing the clicks—you’re directing units.

Verification loops: the difference between “content” and “outcomes”

Verification is the part marketers skip, then pay for later.

Cherny’s point was blunt: when the agent can test its own work—running suites, automating browsers—the quality goes up dramatically. Marketing has verification loops too, and they’re not optional if you want reliable lead flow.

What verification looks like in agentic marketing

A solid verification loop includes:

• Technical QA: page loads, forms submit, thank-you page triggers, pixels fire
• Measurement QA: events and conversions match the funnel stages
• Message QA: claims match approved proof, no forbidden language, voice match
• Performance QA: spend, CTR, CVR anomalies detected early

A practical lead-gen loop (daily):

1. Agent checks spend pacing vs. plan
2. Agent reviews top search queries / placements (if applicable)
3. Agent flags landing-page issues (speed, broken form, tracking failure)
4. Agent proposes 1–3 changes with expected impact
5. Human approves the change set (not the entire analysis)

Snippet-worthy rule: If an agent can’t verify, it’s guessing. If it can verify, it’s improving.

“People also ask” (quick answers)

What is agentic marketing, in plain English?

Agentic marketing is a system where AI agents make decisions and take actions—planning campaigns, producing assets, running tests, and adjusting based on results—with minimal human supervision.

Do you need five agents to start?

No. Start with two: Builder (creates assets) and Verifier (tests/QA + measurement checks). Add a Planner once you trust outputs.

What’s the biggest risk when teams adopt autonomous agents?

Shipping unverified work. The fastest way to lose trust internally is an agent that publishes wrong claims, breaks tracking, or misreports performance.

What to do this week (a realistic rollout plan)

Most companies get stuck because they try to “AI transform” everything at once. Don’t.

Here’s a rollout that works in a normal week:

1. Write your instruction file (MARKETING.md) with 20 rules you already enforce manually.
2. Spin up 3 agents: Planner, Builder, Verifier.
3. Pick one funnel (one offer, one audience, one channel).
4. Define verification (forms, tracking, claims, reporting) before you generate volume.
5. Log mistakes as rules every time something goes wrong.

If you do only that, you’ll feel the compounding effect within two weeks.

If you want help designing the orchestration, verification loops, and “learning file” so your agents get better over time, 3L3C’s agentic marketing approach is built around exactly these patterns.

The developers losing their minds over Claude Code aren’t reacting to a clever prompt. They’re reacting to a new management style for digital work.

When your marketing system can run parallel workstreams, verify its own outputs, and learn from mistakes, the question stops being “Can AI write our ads?” and becomes: what would you build if execution stopped being the constraint?