I Turned 3 Days of Content Work Into 25 Minutes With Claude Code

Solo AI Lab — Mon, 13 Apr 2026 12:56:50 +0000

Last Tuesday, 10:47 PM. I was staring at a blog post I had finished and published four hours earlier. Now I needed the same idea as a podcast script, a Twitter thread, a YouTube description with chapter markers, and a long-form community article.

Same thought. Five different shapes.

Each platform had its own quirks. One banned markdown bold. One ate tables. One wanted ①②③ instead of numbered lists. One needed a 140-character blockquote at the top.

I had been at it for two hours. I had six more to go. Outside, everyone was asleep.

I closed the laptop. Opened it again. And whispered the question that had been sitting in my head for months: why am I doing this by hand at all?

That was the night I stopped scheduling my content and started writing it in a single command.

The Turn

The commercial automation tools had all failed me. Zapier could schedule, but couldn't write. Make.com could route files, but couldn't hold a voice. Custom GPTs could draft, but forgot my rules every conversation.

The missing piece wasn't orchestration. It was memory. A system that knew my voice, my platform quirks, and my session-over-session lessons — and applied them to every new topic without being reminded.

Then Claude Code arrived. And I realized the memory I needed was already sitting in my project directory. I just had to put it in the right files.

The Three-Layer Architecture

The system has three layers. Strip any of them out and the whole thing collapses back into generic LLM output.

Layer 1: The constitution

A file at the project root called CLAUDE.md. Claude Code reads it on every session. This is where the non-negotiables live:

Voice rules: first person, no markdown bold, numbered lists use ①②③
Banned words: the phrases that make writing sound like AI
Platform quirks: no tables here, emoji-heavy there, H3 max somewhere else
Lessons learned: every time I catch a mistake, it gets added to the file

The constitution grows. When the system makes a mistake, I fix the file, not the output. The pipeline gets smarter across sessions without any retraining.

Layer 2: The meta-prompt

A second file defines the pipeline as twelve stages — C1 through C12. Each stage has a clear input, output, and set of rules:

## C3: Podcast script

Input: 02_outline.md
Output: 03_podcast_script_draft.md
Target length: 3,000–3,500 characters
Rules: follow CLAUDE.md voice rules
Close with "Until next time."

The meta-prompt is the shape of the work. When I ask Claude to run C3, it knows exactly what to produce.

Layer 3: Skills and scripts

The third layer touches the outside world. Claude Code supports skills — packaged sub-agents with their own frontmatter and tools. Mine include:

A fact-check skill that runs parallel web searches on every claim
An image-check skill that compares generated images against their prompts
A podcast-optimization skill built from retention research
A trend-scout skill that surveys social platforms for topic ideas

Alongside the skills sit PowerShell glue scripts. They handle clipboard copying for platforms that refuse markdown uploads. They push WordPress drafts. They convert markdown to HTML for community sites. Claude calls them when a task leaves the LLM sandbox.

Three layers. Plain markdown files and small scripts. No external orchestrator. No hidden pipeline. No "automation platform" subscription.

One Walkthrough

Here is what happens when I run it.

I open Claude Code in my project directory and type: Run C1 through C12 for today's topic.

C1 — Research. Claude runs parallel web searches. Pulls top articles. Finds the missing angle. Writes 01_research_brief.md.

C2 — Outline. Section by section: hook, three main points, objections, call to action.

C3 — Podcast script. 3,500 characters in my voice. Opens with a 30-second hook. Banned phrases filtered automatically.

C3.5 — Fact-check. The fact-check skill scans the script for numerical claims, product names, and exaggerated statements. It runs searches in parallel. Discrepancies come back as a table. I approve the fixes. The file is renamed from _draft to _revised — a rule that lives in CLAUDE.md, so future me knows which scripts have been verified.

C4 — Blog post. Two files. One plain text for WordPress. One with [IMAGE: scene/XXX.png] tags at every heading. Producing only one file is a "constitutional violation." The constitution literally says so.

C5 — Image prompts. One prompt per scene, in consistent art direction. Every prompt begins with a style anchor to prevent drift.

C6 through C12. Blog export variants. Twitter thread with ### Tweet N markers. YouTube description with chapter markers pulled from an audio label file. Long-form community article in a GIVE-first tone.

Total wall time: about 25 minutes. Files produced: typically 14. Manual typing on my part: one prompt at the start and a few approval clicks along the way.

Why It Doesn't Break

People build pipelines like this all the time. Most collapse in a few weeks. Here is why this one doesn't.

Memory lives in files, not in the model. The voice rules, the platform quirks, the session lessons all sit in CLAUDE.md in the repo. The LLM doesn't remember anything. It reads fresh every session. When something changes, I change the file.

Skills are first-class. Each skill has its own frontmatter, its own tools, its own scope. Fact-check logic doesn't pollute podcast-writing logic. I can upgrade any skill without touching the others.

Human-in-the-loop at the right places. I don't review every stage. I review two: after fact-check, and after image generation. Everything else runs unattended. Choosing checkpoints carefully is the difference between a helpful tool and an interrupt machine.

Failure is promoted to policy. When I spot an AI-sounding phrase, I don't just fix the output. I add the phrase to the banned list in the constitution. Next session it can't happen. Every mistake compounds into a smarter system instead of a bigger correction queue.

Results

Before the pipeline: one topic took the better part of three working days.

After: 25 minutes of LLM wall time plus about 10 minutes of my own approval clicks.

I have run this for dozens of topics by now. Quality has climbed, because every session's mistakes get promoted into the constitution. And because everything is files, the pipeline scales horizontally. I run multiple topics in parallel Claude Code sessions, each in its own folder, sharing the same constitution and skills.

The marginal cost of another piece of content has effectively gone to zero.

Start Small

This is overkill if you publish once a week to one platform. It makes sense when you run at least three distinct channels and your voice is non-negotiable.

If that's you, start tiny. Write a CLAUDE.md with your top five voice rules. Define one stage — just podcast script, or just blog post. Iterate from there. Add a stage every time you catch yourself doing manual work twice. In a month you will have something you would be proud to ship.

The lesson I would distill from all of it: stop fitting your workflow into a prompt. Start treating your project directory as the workflow.

This post is part of **Solo AI Lab* — a field journal of one-person media pipelines, Claude Code experiments, and AI-assisted creative workflows. If you're building something similar, follow along. I publish every time I ship a new layer.*

DEV Community: Solo AI Lab