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:
- Understands input
- Researches content
- Structures ideas
- Decides visuals
- 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:
- Memory (CLAUDE.md)
- Brain (carousel.md)
- 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
