Four files, not twenty. The framework comes from the Growth Codex Level 2 chapter on Content & Story – the chapter I've walked founders through more times than any other in the last year. It reduces every content strategy to four questions, asked in order: why we do this (your story), what we talk about (your topics), how we talk about it (your voice and formats), and when we talk about it (your cadence). Everything else compounds from these four. If they're not locked, every piece your skill drafts is guessing.

Inside the Bridesmaid repo, the four answers live as four markdown files in a single folder:

The persona is the trapdoor

The first file is the one that has to be right before anything else has a chance. Story is where the persona lives, and the persona is the trapdoor under every other call. In Christina's case the persona named itself inside ten minutes: she calls herself a first-time bride. She said it twice, unprompted. The gap she's working against isn't aesthetic and isn't age – it's experience. That word changes what every downstream piece of content has to do for her. A theme like “Real Costs” exists because a first-time bride has no felt sense of what a $10k, $30k, or even $100k wedding actually looks like. Pick the wrong persona and the skill draws confidently from the wrong source for months.

The reason this lands as a section called “Pour It In” is what Christina said when I asked her what Bridesmaid actually delivers:

“There is this one solution where I can just pour it all in and I get my perfect wedding plan back.”

That sentence is the whole job of the four files. The bride pours the chaos in – her scattered tabs, her many possible weddings, her budget worry, her parents' opinions. The skill returns a plan she recognizes as hers, not a list of links. For a founder pouring your chaos into a content engine, the equivalent is exactly the same shape: the four files are where you pour. Without them, every prompt starts from a cold reading of whatever the model already thinks your brand is. With them, the model starts every draft from your actual story.

Corrections, not clean templates

What surprised me about doing this with Christina was how much of the work was honest correction, not filling in blanks. Three moments stood out in our session:

• Image generation got demoted from headline to demo. The earliest Bridesmaid pitch led with the magic of describing a venue and seeing it rendered. Sitting in the story call together, both of us agreed: that's a demo, not the point. The point is the plan that accumulates. Image-gen stayed in the product as a supporting beat, but the brand story stopped leading with it.
• Food almost got cut from the themes entirely. The themes file's first pass had no food theme. Christina mentioned, almost in passing, that food is the part of her own wedding she gets most lit up about. The file added a theme called The Table on the spot.
• The pricing ladder rewrote what the voice can claim. A vague pricing intention became a real free + monthly + annual structure during the session, which changed what the voice file allows the skill to claim today versus what it has to mark as direction.

Each correction is the same move: the agent surfaces a draft of what it thinks is true, the founder reads it back, the file gets sharper. None of it is fill-in-the-blank. None of it is a clean template you copy. The four files are where your founder voice gets concrete enough that a machine can hold it for you – and the only way to get there is to say what you actually mean, out loud, and have someone (or something) read it back to you.

Lock these four and you've done the load-bearing work. Everything in the next section – the skill itself – is what gets built on top.

The four files are the brand. The skill is the operating contract on top of them. It lives in one folder – .claude/skills/content/ – and the folder holds exactly one file: SKILL.md. That file does not contain your brand. It points at your brand. Its job is naming the moves the agent runs: how to produce Monday's carousel, how to draft Friday's single image, how to outline Saturday's Reel without scripting it, when to surface a clarifying question instead of guessing.

You build it the same way you build any agentic skill: a conversation inside Claude Code, using Anthropic's Skill Creator. You answer questions in your own words. The Creator scaffolds a markdown file. You correct what it got wrong. You commit. The same loop Christina and I ran for the Bridesmaid build – and the same loop you'll run for yours. There is no scripting language, no DSL, no special editor. Just markdown a smart agent reads.

Here is the actual skill we ended up with. The folder, the five files, the contract. Click to read it in full:

Read it back, every time

The skill is bounded by the four files. Its honesty is bounded by your read-back. Both bounds are yours to set – and the read-back is the one most founders quietly skip. Here is why that's expensive.

Early in the story call, Christina described what Bridesmaid does for a first-time bride as “an all-in-one plan on how to plan a wedding.” It's the phrase that names her whole product in one breath. As we worked through the file together, the agent lifted what it thought was her distinctive line and wrote it into story.md as a locked quote. It rendered the phrase as “hole-in-one plan on how to plan a wedding.” Twice. Confidently. The agent was sure that was what she said.

Christina caught it on the first read-back. We corrected it, the file got fixed, and the skill drafted the next piece against the right phrase. Small moment. But if neither of us had read it back, the agent would have spent the next six weeks producing Bridesmaid content built around a golf pun for an event the bride never said.

That is the cleanest argument for why the skill drafts and you stay the editor from day one. Confident agents are wrong agents until proven otherwise. The four files are where your voice gets concrete enough that the agent can hold it – and the read-back is what keeps it from holding a wrong version. The skill improves only because you correct it. Every correction sharpens the file the skill reads next.

In the next section we'll get specific about how that editor role works week to week, what happens to it as trust grows, and the seven-step plan you can run in your own repo this week to set the whole thing up.

Most “AI content” pieces lead with the promise that the agent ships your marketing for you. This one doesn't. The agent drafts; you ship. That posture is the operating principle that makes a content skill safe to keep around in the first place – and it's also what lets a small team produce daily content without ever publishing something that sounds like it came from someone else.

If you've worked inside Claude Code long enough to feel the difference between ask mode and auto mode, you already know the mental model. Some actions you let the agent take on its own, because the cost of being wrong is small. Other actions you keep in your hands, because the cost of being wrong is large. AI Founder Mode made this same call for irreversible actions in the codebase: full access for the recurring work, tight boundaries on the things a prompt injection could turn into real-world damage. Brand voice is in the second bucket. The audience that took years to earn is downstream of every post, and one off-brand week is a tax the small but mighty team can't afford. So daily content sits in review mode by default.

The first read-back

Here is what the editor seat actually looks like once the skill is live. When Bridesmaid's skill produced its first carousel, I opened it, scrolled through, and surfaced three corrections in the same conversation:

• Slide count too high. The draft came in at seven slides. Bridesmaid's locked spec is max four – the agent had over-produced.
• Wrong aspect ratio. The carousel came out at 9:16. Instagram crops anything taller than 4:5 in the feed, so the spec is 4:5 (1080×1350) for everything except Saturday's Reel.
• No style guide. Typography and palette had drifted because voice-and-formats.md didn't yet have an explicit visual system locked in. We added it on the spot.

The skill bent in the same conversation – revised draft on the next message, updated file commits in the one after. That is the operating posture the skill is built for: drafts come fast, the founder reads back, the file gets sharper, and the next draft already reflects the correction. None of those moves are special to Bridesmaid – they are exactly what your editor seat will look like the first time you run your own skill.

Four levels, one path

Review-by-default is the starting state, not the destination. The destination is the opposite end of the same spectrum: a skill that runs the daily content operation on its own, with the founder reviewing performance after publication instead of approving each draft. Between those two ends there are four practical stops on the autonomy ladder. The skill knows which one it's currently at because cadence.md tells it.

• Per-piece review. Default. The skill drafts; you approve each piece before it ships. This is calibration mode – the place where voice and tool setup get sharpened.
• Weekly batch approval. Once the voice holds steady, you stop reviewing piece-by-piece and approve the whole week's batch on Friday in one pass. Same review work, less context switching.
• Scoped autonomy. The skill ships most things on its own; specific categories still escalate to you – anything mentioning a vendor by name, anything touching pricing, anything making a future-tense claim about the product. You name the gates. The skill obeys.
• Fully autonomous. Drafts and ships everything without your prior review. The review shifts to after the post is live – you look at the performance data and decide whether the skill needs an adjustment for next week.

Movement up the ladder is founder-granted on named scopes, not earned by the skill on its own. No streak of clean drafts auto-promotes anything. You write “Tuesday carousels go straight to the scheduler starting Monday” into cadence.md and the skill obeys. Anything outside that scope keeps going through the prior review level. The level can also go down – if a particular format starts drifting, pull it back to review-by-default and re-calibrate.

What every review actually optimizes

The point of reading the drafts back isn't only to catch off-brand voice. That's the obvious half. The less obvious half is that every review is also a chance to tune the operating system underneath the skill – so the right model does the right job, at the right cost, week over week.

Practically: a Sunday “Bride's Diary” postcard image doesn't need the same model budget as a Wednesday venue-try-on carousel that runs four img-to-img variants. The first can lean on a fast, cheap model; the second wants something with stronger composition control. The first time the skill produces each format, you notice where the output quality lines up with the job – and where it's either over-spending or under-delivering. Each review writes that learning back: the skill picks the right model per format, the prompts get tighter, the tool calls get fewer. The same skill that costs $1.50 per piece this week can cost $0.30 per piece a quarter from now, doing better work, because every review was also a tuning pass.

That is the deeper reason the agent drafts and you stay the editor from day one. Reviews aren't a gate the skill grows out of. They're where the skill, the prompts, the model choices, and the budget all get incrementally better – and where the leverage compounds over the quarters you'll run this thing.

The alignment rule keeps the substrate honest

One more piece that makes review-by-default actually scale: the alignment rule between your strategy folder and your content folder. When the skill notices a drift – a post wants to claim something the strategy doc says isn't true yet, or vice versa – it surfaces a clarifying question rather than silently picking a side.

During the Bridesmaid build, this rule did real work twice in one afternoon. The pricing ladder got sharper in the story call (free trial + $10/month + ~$100/year + planner tier), and the alignment rule pulled the change through into strategy/business-model.md while also flagging an open question in strategy/acquisition-strategy.md that we hadn't resolved yet. It didn't guess. It asked. The same rule caught the geo-scope decision (the content goes English-first, the acquisition strategy still lists geo as open) and flagged the gap for a future session.

This is what makes giving the skill more autonomy actually safe later on. The substrate doesn't quietly rot, because the skill is built to notice when it's rotting and to point at it. The two open ideas we already filed for Bridesmaid – the vendor agent that sends and parses emails end-to-end, and a German-language social channel – both live in an ideas/ folder marked clearly as vision, not today-truth. The skill speaks to them as direction, never as something the product ships today. Honest about what it doesn't know is part of the contract.

Your move: The Content Skill Builder

Here is the plan that takes you from where you are today to a working content skill running at review-by-default in your own repo, with one piece shipped through it. Seven steps, in order. They're not day-mapped – some you'll move through in an hour, others might take a weekend.

Definition of done: .claude/skills/content/SKILL.md exists and references your four canonical files. One real piece has shipped through the skill. One review session is logged – what the skill drafted, what you corrected, what got written back. And an explicit autonomy decision is on record, even if that decision is “stay in review mode for now.”

Once your app and your strategy live in the codebase, your content production is the next process to move in. The grind that used to own your week becomes a skill that drafts on demand, against your locked story, themes, voice, and cadence. The treadmill stops. The work that compounds – input, feedback, sharper files, sharper drafts – takes its place. And the founder voice that earned the audience in the first place doesn't get traded for reach.

The skill drafts. You stay the editor.