Claude Skill A Claude Skill that takes a filled brief and outputs a structural outline (H2 and H3 hierarchy targeting query clusters) before drafting starts.

Brief-to-Outline Claude Skill

Brief-to-Outline is a free Claude Skill that turns a filled content brief into a structural outline: an H1, the H2 and H3 hierarchy, a sketched FAQ section, and slots for internal links. The Skill maps every query in the brief’s cluster to a heading before drafting starts. Install it once in Claude Code and invoke it by name.

A complete brief still leaves the writer with a blank page, and the first thing most writers do with a blank page is improvise structure. That improvisation is where query targets get lost. This page covers what the Skill returns, the mapping rules it enforces, a worked example, and the points where it refuses to go further.

What does the Brief to Outline skill do?

Four steps: take the brief, map the queries, draft the skeleton, stop.

  • Step 1, brief in. You hand it the filled brief, from the Brief Drafter Skill or any equivalent. It asks for its inputs explicitly and will not proceed on placeholders; whatever is missing, it requests before continuing.
  • Step 2, mapping. It assigns the primary query to the H1 and to at least one H2, and places each supporting query in an H2 or H3. Anything that looks off during the mapping is surfaced as a flag, and the Skill waits for your confirmation before moving on.
  • Step 3, outline. It drafts the H2 and H3 hierarchy, sketches the FAQ section, and notes where internal links should land. The output structure is fixed, with every required section present and non-empty.
  • Step 4, hand-off. You get a markdown skeleton with an empty paragraph under each heading, ready for a writer to fill.

What is in the outline it returns?

One markdown block, structure only. The skeleton carries the H1, the H2 and H3 hierarchy, a placeholder for the FAQ block, the internal link slots, and faq frontmatter scaffolding for the publish step. Body copy never appears. Under each heading sits an empty paragraph waiting for the writer.

That restraint is the design. A skeleton with no prose in it cannot smuggle in claims nobody checked, and the writer starts from a structure that already carries the SEO work rather than reverse-engineering it after the draft exists.

How does it map queries to headings?

Three rules, all hard. The primary query goes in the H1 and in at least one H2. Every supporting query is explicitly mapped to an H2 or H3, so the cluster ends up with no orphans. And when the post’s queries carry strong People Also Ask presence, the FAQ section becomes a required part of the outline.

Those three rules are the ones writers skip when outlining from memory, which is why the file writes them down as hard constraints. The same file bans invented statistics and invented citations outright, keeps every heading in sentence case, and runs a self-check before returning. An outline that fails its own check never reaches you.

What does a worked example look like?

Start from a filled brief with these values, which we invented for this page:

  • Primary query: content calendar template
  • Supporting queries: how to build a content calendar; content calendar example
  • Audience: content lead at a small B2B software company
  • PAA presence: strong, per the brief’s SEO section

The Skill returns a skeleton shaped like this:

# Content calendar template: how to build one your team keeps using

[empty paragraph]

## What goes in a content calendar template

[empty paragraph]

## How to build a content calendar in five steps

[empty paragraph]

### Content calendar example: one filled month

[empty paragraph]

## Frequently asked questions

[FAQ block placeholder]

[internal link slot: pillar page named in the brief]

Every line traces to a rule in the Skill file. The H1 carries the primary query, and so does the first H2, which satisfies the placement rule. One supporting query became an H2 and the other sits as an H3 beneath it, so the cluster carries no orphans. Why the FAQ block? This invented brief marks its People Also Ask presence as strong, and strong PAA presence makes the section mandatory. The link slot and the empty paragraphs are the fixed output shape. Sentence case headings, no em dashes, no statistics: the block passes the self-check the Skill runs before it returns anything. Those sample values are ours, and the derivation is mechanical.

When does it stop or refuse?

It stops at the outline, always. Drafting the body belongs to the writer, human or model, and the Skill file says so in as many words.

The refusals are written into the file. A missing input produces a question back to you instead of a guess the writer would inherit weeks later. A flag halts the run until you confirm. And a request that pushes past the Skill’s scope, such as asking it to write the sections it just outlined, gets declined with a pointer to the Skill in the series that owns that job.

An outline tool that quietly writes body copy stops being an outline tool, and the structure stops being reviewable on its own. The refusals keep the step small enough to trust.

Who is this Skill for?

Teams where structure gets decided over and over, one draft at a time.

  • Heads of content who want query mapping settled before a draft ever reaches review.
  • Production leads who want the brief-to-draft handoff to run the same way every time.
  • Solo marketers drafting in Claude Code who want the structural step done to a standard.
  • Any team turning an LLM into a dependable stage of the pipeline rather than a wildcard.

How do you install the Brief to Outline skill?

One file in one folder, then call it by name.

  1. Save the SKILL.md file to ~/.claude/skills/brief-to-outline/SKILL.md on your machine.
  2. In Claude Code, invoke /brief-to-outline and hand it the filled brief. It asks for anything it still needs.
  3. Paste the returned skeleton into your draft document and hand it to the writer.

The skills hub carries the full install guide for the series.

What’s in the bundle?

Four pieces, one gated behind an email.

  • SKILL.md (raw): the Skill itself, one file; save it under ~/.claude/skills/brief-to-outline/ and it is installed.
  • One-pager PDF: the mapping rules and the skeleton format on a single printable page, for the editor who reviews outlines rather than builds them.
  • Google Doc (gated): a Drive-resident copy plus install notes. Submit your email to access; we also tag you for the Claude Skills for content operations email sequence so you hear when the next Skill lands.
  • Card image: the page hero, sized for sharing wherever you pass the Skill along.

Why we built it

Brief-to-Outline sits sixth in the ten-Skill series we run our own content operations on, taking over at the exact moment a brief through refresh. It sits between the brief and the draft, the exact point where a carefully chosen query cluster most often dissolves into whatever structure someone improvised under deadline.

The boundary matters as much as the function. This Skill ends at the skeleton and the Brief Drafter ends at the brief, so each stage of the series can be reviewed on its own terms before the next one begins.

Frequently asked questions

What is a Claude Skill?

An instruction file Claude Code loads when you call it. The SKILL.md holds frontmatter that names and describes the Skill, plus a body carrying its rules and output format. Install it once and it answers to its name from then on.

Do I need a paid Claude plan to use this?

The Skill is free and MIT licensed. What you need is Claude Code, since the Skill is a file that runs inside it.

Does it draft the article as well?

No. The outline is where it ends, by rule. Push it to write the body and it declines, pointing you at the Skill in the series built for that job. The hand-off is a skeleton with empty paragraphs, which keeps drafting a separate, reviewable step.

What happens if my brief is missing the query cluster?

It asks, and it waits. The file bars it from proceeding with placeholders and from inventing an input, so a brief with no queries comes back as a request for them rather than as an outline built on guesses.

Can I change the mapping rules?

Yes. The SKILL.md is plain markdown under an MIT license. Edit the hard rules section and every outline after that follows your version.

Will more Skills follow?

The series runs to ten Skills and this is the sixth. The next step in the workflow, once your writer fills the skeleton, is review, and that is the job of the Editor Checklist Skill, number seven in the series. Submit your email above to hear when each new Skill lands.

Ready to streamline your content operations?

Start your free trial and see the difference.