‍You Don’t Have a Content Problem — You Have a System Problem

Most creators think their bottleneck is:

• “I need better ideas”
• “I need better prompts”
• “I need better design skills”

But if you’ve been creating content consistently, you’ll notice something else:

• You already know what to say
• You just don’t want to go through the process again

Opening Canva.
Rebuilding layouts.
Rewriting structure.

Every. Single. Time.

The real bottleneck isn’t creativity.

👉 It’s execution friction.

And Claude Code changes that — not by writing better captions, but by letting you build a repeatable content system.
‍

Stop Thinking in Prompts — Start Thinking in Systems

Most people use AI like this:

“Write me a carousel about X”

That works… once.

But it breaks when you try to scale because:

• No consistency
• No structure reuse
• No quality control

With Claude Code, you’re not writing prompts.

You’re building:

👉 A content operating system

And the two components that actually determine whether it works are:

• .claude/commands/carousel.md → your decision engine
• render.py → your execution engine

Everything else is secondary.
‍

Part 1: carousel.md — Your Content Brain

📎 Resource reference:

Why Most People Get This Completely Wrong

The biggest mistake:

👉 Treating carousel.md like a prompt

Example of bad approach:

• “Generate a carousel about AI tools”
• Long paragraphs of vague instructions
• No structure, no logic

Result:

• Inconsistent outputs
• Random structure
• No scalability

What carousel.md Actually Is

It’s not a prompt.

👉 It’s a multi-stage execution pipeline

Inside your file, you're defining how AI:

1. Understands input
2. Researches content
3. Structures ideas
4. Decides visuals
5. Outputs structured data

This is closer to product design than writing.

The Most Important Section: Slide Planning

This is where most of the value lives.

Instead of jumping straight into writing, your system forces:

👉 Structure before content

Example logic from the system:

• Hook (pattern interrupt)
• Context (frame the problem)
• Insight (core idea)
• Breakdown (explanation)
• CTA (action)

Why this matters:

• AI is bad at flow by default
• Humans are bad at consistency

This layer fixes both.

The Hidden Power: Forced Approval Step

One of the smartest design decisions in the system:

The process stops before rendering

This is intentional.

Because:

• AI is fast at execution
• Humans are better at judgment

If you skip this step:

• You’ll edit final outputs repeatedly
• You lose efficiency

If you keep it:

👉 You fix problems at the cheapest stage

The Real Asset: Config JSON

At the end of the command, AI generates structured output like:

{

  "slides": [...]

}

This is not just a format.

👉 It’s the interface between thinking and rendering

Once you have this:

• You can reuse content across formats
• You can plug into different renderers
• You can batch produce content

This is where your system becomes scalable.

How Advanced Users Actually Improve carousel.md

Most people tweak wording.

That’s low leverage.

High-leverage changes happen at the decision level:

1. Change the Content Strategy Logic

Instead of generic flow:

• Hook → Info → CTA

You define:

• Pattern interrupt
• Belief shift
• Contrast
• Peak insight

This directly impacts:

👉 Retention and conversion

2. Add Conditional Thinking

Example:

• If topic = tools → use comparison format
• If topic = concept → use analogy

Now AI is no longer “writing”

👉 It’s deciding

3. Constrain Output

Counterintuitive, but critical:

• Max characters per slide
• Max 2 ideas per slide

This forces:

👉 Clarity and punch

Part 2: render.py — Your Execution Layer

📎 Resource reference:

Why This Matters More Than You Think

Most people underestimate rendering.

They think:

“If the content is good, design doesn’t matter”

Reality:

• Good content + bad design → ignored
• Average content + strong design → performs

👉 Design is not decoration
👉 It’s delivery

What render.py Actually Does

It’s not just drawing images.

It’s a full:

• Layout engine
• Typography system
• Design rule enforcer

It translates structured content into:

👉 Consistent, production-ready visuals

Key Systems Inside render.py

1. Theme Switching (Dark / Light)

Each slide can define:

"theme": "dark"

Why this matters:

• Visual rhythm
• Attention reset
• Content segmentation

Without this:

👉 Slides feel flat and repetitive

2. Accent Highlight System

Using:

*keyword*

Automatically becomes:

• Highlighted
• Styled
• Consistent

This removes:

• Manual styling decisions
• Inconsistency

And improves:

👉 Scanability

3. Layout Constraints

The renderer enforces:

• Padding
• Line height
• Max width

This is critical because:

👉 AI should not control layout freely

Design consistency must be system-controlled

4. Content Blocks = Visual Language

Your renderer supports structured blocks like:

• Pills (tools / tags)
• Comparison (old vs new)
• Cards (key insights)
• Code blocks

This is powerful because:

👉 It maps meaning → design

Examples:

Content Type

Visual Format

Tool list

Pills

Comparison

Split cards

Insight

Callout card

This creates:

👉 Faster comprehension
👉 Higher retention

How Advanced Users Upgrade render.py

1. Control Information Density

You can adjust:

• Max lines
• Font size scaling

This determines:

👉 How “heavy” each slide feels

2. Adjust Visual Hierarchy

Tweaks include:

• Headline size
• Divider thickness
• Spacing

These directly impact:

👉 Attention and readability

3. Add New Block Types

Example extensions:

• Stats blocks
• Charts
• Step-by-step layouts

Now your system evolves from:

👉 Content generator → Content framework

4. Engineer Attention Flow

By controlling:

• Dark vs light frequency
• Highlight colors
• Contrast

You’re effectively designing:

👉 User attention movement

Why You Need a Renderer (Instead of Just ChatGPT)

Without it:

• Every design is manual
• No consistency
• No batching

With it:

• One structure → infinite outputs
• Consistent branding
• Scalable production

The Real Shift: From Creating Content to Producing Content

What you’re building here is not:

• A tool
• A prompt
• A shortcut

It’s a system with 3 layers:

1. Memory (CLAUDE.md)
2. Brain (carousel.md)
3. Hands (render.py)

But the real leverage comes from:

👉 Brain + Hands

Final Insight

If you only improve prompts:

👉 You’re still a content user

If you start modifying:

• .claude/commands/
• render.py

👉 You become a content system builder

And the difference is:

• One creates content
• The other produces it at scale

‍