I let Claude Code run marketing workflows for brands

I got tired of context-switching between Figma, Buffer, Instagram, analytics, random downloads folders, and whatever tab I had open for reference images.

The problem was not "marketing is hard" in some abstract sense. The problem was that getting one post out the door felt like a bad relay race between tools that had no idea about each other.

Open a design tool. Export something. Realize the crop is slightly off. Re-export it. Open a scheduler. Paste the caption. Open Instagram to check whether the caption still reads well in the real app. Come back tomorrow to see if the thing did anything.

That loop is tolerable if marketing is your main job. It is awful if you are a founder or developer trying to do it between product work, support, bugs, and shipping.

What finally clicked for me was this:

I did not actually want "marketing in the terminal." I wanted natural language on top, and a command surface underneath that an agent could reliably operate.

That is why I built Wonda.

This is not a neutral review. It is a write-up of the workflow we actually use, what the product really helps with, and where it absolutely does not save you.

TL;DR

I got tired of doing marketing through dashboards, so I started using Claude Code as the interface and Wonda as the execution layer underneath. It works well for research, generation, editing, and publishing because the whole thing is text-driven and inspectable. It still needs human review, taste, and restraint.

The interface was the real problem

I do not think technical people are bad at marketing because they cannot understand hooks, distribution, or creative.

I think a lot of us are bad at it because the usual tools fight the way we already work.

The old loop looked something like this:

1. Make an image in Figma or hack together a reel idea somewhere else.
2. Export it locally.
3. Upload it into a scheduler.
4. Open Instagram or TikTok anyway because you do not fully trust the scheduler preview.
5. Check analytics later in a different place.

It is not one workflow. It is five partial workflows taped together.

What I wanted instead was simpler:

• something scriptable
• something composable
• something I could inspect after the fact
• something Claude Code could drive without needing browser automation

That last part ended up mattering more than I expected.

What Wonda actually is

The short version is: Wonda is a CLI and API for content workflows.

The narrow loop I care about most is:

• check what is performing
• pull brand references
• generate stills or short videos
• edit them into something more platform-native
• publish without leaving the workflow

But the product is broader than the handful of commands in this post. Under the hood it also has media management, workflow blueprints, chat-driven generation, brand/style extraction, scraping, analytics, and direct publishing surfaces. The reason I am not trying to cram all of that into this article is simple: the useful part for me was getting one small loop to feel repeatable.

And most of the time, I am not manually typing every command.

Usually I tell Claude Code what I want, and it uses the CLI underneath.

The smallest version of that loop looks like this:

# Generate an image
wonda generate image \
  --model nano-banana-2 \
  --prompt "iced matcha latte on a stone counter" \
  --aspect-ratio 1:1 \
  --wait -o matcha.png

# Generate a short video
wonda generate video \
  --model seedance-2 \
  --prompt "slow handheld push-in on a coffee pour" \
  --duration 5 \
  --aspect-ratio 9:16 \
  --params '{"quality":"high"}' \
  --wait -o pour.mp4

# Upload and publish
MEDIA=$(wonda media upload pour.mp4 --quiet)
wonda publish instagram \
  --media "$MEDIA" \
  --account "$ACCOUNT_ID" \
  --caption "Morning ritual."

That is not the whole product. It is just the shortest loop that made the entire thing feel useful to me.

The real unlock was not the CLI. It was the agent.

If I had to summarize why this works in one sentence, it would be this:

the terminal is not the star here, the terminal is the stable surface an agent can use.

I do not enjoy memorizing flags for the sake of it. That is not the point. The point is that text in, JSON out, blocking waits, inspectable commands, and predictable errors are a much better execution layer for an agent than clicking around five different SaaS dashboards.

So instead of operating at the syntax level, I can stay closer to intent:

use wonda to study @feelreformed, then make three Instagram
post ideas in a similar visual direction, generate one still
image and one reel, then draft captions for both

Claude Code can translate that into something closer to:

wonda analytics instagram
wonda scrape social --handle @competitor --platform instagram --wait
wonda generate image ...
wonda generate video ...
wonda edit video ...
wonda publish instagram ...

That is the part I actually wanted.

Not "marketing from the terminal" as a flex.

Not "agents replaced the team."

Just a better control surface for repetitive production work.

What changed in practice

I am not going to pretend I ran a perfect A/B test, or that every workflow is measured cleanly enough to make a grand claim.

But operationally, a few things changed fast:

• I could go from "study this account" or "work from this brief" to draft assets in one conversation.
• I stopped thinking in individual tools and started thinking in loops.
• I could inspect the exact commands that ran, rerun them, or tweak one step without starting over.
• Throwing away mediocre ideas stopped feeling expensive.

That last point matters more than people admit.

The biggest benefit was not "AI made better art." The biggest benefit was that bad ideas got cheaper to kill.

If a visual feels generic, the caption lands flat, or the whole thing looks like sterile AI mush, I can adjust and rerun instead of treating every asset like a mini production process with its own little committee.

One thing worth separating from the Feel Reformed example: we also shared a more aggressive UGC reaction workflow publicly on Reddit. That setup ran across 12 accounts and drove 8.7M views, with 43% of the audience in the US. One video hit 5.3M views and 10 others cleared 100K. Different content format, same operating model: Claude Code on top, CLI underneath. Source

I would not use that as proof that "automation solves marketing." I do think it is fair evidence that this operating model can hold up under real volume.

A realistic workflow

Here is a more honest example than the polished landing-page version.

This is roughly the shape of what Claude Code ends up doing after I describe the goal:

# 1. Check what has been working on your own account
wonda analytics instagram

# 2. Pull references from the brand account
wonda scrape social \
  --handle @feelreformed \
  --platform instagram \
  --wait

# 3. Generate an image concept
wonda generate image \
  --model nano-banana-2 \
  --prompt "hands holding a ceramic mug, warm morning light" \
  --aspect-ratio 1:1 \
  --wait -o shot1.png

# 4. Generate a reel concept
wonda generate video \
  --model seedance-2 \
  --prompt "steam rising from a mug, subtle camera push-in" \
  --duration 5 \
  --aspect-ratio 9:16 \
  --params '{"quality":"high"}' \
  --wait -o reel.mp4

# 5. Add captions
REEL_MEDIA=$(wonda media upload reel.mp4 --quiet)
wonda edit video \
  --operation animatedCaptions \
  --media "$REEL_MEDIA" \
  --params '{"fontFamily":"TikTok Sans SemiCondensed","position":"bottom-center","sizePercent":80}' \
  --wait -o reel-captioned.mp4

# 6. Publish
FINAL=$(wonda media upload reel-captioned.mp4 --quiet)
wonda publish instagram \
  --media "$FINAL" \
  --account "$ACCOUNT_ID" \
  --caption "The best mornings start slow."

The important detail is not the exact prompt wording. It is the workflow shape:

research -> generate -> edit -> publish

That sequence used to be spread across multiple dashboards, export steps, and random notes. Now it can happen in one conversation and one command surface.

One still from the Feel Reformed workflow.

A second variation from the same direction.

One important boundary: scraping your own brand account for reference does not mean every generated output is automatically ready to ship. I still treat the account as source material for visual direction, and I still review the output before anything gets published.

What still breaks

This is the section that usually gets removed from product posts, which is exactly why I want it in here.

Moving this work into Claude Code plus a CLI did not make the ugly parts disappear. It mostly changed where they show up.

The recurring failure modes for me are:

• Bad generations are still bad generations. Faster iteration does not magically fix weak prompts, uncanny faces, awkward hands, or boring scenes.
• Taste is still the bottleneck. The tool can produce options. It cannot decide which one is right for your brand.
• Captions and on-screen text still need human eyes. This is one of the first places low-quality work leaks through.
• Scraping can give you too much noise if you are sloppy. Pulling broad references is easy. Pulling useful references is harder.
• Platform nuance does not disappear. Instagram, TikTok, and ads are not interchangeable just because they all accept media plus text.
• Auth and account state are real operational concerns. If the wrong account is connected, permissions are stale, or the publish surface is not set up cleanly, the fancy generation part does not matter.
• Volume can make you lazy. Reducing friction is good right up until it helps you produce more junk.

The honest summary is simple:

Wonda reduces production friction. It does not remove the need for review, strategy, or judgment.

Why this feels more natural to me than another dashboard

If you already live in prompts, shell history, Markdown files, and AI tools, this setup feels obvious very quickly.

Natural language becomes the control layer.

The CLI becomes the execution layer.

That split matters.

I do not want to hand-author ten commands every time. I also do not want a polished GUI that traps the workflow inside clicks and hidden state. I want to say what I am trying to do, let the agent do the repetitive plumbing, and still be able to inspect the exact steps.

That is the balance I was missing.

If you love visual tooling, collaborative approvals, and highly polished review flows, a dashboard may still be the better interface for you. I do not think a CLI wins on every axis.

I think it wins when the operator is technical and values speed, repeatability, inspectability, and agent control more than visual polish.

Getting started

If you want to try the same approach, the shortest path is:

# Ask Claude Code to install Wonda
curl -fsSL https://wonda.sh/install.sh | bash

# Then authenticate
wonda auth login

# Optional: let Claude inspect the CLI surface
wonda --help

After that, you do not need to start by memorizing commands. You can just describe the outcome:

Generate an Instagram image for Feel Reformed, then make a short reel version
with animated captions and draft a caption for both.

If I were giving one piece of advice, it would be this:

do not start with the giant autonomous workflow.

Start with one small loop. Watch what Claude runs. See where it breaks. Fix the boring parts. Then add one more step.

That has been the biggest lesson for me.

The useful part is not the flashy demo. The useful part is having a loop you will actually run again tomorrow.

If you try this and it breaks, that is the part I want to hear about.