writing

name	writing
description	Use when full-stack content production factory — ad copy, emails, long-form articles, product descriptions. Turn words into revenue with data-driven writing pipelines.
domain	content
author	oyi77
license	Apache-2.0
subdomain	content-creation
tags	["content-creation","copywriting","ad-copy","email-marketing","long-form","product-descriptions","money-making"]
version	1.0.0

Content Writing Factory — Ad Copy, Emails, Long-Form, Product Descriptions

When Not to Use

• Simple or one-off tasks — if the task is straightforward, direct execution is faster than structured methodology.
• Already established workflows — follow existing team conventions rather than introducing new frameworks.
• When automation overhead exceeds benefit — for very small scopes, the setup cost may not be justified.

Dependencies

• Python 3.8+ or Node.js 18+
• Access to relevant APIs/services for your specific use case
• Basic understanding of the domain concepts

Commands

# Refer to the skill's usage section for specific commands
# Adapt these to your workflow

Money-Making Overview

Service	Client Price	Your Time	ROI
Ad copy (5 variations)	$500–$2,000	1–2 hrs	$400–$1,000/hr
Email sequence (5 emails)	$750–$3,000	2–4 hrs	$300–$750/hr
Long-form article (2,000 words)	$400–$1,500	1–2 hrs	$300–$750/hr
Product description (10 items)	$300–$1,000	1 hr	$300–$1,000/hr
Full content bundle (all 4 types)	$2,000–$7,000	5–10 hrs	$400–$700/hr

Target clients: E-commerce brands, SaaS startups, newsletters, agencies, course creators who need copy that converts but can't afford a full-time copywriter.

Delivery model: Per-project pricing or monthly retainer ($2,000–$5,000/mo for 4 articles + 2 email sequences + ad copy).

Combined Capabilities

Capability	Best For	Output Format	Avg Conversion Lift
Ad Copy	Meta, Google, TikTok, LinkedIn ads	Headline + body + CTA (5 variants)	15–40% CTR improvement
Email Writing	Newsletters, sequences, sales	Plain-text or HTML emails	20–50% open rate, 3–10% click rate
Long-Form Content	SEO blogs, thought leadership, guides	1,500–3,000 word articles	5–20x organic traffic
Product Descriptions	E-commerce, SaaS features, landing pages	Feature-benefit bullets + SEO copy	10–30% conversion uplift

Concrete Action Flow

Phase 1: Brief & Research (30 min)

import json
from dataclasses import dataclass, asdict

@dataclass
class ContentBrief:
    project_type: str  # "ad_copy" | "email" | "long_form" | "product_desc"
    client: str
    product_or_topic: str
    target_audience: str
    tone: str  # professional, casual, urgent, luxury
    key_benefits: list[str]
    call_to_action: str
    seo_keywords: list[str] = None
    competitor_examples: list[str] = None
    platform: str = "web"

    def to_prompt(self) -> str:
        return f"""
Write {self.project_type.replace('_', ' ')} for {self.client}.
Topic: {self.product_or_topic}
Audience: {self.target_audience}
Tone: {self.tone}
Key Benefits: {', '.join(self.key_benefits)}
CTA: {self.call_to_action}
Keywords: {', '.join(self.seo_keywords or [])}
Platform: {self.platform}
"""


# Save brief for repeatable workflow
def save_brief(brief: ContentBrief, path: str = ):
     (path, )  f:
        json.dump(asdict(brief), f, indent=)

Phase 2: Ad Copy Generation (1 hr)

def generate_ad_variants(
    product: str,
    audience: str,
    benefits: list[str],
    cta: str,
    platform: str = "facebook",
) -> list[dict]:
    """
    Generate 5 ad copy variations using different hooks.
    Returns list of { headline, body, cta } dicts.
    """
    hooks = {
        "problem": f"Stop {audience.lower()} from losing money on {product.lower()}.",
        "result": f"Get {benefits[0].lower()} — starting today.",
        "curiosity": f"Most {audience.lower()} don't know about this {product.lower()} secret.",
        "social": f"Join {audience.lower()} who switched to {product.lower()}.",
        "urgency": f"Last chance to get {benefits[0].lower()} with {product.lower()}.",
    }

    variants = []
    for hook_type, headline in hooks.items():
        body = compile_ad_body(hook_type, product, audience, benefits)
        variants.append({
            "variant": hook_type,
            "headline": headline,
            "body": body,
            "cta": cta,
            "platform": platform,
        })
    return variants


def compile_ad_body(hook: , product: , audience: , benefits: []) -> :
    
    bullet_benefits = .join(  b  benefits)
    bodies = {
        : ,
        : ,
        : ,
        : ,
        : ,
    }
     bodies.get(hook, bullet_benefits)

Phase 3: Email Sequence Writing (2 hrs)

def generate_email_sequence(
    product: str,
    audience: str,
    benefits: list[str],
    cta: str,
    sender_name: str = "Team",
) -> list[dict]:
    """
    Generate a 5-email sales sequence.
    """
    sequence = [
        {
            "subject": f"Quick question for {audience.lower()}",
            "preview": "I have a thought...",
            "body": f"Hey there,\n\nI noticed you're {audience.lower()}. I wanted to share something that's been helping people like you get {benefits[0].lower()}.\n\nMore tomorrow,\n{sender_name}",
        },
        {
            "subject": f"The {benefits[0]} problem (and how to fix it)",
            "preview": "Here's what most people miss...",
            "body": f"Hi again,\n\nMost {audience.lower()} struggle with {benefits[0].lower()}. They try everything but nothing sticks.\n\n{product} was built specifically for this. Let me show you how:\n\n" + "\n".join(f"• {b}" for b in benefits) + f"\n\nCheck it out: {cta}\n\n{sender_name}",
        },
        {
            "subject": f"Real results from ",
            : ,
            : ,
        },
        {
            : ,
            : ,
            : ,
        },
        {
            : ,
            : ,
            : ,
        },
    ]
     sequence

Phase 4: Long-Form Article (2 hrs)

def generate_article_outline(
    topic: str,
    audience: str,
    keywords: list[str],
    sections: int = 6,
) -> list[dict]:
    """
    Generate an SEO-optimized long-form article outline.
    Returns list of { heading, sub_points, word_target, keywords }.
    """
    outline = [
        {
            "heading": f"Introduction: Why {topic} Matters for {audience}",
            "sub_points": [
                f"The current state of {topic}",
                f"Why {audience} should care",
                "What you will learn in this guide",
            ],
            "word_target": 250,
            "keywords": [topic, f"{topic} guide"],
        },
    ]
    for i in range(1, sections):
        outline.append({
            "heading": f"Section {i}: {'Key ' if i > 1 else ''}Strategy {i} — {' '.join(topic.split()[:3])}",
            "sub_points": [
                f"Understanding {topic} from {audience} perspective",
                ,
                ,
            ],
            : ,
            : [, ],
        })
    outline.append({
        : ,
        : [
            ,
            ,
            ,
        ],
        : ,
        : [, ],
    })
     outline


 () -> :
    
    minutes = (, (word_count / ))
     


 () -> :
    
    lines = [ + outline[][].replace(, ) + ]
     sec  outline[:]:
        lines.append()
         sp  sec[]:
            lines.append()
    lines.append()
     .join(lines)

Phase 5: Product Descriptions (1 hr)

def generate_product_description(
    product_name: str,
    features: list[str],
    benefits: list[str],
    audience: str,
    seo_keywords: list[str] = None,
) -> dict:
    """
    Generate structured product description with variants.
    Returns short, medium, and long formats.
    """
    base = {
        "product": product_name,
        "audience": audience,
    }

    # Short (social media / listing title)
    base["short"] = f"{product_name} — {' • '.join(benefits[:3])}. Perfect for {audience}."

    # Medium (product page summary)
    bullets = "\n".join(f"  ✓ {b}" for b in benefits)
    base["medium"] = f"""## {product_name}

Designed for {audience.lower()} who need {benefits[0].lower()}.

What you get:
{bullets}

### Key Features
{"\n".join(f"  • {f}" for f in features)}

Ready to {benefits[0].lower()}? Get {product_name} today.
"""

    # Long (SEO-optimized landing page)
    seo_section = ""
    if seo_keywords:
        seo_section = 
    base[] = 
     base


 () -> :
    
    sections = []
     p  products:
        desc = generate_product_description(
            p[], p.get(, []), p.get(, []),
            audience, p.get(),
        )
        sections.append()
     .join(sections)

Phase 6: Format & Deliver

#!/usr/bin/env bash
# generate-content-bundle.sh
# Bundle all content into a client-ready deliverable.
# Usage: ./generate-content-bundle.sh client-name output-dir

set -euo pipefail
CLIENT="${1:?Usage: $0 client-name output-dir}"
OUT="${2:-./deliverables/$CLIENT}"
mkdir -p "$OUT"/{ads,emails,articles,products}

echo "Generated content bundle for $CLIENT"
echo "  Ads:        $OUT/ads/"
echo "  Emails:     $OUT/emails/"
echo "  Articles:   $OUT/articles/"
echo "  Products:   $OUT/products/"
echo "  Bundle:     $OUT/content-bundle.zip"

#!/usr/bin/env python3
"""
Full content factory orchestration.
Generate all 4 content types from a brief.
"""
import json, sys
from pathlib import Path

def produce_content_bundle(brief_path: str, output_dir: str):
    with open(brief_path) as f:
        brief = json.load(f)

    out = Path(output_dir)
    out.mkdir(parents=True, exist_ok=True)

    # Ad copy
    ads = generate_ad_variants(
        brief["product_or_topic"], brief["target_audience"],
        brief["key_benefits"], brief["call_to_action"],
    )
    with open(out / "ad-copy.json", "w") as f:
        json.dump(ads, f, indent=2)

    # Email sequence
    emails = generate_email_sequence(
        brief["product_or_topic"], brief["target_audience"],
        brief["key_benefits"], brief["call_to_action"],
    )
    with open(out / "email-sequence.json", "w") as f:
        json.dump(emails, f, indent=2)

    # Article outline
    outline = generate_article_outline(
        brief["product_or_topic"], brief["target_audience"],
        brief.get("seo_keywords", []),
    )
    with open(out / "article-outline.md", )  f:
        f.write(extract_headings(outline))

    
     brief.get():
        desc = generate_product_description(
            brief[], brief.get(, []),
            brief[], brief[],
            brief.get(),
        )
         (out / , )  f:
            f.write(desc[])

    ()

 __name__ == :
    produce_content_bundle(sys.argv[], sys.argv[])

First Action in 60 Minutes

1. Create a brief — brief = ContentBrief("ad_copy", "ClientX", "ProductY", "SaaS founders", "professional", ["save time", "reduce costs"], "Get Started")
2. Generate ad variants — ads = generate_ad_variants("ProductY", "SaaS founders", ["save time", "reduce costs"], "Get Started")
3. Generate email sequence — emails = generate_email_sequence(...) and save as JSON
4. Draft article outline — outline = generate_article_outline("remote work productivity", "managers", ["remote work", "productivity tips"])
5. Write product description — desc = generate_product_description("Widget Pro", ["API access", "team dashboards"], ["save 10 hrs/week", "reduce errors"], "engineers")
6. Ship it — Zip everything into a client folder. That's your $500–$2,000 deliverable.

Anti-Rationalization Table

Rationalization	Reality
"AI writes it all, no skill needed"	AI generates drafts; humans who know frameworks, hooks, and sequences command $200/hr+. The skill is the system.
"Ad copy is just words"	The right hook doubles CTR. Every variant you test is data your client pays for.
"Email sequences are dead"	Email ROI is 4,200%. Clients pay premium for sequences that actually convert.
"Product descriptions are filler"	Good product copy is the difference between browse and buy. E-commerce clients know this.
"Long-form is dying"	Long-form SEO content drives 10x more traffic than short posts. It's the highest-margin content type for agencies.

Client Deliverable Checklist

• Content brief documented and approved
• Ad copy: 5 variants (different hooks) with tracking UTM links
• Email sequence: 3–5 emails with subject lines and preview text
• Long-form article: outline + first draft (1,500–3,000 words)
• Product descriptions: short, medium, long variants
• Deliverables in client-ready format (no placeholder text)
• SEO keywords integrated naturally
• CTA is specific, trackable, and consistent across all pieces

Output Format

Standard client delivery folder:

client-name-content/
  brief.json               # approved brief for repeatability
  ads/
    facebook/              # 5 variants per platform
    google/
    linkedin/
  emails/
    01-welcome.md
    02-nurture.md
    03-sales.md
    04-close.md
  articles/
    article-outline.md
    draft.md
  products/
    description-short.md
    description-long.md
  content-bundle.zip       # all of the above

Verification Checklist

• Content brief created and saved
• Ad copy generated with 5 hook variants per platform
• Email sequence written with subject lines, preview text, body
• Long-form article outline drafted with word targets
• Product descriptions generated in 3 lengths
• All deliverables in client-ready format
• SEO keywords integrated (not stuffed)
• CTA is trackable and consistent
• No placeholder text, lorem ipsum, or "AI" artifacts remain

When to Use

Use this skill when working with writing.

Workflow

See the parent skill for authoritative workflow documentation.