Copy Studio

Copy Studio — staged marketing-copy pipeline (5 stages + recipe library + optional localization)

Purpose

Run one marketing-copy job through five stages in order, stopping after each stage for the user to approve or edit before the next begins:

1. Strategy (via brainstorming) — goal, target user, fears/pains, desires/selling points, result-oriented value proposition
2. Framework (via writing-plans) — the section/slide/post structure, each block tied to a pain or desire
3. Draft (via copywriting) — write the actual copy on that framework
4. Polish (via copy-editing) — the Seven Sweeps line edit
5. De-AI (via humanizer) — remove AI tells, match a human/brand voice → final deliverable

Plus an optional final step: when the finished copy must ship in a language other than the one it was written in — a German FB group, a Japanese landing page, a Spanish Instagram thread — a sixth step localizes it via a localization skill. Translation happens ONLY here — Stages 1–5 have no translation step, so their output stays in the source language; the target language first appears at Stage 6. It is conditional (skip it when the deliverable is already in its target language) and localizes only to the channel's language(s), locked at Stage 0 — never a default full-language fan-out for a single-channel piece. See Working vs deliverable language and Stage 6.

It is for marketing copy of many kinds — community posts and comment replies, social captions, landing-page value modules and full pages, deck slides, ads, emails, and more (see Output recipe). The point of merging these skills here is one entry point, one carried-through strategy, and a guaranteed review gate between stages — not a faster auto-run.

Three principles run through everything below — #1 is the soul of every piece of copy:

1. Result-oriented is the spine — EVERY piece of copy follows it, whatever the type or channel. Work the chain every time: target user → their fear / pain → their desire / selling point → land on the result: tell and SHOW them the concrete benefit and value they get. Never a feature list. The copy type / recipe only decides the shape; this chain is what fills it.
2. The copy is the deliverable. The gates, the framework, and any image / visual direction all exist to serve the words. When in doubt, spend the effort on the copy.
3. General process, brand-tuned output. The five-stage process is general-purpose. The house voice, the domain routing, and the calibration samples are yours to supply — see Bring your own brand reference below. This skill ships with no brand baked in.

Bring your own brand reference (read before first use)

This skill deliberately contains no brand facts, no product stats, no prize/reward figures, and no verbatim sample copy — those are specific to whoever runs it, and inventing them is the single worst failure mode in marketing copy. Before real work, create your own reference files under references/ and point this skill at them:

• A fact base — the only citable source for your product's stats, capabilities, URLs, pricing, and any program/reward figures. Rule: quote it verbatim, never round, never re-derive from memory, and mark anything absent as TBD instead of guessing.
• A channel calibration file — 2–3 approved, real samples per channel you actually ship to (landing module, community post, comment reply, deck slide, caption, email). These teach shape and voice far better than any description.

references/channel-calibration-template.md in this repo is an empty scaffold for both. Everywhere below that says "cite your fact base" means that file — not the model's memory. If you have no fact base yet, every number in a draft must be marked TBD and surfaced at the gate.

Working vs deliverable language — covers the whole pipeline, read this first

Two layers, treated separately. Set both at Stage 0; the defaults below suit a team whose working language differs from its market's language (adjust to your own setup).

• Working layer (everything you say to the user / their reviewers). One language throughout — Stage 0 intake, the Stage 1 brief, the Stage 2 outline, every gate menu, the reasoning behind an angle, self-check notes, narration. Default: the language the user is talking to you in.
• Deliverable layer (the copy that actually ships). The audience's language. If the channel's audience speaks the working language, both layers coincide and there's nothing special to do.
• When the deliverable must ship in a third language → run Stages 1–5 in the source language, and only then localize at Stage 6. Do the strategy, framework, draft, polish, and de-AI work in one source language, land an approved master, then hand it to a localization skill for localization, not literal translation: per-market search intent, consistent terminology, brand voice, per-language length and format. The result-oriented spine and the voice get built once, in the master.
• ⚠️ Never skip the source-language master just because you know the final language. Writing straight into the target language from Stage 1 loses the strategy work and produces translationese.
• ⚠️ Target language = the channel's language, locked at Stage 0 — not a default full set. A single-channel piece (one comment / post / ad / page) ships in one language: replying to a Spanish post produces Spanish only. Multi-language fan-out belongs to site-wide, multi-market content (blog, SEO metadata, UI strings) — applying it to one comment and emitting 17 versions is a bug. Multi-language requires that the job itself spans markets, or that the user asked.
• Attach a working-language note to every deliverable. When you present copy in a language a reviewer may not read, put a short note beside it: what this line is doing and why it's written that way. The note is support — it never replaces or edits the deliverable.

This section overrides any language convention implied elsewhere in this file.

Scope — what this supports

Any marketing copy that ships to a named channel. The recipe library below covers: landing-page value module cards, full landing pages, community seeding posts, comment replies (invite · contest · creator recruitment · support), social captions per platform, deck slides (launch · single-product spotlight · partner/KOL), ads, emails, and image-heavy template emails. Anything not in the library gets its six fields filled live (see Fallback).

When NOT to use

• The user wants one stage only ("just polish this", "just write a headline", "de-AI this") → invoke that single skill directly.
• It is a software/feature task → use brainstorming and writing-plans in their native code mode, not this pipeline.

Core rule: staged, confirm between stages

Never run all five stages in one pass. After every stage, present the output and STOP. Do not start the next stage until the user responds. Stages 1 and 2 especially need the user's judgment — that is where strategy gets locked in, and silently guessing it wastes the whole pipeline.

The strategy gate is a HARD stop — no exceptions, not even for a one-line comment. You may NEVER present a later stage's output in the same message where you first propose the strategy. Concretely: the turn where you show the Stage 1 strategy (for a small unit, the compressed strategy+framework) contains no draft, no candidate copy, no finished deliverable — it ends at the gate and waits. Producing the framework/draft/polished copy before the user has approved the strategy direction is the #1 failure of this skill: it means you decided the angle for them and raced to a deliverable they never signed off on. If you catch yourself about to output both the strategy and the copy in one turn, stop and output only the strategy.

Reframing brainstorming & writing-plans for copy (read this — it is load-bearing)

brainstorming and writing-plans are written for software work. Used as-is on copy they will talk about architecture, write test tasks, save specs to a docs path, and try to git commit. That is wrong here, and the commit will fail because this is not a code repo. When you invoke them, override their defaults with the frames below. You are borrowing their thinking discipline (one question at a time; a structured outline before writing), not their code machinery.

For both: no architecture/components/data-flow/testing language, no code blocks, no test frameworks, no file paths as tasks, no git commits, and no auto-transition to the next skill. Keep artifacts inline in the conversation; save to a file only if the user asks. STOP at the gate instead of chaining onward.

Stage 0 — Intake (you do this directly, before Stage 1)

In one short exchange, lock the logistics so the rest runs clean:

• Copy type (→ output recipe): which artifact — landing-page value module card / full landing page / community post / comment reply (invite · contest · creator recruitment · support) / social caption / deck slide / ad / email / template email / other. For social, note the platform (X / LinkedIn / Instagram / Facebook / Reddit / a regional platform). This picks the recipe Stage 3 fills; if the type isn't in the library, fill the six-field template live and confirm at the Stage 3 gate.
• The asset & goal in one line: e.g. "acquisition post for feature X", "selling-points deck for sales", "traffic landing page hero + sections".
• Scope: a single small unit (one card / post / comment / caption / ad) or a whole page / deck / campaign? This sets how heavy Stages 1–2 are — lightweight/inline for a small unit, full multi-turn for a big one — but Stages 1–2 (the result-oriented core) always run; never skip them.
• Working language + deliverable language (see that section): lock the target language by channel at intake, since it decides whether Stage 6 runs at all and into which language. Single channel = single language.
• Source material: product brief, feature notes, screenshots, prior copy, reviews/voice-of-customer — or "infer conservatively from the product name/category".
• Grounding rule (state it back): every claim must trace to the source; mark gaps as TBD rather than inventing. These drafts may go to a stakeholder, so fabrication is not acceptable. Reusable product facts come from your fact base (see Bring your own brand reference) — cite that file, never recalled figures.

Then say which stage you're starting at (Stage 1 by default, or a later stage if the user already has a brief/draft — see Entering mid-pipeline), and begin.

The stages (five core + optional Stage 6 localize)

Stage 1 — Strategy · invoke brainstorming

Frame it: "This is marketing copy, not software. The 'design' you are producing is a copy strategy brief." Drive brainstorming's one-question-at-a-time dialogue and its 2–3 alternative angles (positioning, not architecture) toward a brief that nails:

• Goal — acquisition / explain the value / drive traffic / convert / educate (pick the real one).
• Target user — a specific segment, not "everyone".
• Fears = pain points — what goes wrong, what they're stuck on, what they're afraid of.
• Desires = selling points — what they want to achieve, feel, sell, or prove.
• Result-oriented value proposition — the value/benefit shown to the user ("you get / you avoid / you can now…"), never a feature list.

Gate: present the brief, get approval or edits. Do not proceed to Stage 2 on your own.

Stage 2 — Framework · invoke writing-plans

Frame it: "The 'implementation plan' here is the copy framework / outline for this channel — not code tasks." Produce a block-by-block structure (sections for a landing page, slides for a deck, post beats for social) where each block names its job, the one pain or desire it carries (drawn from the Stage 1 brief), the result-oriented message, and an approximate length/format for the channel. Map the through-line (hook → value → proof → CTA, adapted to the channel). The Stage 1 brief is the spine — every block must trace back to the goal/user/pain/desire. For a landing page the framework is the ordered list of modules to spec; for a deck, the slides; for social, the post angles. Stage 3 then fills each block using its output recipe.

Gate: present the framework, get approval or edits.

Stage 3 — Draft · invoke copywriting (or a domain skill — see routing)

Write the real copy on the approved framework, in the source language, producing the type's output recipe — for a landing page that means polished copy for every module (title options + one description sentence) first, plus supporting image direction. Apply copywriting's principles: benefits over features, specificity over vagueness, customer language, one idea per block. Keep the grounding rule: mark anything unsupported TBD; cite facts from your fact base.

Domain routing. If you maintain skills for specific artifacts, route to them instead of generic copywriting — e.g. a structured product-overview skill for catalog rows, or a full-page architecture skill when a brand-new page needs its whole structure (hero / how-it-works / FAQ / CTA) rather than module copy. List your own routes here. Anything unrouted → stay in copywriting.

Stage 3 pre-show self-check (run these binary checks silently before showing the draft; fix any FAIL in place — do not show the checklist):

1. Voice — plain, confident, concrete, benefit + the mechanism that earns it; zero hype words (revolutionary / seamless / effortless / unleash / game-changing).
2. Grounding (hard stop) — every number, claim, and capability traces to the fact base; unsupported claims marked TBD, not guessed.
3. Shape — matches the type's six-field recipe, not generic prose (required beats present, none bolted on).
4. Length — inside the type's size budget; not padded.
5. No AI tells — no em-dash overuse, forced rule-of-three, "not X but Y", AI-vocab (delve / leverage / robust / elevate / foster).
6. Copy-first — words lead; image/layout direction is secondary, or "none" for words-only types.
7. Channel rules (hard stop) — Reddit: zero links/hashtags, no rewards in the main comment; emoji only on social/community; clean output (mark emphasis with 【】, never raw HTML).
8. Language — the deliverable is in the channel's language; each deliverable carries its working-language note; all conversation with the user stays in the working language.

Never ship a draft that fails check 2 or 7. If a FAIL needs a missing fact, mark TBD and surface it at the gate.

Gate: present the draft, get approval or edits.

Stage 4 — Polish · invoke copy-editing

Run the Seven Sweeps over the draft (clarity, voice/tone, so-what, …). Enhance, don't rewrite; preserve the message and the on-strategy claims from the brief.

Gate: present the polished copy, get approval or edits.

Stage 5 — De-AI · invoke humanizer

Remove AI tells and make it sound like a real person/brand. If the user has a voice sample (prior posts, a brand guide, a past page that sounds right), feed it to humanizer for voice calibration — otherwise use its default natural-voice mode. If no localization is needed, this is the final deliverable: present the finished copy plus a one-line note of what changed from the polished version, and attach the working-language note alongside it so reviewers can read it. If the deliverable must ship in another language, this is the source-language master that feeds Stage 6.

Stage 6 (optional / conditional) — Localize

This is the ONLY step where translation happens. Stages 1–5 run in the source language; a third language appears only here.

Trigger test (all must be YES): 1

…

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: Ekko237
• Source: Ekko237/copy-studio
• License: MIT

Install and usage instructions live in the source repository linked above.