I Had Claude Build Me a Full AI Marketing Department — Here's Exactly How I Did It

Real talk: I didn't write most of this code.

I directed it. I described what I wanted, reviewed what came back, pushed back when it was wrong, and kept iterating until it worked. That's the actual skill I want to talk about — because if you're still treating Claude like a search engine that writes code snippets, you're leaving a lot on the table.

Here's what we built together and how the conversation actually went.

What I Wanted

I was tired of asking AI for marketing help and getting back the kind of copy that sounds like it was written by a committee of robots. You know the type — "Unlock Your Potential Today!" Nobody buys that.

The real problem is that marketing isn't a one-prompt job. It's a team sport. You need someone thinking about strategy, someone thinking about keywords, someone writing the actual copy, and someone planning the social calendar. When you smash all that into a single prompt, you get a single-perspective answer that misses everything it wasn't specifically asked about.

So I told Claude what I actually wanted: build me a team.

The Prompt That Started It

I didn't give Claude a spec doc. I just described the problem:

"I want a Python CLI that runs multiple specialized AI agents sequentially. Each agent has a specific marketing role — CMO, SEO, copywriter, social media, email, analyst. Each one should receive the previous agents' output as context so they're building on each other's work, not starting from scratch. Use Claude Opus 4.6 with streaming and adaptive thinking."

That's it. No architecture diagram. No file structure. Just the outcome I wanted and one key constraint: sequential context passing.

What came back was a working base. Not perfect. But working.

The Architecture Claude Landed On

main.py                 # CLI + orchestrator
agents/
  base.py               # MarketingAgent base class
  cmo.py                # Campaign strategy
  seo.py                # Keyword + content strategy
  copywriter.py         # Landing pages, ads, taglines
  social.py             # Content calendar, platform playbooks
  email_marketer.py     # Welcome sequences, nurture flows
  analyst.py            # KPI dashboard, A/B roadmap
tools/
  platform_tools.py     # HubSpot, Mailchimp, Buffer, Semrush hooks
campaigns/              # Saved campaign outputs

Six agents. Each one a specialist. Each one named like a real person on a real team because — honestly — it makes the system prompts better when you write them that way.

The Base Agent — This Is the Core

Every agent inherits from one class. The think() method is the whole game:

class MarketingAgent:
    def __init__(self, name: str, role: str, system_prompt: str, emoji: str = "🤖"):
        self.name = name
        self.role = role
        self.system_prompt = system_prompt
        self.emoji = emoji

    def think(self, task: str, context: str = "", max_tokens: int = 4096) -> str:
        messages = [{"role": "user", "content": task}]
        if context:
            messages = [
                {
                    "role": "user",
                    "content": f"Context from previous team members:\n\n{context}\n\n---\n\nYour task: {task}"
                }
            ]

        full_text = ""
        with client.messages.stream(
            model="claude-opus-4-6",
            max_tokens=max_tokens,
            thinking={"type": "adaptive"},
            system=self.system_prompt,
            messages=messages,
        ) as stream:
            for text in stream.text_stream:
                print(text, end="", flush=True)
                full_text += text

        return full_text

Simple. Take the task, prepend any context from previous agents, stream the response. The context is what makes it not stupid.

The Context Handoff — Why This Actually Works

Here's the pipeline in the orchestrator. This is the part I pushed back on Claude about — the first version ran everything in parallel and the output was incoherent because nobody was talking to each other.

# CMO goes first — sets everything
self.outputs["01_cmo"] = self.agents["cmo"].think(cmo_task)

# SEO gets the CMO brief
self.outputs["02_seo"] = self.agents["seo"].think(
    seo_task, context=self.outputs["01_cmo"]
)

# Copywriter gets CMO + SEO both
self.outputs["03_copy"] = self.agents["copywriter"].think(
    copy_task,
    context=self.outputs["01_cmo"] + "\n\n" + self.outputs["02_seo"]
)

# Social gets CMO + Copy
self.outputs["04_social"] = self.agents["social"].think(
    social_task,
    context=self.outputs["01_cmo"] + "\n\n" + self.outputs["03_copy"]
)

# Email gets CMO + Copy
self.outputs["05_email"] = self.agents["email"].think(
    email_task,
    context=self.outputs["01_cmo"] + "\n\n" + self.outputs["03_copy"]
)

# Analyst gets everything
self.outputs["06_analytics"] = self.agents["analyst"].think(
    analyst_task,
    context="\n\n---\n\n".join([
        self.outputs["01_cmo"],
        self.outputs["02_seo"],
        self.outputs["04_social"],
    ])
)

When the Copywriter writes your landing page headline, it already knows the positioning the CMO defined, the keywords the SEO specialist identified, and the exact personas. The copy isn't generic because it's not starting from scratch — it's starting from a complete strategic brief written by the agent before it.

That's what single-prompt marketing AI can't do. It has no team. It's one person trying to do six jobs at once and it shows.

What I Had to Correct

A few things Claude got wrong on the first pass that I pushed back on:

1. Parallel execution. First draft ran all agents at once. Looked efficient. Output was a mess because the Copywriter had no idea what the SEO specialist recommended. Told Claude to make it sequential and explained why. Fixed immediately.

2. Generic system prompts. Early versions had vague role descriptions like "you are a marketing expert." I pushed for specificity — actual deliverables listed, actual output format expected, written from the perspective of a real person with a real title. The output quality jumped noticeably.

3. No context injection on quick mode. The quick campaign (CMO + Copywriter only) wasn't passing the CMO brief to the Copywriter. Caught it in testing. One-line fix but it's the whole point of the system.

This is what directing AI actually looks like. It's not magic prompt engineering. It's reviewing output, identifying what's wrong, and being specific about how to fix it.

What It Produces

Run a full campaign and you get six connected deliverables:

• CMO output — positioning, personas, channel mix, messaging pillars, KPIs
• SEO output — keyword clusters, search intent analysis, content briefs for top 3 pages, technical checklist
• Copywriter output — hero copy, full landing page, 3 Google ad variations, 3 Meta ad variations, brand voice guide
• Social output — 4-week calendar for LinkedIn, Instagram, X, and TikTok with ready-to-post content
• Email output — welcome sequence (5 emails), sales sequence (3 emails), re-engagement sequence, newsletter template
• Analyst output — KPI dashboard, attribution model, A/B testing roadmap, 90-day benchmarks

Total output on a full run: somewhere between 8,000 and 12,000 words of interconnected marketing content that actually references itself. The social posts use the same messaging pillars the CMO defined. The email subject lines match the copy angles the Copywriter developed. It coheres.

How to Run It

git clone https://gitlab.com/JonathanMelton-FusionAL/ai-marketing-team
cd ai-marketing-team
pip install -r requirements.txt
cp .env.example .env
# Add your ANTHROPIC_API_KEY

# Full campaign — all 6 agents
python main.py campaign --product "B2B SaaS for HR teams" --save

# Quick mode — CMO + Copywriter only
python main.py campaign --product "your product" --mode quick

# Ask one agent directly
python main.py ask cmo "What channels should a bootstrapped SaaS focus on first?"
python main.py ask copy "Write 5 headline variations for a project management tool"
python main.py ask seo "Keywords for email automation software?"

The --save flag dumps everything to a timestamped folder in campaigns/. Use it. You'll want to reference the outputs later.

What I'd Do Differently

Real keyword data. Right now the SEO agent estimates keyword volume. Hooking in a Semrush API key (there's a hook for it in tools/platform_tools.py) would make those recommendations actually grounded in real search data.

Iteration loops. Right now it's a straight pipeline. What I want is the CMO reviewing the Copywriter's output and pushing back if it doesn't match the positioning. That's more expensive token-wise but would be closer to how a real team works.

MCP server version. This is the one I'm actually building next. Wrap the whole thing as an MCP server so it runs inside Claude Desktop as a tool — no CLI, just "run a campaign for X" and it happens in your workspace. That's what FusionAL is moving toward: all your AI tools in one place, zero config headache.

Note: Opus 4.6 with adaptive thinking burns tokens fast. A full 6-agent campaign run will cost roughly $1-3 depending on your product description length. Budget accordingly or swap claude-opus-4-6 for claude-sonnet-4-6 in agents/base.py for a cheaper run.

The Bigger Point

I'm a self-taught developer. No CS degree. No team. I built this working alone, directing Claude to do the heavy lifting on code I understood well enough to review and correct but didn't have to write from scratch.

That's the skill now. Not knowing every syntax. Not being the fastest typist. Knowing what you want, being able to recognize when you're not getting it, and knowing how to course-correct.

If you're sleeping on that because it feels like "cheating" — it's not. It's just how good builders work in 2026.

Repo: gitlab.com/JonathanMelton-FusionAL/ai-marketing-team

If you run it, let me know what it produces. Tag me on X — @2EfinAwesome.

I'm building FusionAL — a unified MCP gateway for teams who don't want to hire a platform engineer to set up their AI tooling. Follow the build on X.