Claude Code Workflow: A Playbook for Agentic Teams

Most teams think “AI productivity” means faster drafting. Boris Cherny’s Claude Code workflow shows something different: it’s about running multiple autonomous workstreams at once, then managing the handoffs like a project lead—not a typist.

That’s why developers reacted so strongly to his recent breakdown of how he works. Not because it’s flashy, but because it’s practical. It reads like a checklist for building an “agentic” operating model: parallel agents, shared rules, repeatable commands, and relentless verification.

If you’re following our Agentic Marketing series, this matters for a simple reason: the same patterns that turn one engineer into a small engineering team can turn one marketer into a small growth team—if you build the right loops. If you’re curious what that looks like in practice, start with this agentic workflow lens, then map it to your own execution stack (or get help designing it at 3L3C).

The real shift: from “inner loop” to “fleet control”

Cherny’s biggest lesson is structural: stop treating AI like a single assistant sitting next to you. Treat it like a set of specialized workers you dispatch, monitor, and correct.

Traditional work happens in a linear “inner loop”: write → run → fix → repeat. It’s fine when the bottleneck is typing. But when the bottleneck is decision-making, coordination, and review, linear work collapses.

Cherny’s approach replaces the inner loop with parallel lanes. In his terminal, he runs multiple Claude sessions at once, each assigned to a different task, and uses notifications to know when an agent needs input.

Here’s the agentic principle hiding in plain sight:

Humans shouldn’t do the work. Humans should route the work.

How this maps to agentic marketing

Marketing automation used to mean: “If X happens, send Y email.” Agentic marketing is closer to: “Achieve pipeline goal Z—decide the steps, run them, and report back.”

Parallelization is the first multiplier. A practical mapping looks like this:

• Agent 1: Research (ICP pain points, competitor offers, audience language)
• Agent 2: Production (draft landing page variants, ads, sequences)
• Agent 3: QA (check claims, compliance, brand voice, broken links)
• Agent 4: Ops (UTM plans, campaign setup checklists, naming conventions)
• Agent 5: Analytics (hypotheses, dashboards, next tests)

Most teams try to get one AI chat to do all five. That’s how you get mush.

Why “slower but smarter” wins (most of the time)

Cherny’s counterintuitive stance is one I agree with: use the smartest model you can for core work, even if it’s slower. He argues that a heavier model reduces steering, reduces errors, and—net—finishes faster.

This is the part many orgs miss because they obsess over generation latency. But the actual cost center is human correction time.

A clean way to think about it:

• Token tax: you pay compute to generate output
• Correction tax: you pay human attention to fix output

Smaller/faster models often look cheaper until you measure the correction tax. If your team spends 20 minutes cleaning up a “fast” result, you didn’t save time. You bought rework.

Marketing example: speed that creates rework isn’t speed

If you’re shipping:

• ad copy that triggers compliance rewrites,
• landing pages that don’t match sales reality,
• emails that fail deliverability checks,

…you’re paying correction tax. In lead-gen work, correction tax also shows up as wasted spend and burned audiences.

A good agentic marketing system assigns the highest-reliability model to:

• offer positioning
• claims and proof points
• experiment design
• final QA

Then it uses cheaper/faster models for “volume” tasks like variations and formatting.

The underrated weapon: a shared “rules file” that compounds learning

Claude Code’s CLAUDE.md idea is the most transferable concept in the entire workflow.

Answer first: If you want agents to improve over time, you need a persistent, shared instruction layer that lives with the work.

The problem with most AI use at work is memory fragmentation:

• One person “figures out” a prompt trick
• Another person learns the tool’s quirks
• None of it becomes institutional knowledge

A shared file fixes that. Every time the agent makes a mistake, you turn the mistake into a rule.

Every mistake becomes a policy.

Marketing version: create AGENTS.md (or PLAYBOOK.md)

For agentic marketing teams, I’ve found this file should include specifics like:

• Voice rules: “No hype. No clichés. Use short sentences. Prefer concrete proof.”
• Offer rules: “Never promise outcomes we can’t measure. Always state time-to-value.”
• Compliance rules: “No health/financial guarantees. Avoid ‘best’ claims.”
• Channel rules: “LinkedIn posts must have a strong first line; emails must have one CTA.”
• Measurement rules: “Every campaign needs UTMs + a named hypothesis.”

This is how you stop repeating the same review comments.

If you’re building agentic marketing systems for lead generation, this is also where you encode your pipeline definitions, MQL/SQL criteria, and disqualification logic—so agents don’t optimize the wrong metric. If you want a structured way to implement this across your stack, 3L3C’s agentic workflow approach is a solid starting point.

Slash commands, subagents, and the “packaging” of expertise

Cherny’s workflow includes slash commands (custom shortcuts committed into the repository) and subagents (specialized AI personas for phases of work).

Answer first: Agentic systems scale when expertise is packaged into repeatable interfaces—commands and roles—rather than living in one person’s head.

That’s why slash commands matter. They turn “I know how to do this” into “the system can do this on demand.”

Marketing equivalents that actually save time

You don’t need to be technical to adopt the pattern. You can create “commands” in whatever orchestration layer you use (templates, agent runbooks, internal tools). Useful ones include:

1. /launch-campaign

   • Creates UTM plan
   • Generates ad variations
   • Drafts landing page section copy
   • Produces a QA checklist

2. /prep-weekly-report

   • Pulls spend/leads/pipeline
   • Flags anomalies
   • Writes a narrative: what happened and why

3. /create-test-plan

   • Generates 5 hypotheses
   • Selects primary metric + guardrails
   • Outputs a 2-week experiment calendar

4. /content-repurpose

   • Turns a webinar into: 5 LinkedIn posts, 1 email, 1 landing page section, 10 ad hooks

Subagents: stop asking one agent to be everything

Assign roles so you get consistent outputs:

• Strategist agent: positioning, ICP, hypotheses
• Copy chief agent: headlines, CTAs, structure
• Proof agent: sources, case studies, claim checking
• Ops agent: UTMs, tracking, naming conventions
• QA agent: brand voice, compliance, formatting

One generalist agent tends to average out. Specialized agents sharpen.

Verification loops: the difference between “drafting” and “shipping”

Cherny’s strongest point is also the least glamorous: verification is the unlock. He describes using tools to test changes—running suites, automating browser checks, iterating until the UI works and the UX feels right.

Agentic marketing needs the same discipline.

Answer first: If agents can’t verify outcomes, they’ll optimize for “looks good” instead of “works.”

What verification looks like in marketing

Verification loops should exist at three levels:

1) Pre-flight checks (before launch)

• All links work (including UTMs)
• Forms submit and route correctly
• Thank-you page fires conversion events
• Mobile layout and load time are acceptable

2) Signal checks (first 24–72 hours)

• Are impressions and clicks within expected ranges?
• Is CTR stable across creatives?
• Is CPC exploding due to mismatch?
• Are leads junk because targeting is off?

3) Outcome checks (week 1–4)

• Lead-to-meeting rate
• Meeting-to-SQL rate
• Cost per SQL / cost per pipeline dollar

Here’s my stance: if you can’t measure it, don’t automate it. Automation without verification just scales mistakes.

A practical starter kit: implement this in 10 days

If you want to apply Cherny’s lessons without rebuilding your entire org, do this as a contained sprint.

Days 1–2: Create your shared rules file

• Write AGENTS.md with voice, offer, compliance, and measurement rules
• Add “common mistakes” your team keeps correcting

Days 3–5: Define 3 subagents and their outputs

Pick roles that match your bottlenecks:

• Strategist agent: 1-page campaign brief + hypothesis list
• Copy agent: 10 hooks + 3 landing page variants
• QA agent: compliance + tracking checklist

Days 6–8: Build 2–3 reusable commands/templates

Make them stupidly specific. Good commands are boring.

• /create-test-plan
• /prep-weekly-report
• /launch-campaign-lite (one channel only)

Days 9–10: Add verification

• Define the metrics and thresholds
• Decide what triggers human review
• Document the “stop rules” (when to pause spend)

If you want a partner to help you set up this agentic operating system for lead generation, 3L3C focuses on exactly this kind of autonomous workflow design—agents that execute, measure, and improve.

The uncomfortable truth: most teams don’t need more people

Cherny’s workflow went viral because it hints at a future many teams are avoiding: small groups achieving outsized output through orchestration.

For engineering, that means parallel agents, shared memory, command interfaces, and tight verification. For agentic marketing, it’s the same shape—just applied to research, creative, ops, and analytics.

If 2025 was the year teams adopted “AI assistance,” early 2026 is shaping up to be the year teams adopt AI management—treating agents as a workforce that needs direction, guardrails, and feedback loops.

If you had five specialized agents working for you tomorrow, which part of your marketing execution would you delegate first: research, production, ops, or verification?