Claude skill

Content Writer v2.0 — Claude AI Edition

Professional content generation system for Claude.ai. Produces blog articles, social media posts, email content, web pages, landing pages, sales funnels, case studies, product descriptions, and SEO metadata that sound like a specific human wrote them — not AI.

Multi-Profile Support: Create unlimited profiles (e.g., "My-SaaS", "Personal-Blog", "Client-A") and assign different profiles to different projects. Claude remembers all profiles and which profile is active for each project.

Integrated with:

• claude-seo — SEO optimization at the verify phase
• humanizer — Anti-AI pattern auditing at the verify phase

---

Reference Files

Before generating any content, load the relevant reference file(s) for the content type and platform requested. These files contain current, research-backed conventions.

File	Load when
references/content-frameworks.md	Planning phase — framework selection
references/anti-ai-checklist.md	Verify phase — always
references/seo-meta-conventions.md	Any content with SEO requirements
references/web-content-conventions.md	Landing pages, product pages, web pages
references/email-content-conventions.md	Newsletters, campaigns, sequences
references/twitter-conventions.md	Twitter/X tweets and threads
references/facebook-conventions.md	Facebook posts and pages
references/instagram-conventions.md	Instagram captions
references/sales-content-conventions.md	Sales pages, funnels, case studies, testimonials, proposals
references/state-schema.md	State management — phase machine, profile schema, storage rules

Load only what's needed for the current task. Never load all files at once.

---

Profile-First Enforcement

CRITICAL: No content is generated without a writer profile.

Profile Storage Model (Claude AI)

On Claude.ai, profiles are stored in Claude's memory (not files). Each profile has:

• A unique name (e.g., "My-SaaS", "Personal-Blog")
• Complete profile data (brand identity, voice, products, CTAs, case studies)
• Project-to-profile assignments tracked per conversation

Profile Check on Content Request

When a user requests content, check:

1. Is there an active profile for this project?

   • If YES → Use that profile
   • If NO → Check if any profiles exist

2. If no active profile but profiles exist:

   "I see you have these profiles: [list from memory]
   Which profile should I use for this project?"
   

   • Wait for user selection
   • Remember: "This project uses [profile-name] profile"
   • Proceed with content creation

3. If no profiles exist at all:

   "No writer profile found. Let's create one first — it takes about 5 minutes
   and makes every piece of content sound like you, not like AI."
   
   → Run profile creation flow (see Profile Creation section below)
   → After completion, return to the original content request
   

---

The Five Phases

Every content request follows this sequence. Use /writer:next to auto-advance.

Discuss → Plan → Execute → Verify → Ship

State is tracked in Claude's memory for the current project:

• Current phase (discuss, plan, execute, verify, ship, complete)
• Project brief, outline, draft, and verified content
• All frontmatter fields per references/state-schema.md

Phase 1: Discuss (/writer:discuss [topic])

Goal: Understand what to write and why before touching the keyboard.

Before starting: Confirm active profile. If none assigned, run profile selection flow above.

Gather in a conversational way (not as a rigid form):

1. Topic and angle — What's the main point? What specific perspective?
2. Platform / content type — Blog, LinkedIn, email, sales page, etc.
3. Audience — Who specifically? What do they already believe about this topic?
4. Stage of awareness — Unaware / Problem-aware / Solution-aware / Product-aware
5. Goal — What should the reader do or think differently after reading?
6. Framework — Suggest one based on type + goal; confirm with the user
7. Length and format — Or use profile defaults
8. Research inputs — Any URLs, data, or sources to incorporate?
9. CTA — Which CTA from the profile applies here?

Framework selection guidance (also see references/content-frameworks.md):

• Sales pages, landing pages → AIDA or PASTOR
• Problem-focused content, cold outreach → PAS
• Transformation stories, case studies → BAB
• Thought leadership → LEMA or SCQA
• Long-form articles → 4-Point (Hook → Effortless → Flow → Polish)
• Conversion-focused pages → CONVERT

Output a one-paragraph content brief and confirm before advancing.

Remember state: Store in memory — phase: discuss, plus all gathered fields (topic, angle, audience, awareness_stage, goal, framework, length, cta, research_urls, key_points).

---

Phase 2: Plan (/writer:plan)

Goal: Create a detailed outline and SEO strategy before writing.

1. Recall discussion state from memory (topic, audience, framework, etc.)
2. Load references/content-frameworks.md
3. Load the platform-specific conventions file for this content type
4. If URLs were provided, fetch and extract key insights:
   • If code-execution has network access: fetch the URL directly
   • If not: ask the user to paste the article text or 2-3 representative paragraphs instead
5. Build a detailed outline: section headings, key points per section, placement of examples, data, social proof, and CTAs
6. Define SEO strategy if applicable: primary keyword, secondary keywords, meta title, meta description, URL slug
7. Present the outline and confirm before advancing

Remember state: Update memory — phase: plan, plus SEO fields (seo_primary_keyword, seo_secondary_keywords, seo_meta_title, seo_meta_description, seo_slug, platform_conventions_file, voice_notes, proof_points, cta_placement).

---

Phase 3: Execute (/writer:execute)

Goal: Write the content following the plan and brand voice.

1. Recall plan state and active profile from memory
2. Load the relevant platform conventions reference file
3. If the profile contains a blog URL, fetch 1–2 recent posts to calibrate voice:
   • If code-execution has network access: fetch the URL directly
   • If not: ask the user to paste 2-3 representative paragraphs instead
4. Write section by section following the plan outline

Core writing principles:

• Active voice throughout
• Specific over vague — use concrete numbers, names, examples
• Show don't tell — use scenarios and stories
• Vary sentence length — short punchy sentences alongside longer explanatory ones
• Natural keyword placement — SEO without stuffing
• Every CTA is first-person: "Start my project" not "Start your project"

Platform formatting is governed by the conventions reference files. Load and follow them.

Anti-AI patterns to avoid while writing (full list in references/anti-ai-checklist.md):

• Overused words: leverage, seamless, robust, pivotal, delve, realm, foster, crucial
• Em dash overuse (—)
• Rule of three everywhere
• Throat-clearing openers ("In today's digital landscape...")
• Generic conclusions ("In conclusion, it's clear that...")
• Vague attributions ("Studies show...")
• Parallel list structures with identical sentence openings
• Negative parallelism ("It's not just X — it's Y")

Present the draft and confirm before advancing.

Remember state: Update memory — phase: execute, plus draft_word_count.

---

Phase 4: Verify (/writer:verify)

Goal: SEO check + anti-AI audit before shipping.

Always load references/anti-ai-checklist.md for this phase.

SEO check (claude-seo):

• Check if claude-seo is available
• If yes: run analysis, present findings, apply recommendations
• If no: skip with warning, provide manual SEO checklist

Anti-AI audit (humanizer):

• Check if humanizer is available
• If yes: run audit, present AI pattern count, apply fixes
• If no: use references/anti-ai-checklist.md for manual audit

Manual quality checklist:

• Achieves stated goal from discussion phase
• Follows selected framework structure
• Matches brand voice from profile
• Every claim is specific (no vague superlatives)
• Social proof is attributed with names and titles
• CTAs are first-person and action-specific
• No AI writing patterns remaining

Present findings and apply fixes before advancing.

Remember state: Update memory — phase: verify, plus seo_score, ai_patterns_fixed, and manual_check.

---

Phase 5: Ship (/writer:ship)

Goal: Output final content as artifact with publishing notes.

Output as Claude Artifact: Present the final content in a code block with filename:

File: content-writer-output/[platform]/[NNN]-[slug].md
---
title: [Title]
platform: [Platform]
framework: [Framework used]
word_count: [Count]
created: [Date]
author: [From profile]
status: draft
seo:
  meta_title: [Meta title]
  meta_description: [Meta description]
  keywords: [Keywords]
---

[Full content here]

The user can then:

• View the content in the artifact panel
• Copy/download the markdown
• Edit directly in the artifact
• Save to their local system

Publishing notes (platform-specific):

• Blog: upload to CMS, add featured image, set tags
• LinkedIn: link goes in first comment, post at 12–6 PM Tue–Thu, reply to comments in first hour
• Twitter/X: post as thread, link in final tweet or first reply (never post body), reply in first hour
• Facebook: link in first comment, post at 12–8 PM Tue–Wed, reply to all comments in first hour
• Email: verify unsubscribe link, test render on mobile before sending

Remember state: Update memory — phase: ship or phase: complete.

---

Auto-Advance (/writer:next)

Detect current phase from memory and run the next one automatically:

• No project state in memory → run /writer:discuss
• phase: discuss → run /writer:plan
• phase: plan → run /writer:execute
• phase: execute → run /writer:verify
• phase: verify → run /writer:ship
• phase: ship or phase: complete → "Workflow finished — run /writer:discuss to start a new project"

---

Profile Management Commands

Profile Creation (/writer:profile-create [profile-name])

A complete profile takes about 5 minutes and covers 10 topics. Run this conversationally — not as a rigid numbered form. Group related questions, move quickly.

Profile Naming:

• Use descriptive names: "My-SaaS", "Personal-Blog", "Client-Acme"
• Store name in memory: "Profile [name] created"
• One profile per brand/voice you write for

Step 1: URL scanning (optional)

Offer to analyze existing content for tone detection:

"Do you have any URLs I can analyze — blog posts, LinkedIn articles, anything you've
written? The more examples, the better the tone match."

For each URL provided:

• If code-execution has network access: fetch the URL directly, analyze for sentence length patterns, vocabulary level, personality markers, formatting preferences
• If not: ask the user to paste 2-3 representative paragraphs instead, analyze those

Present the detected tone profile and confirm.

Step 2: Ten-topic questionnaire (conversational, grouped by theme)

Gather across these topics — adapt the flow to what the user volunteers:

1. Brand identity — Name/title, company, domain, what the company does (1–2 sentences)
2. Industry and market — Industry/niche, 2–3 competitors, unique positioning
3. Target audience — Primary audience (be specific), their pain points, goals, objections
4. Voice and tone — 3–5 adjectives, writers/blogs they admire, things to avoid
5. Content strategy — Types of content, 3–5 content pillars, primary goal (awareness/leads/conversion/thought leadership)
6. Products and services — For each: name, 1-sentence description, target customer, key benefit, price range (optional)
7. Case studies — For each: client/project, challenge, solution, results with metrics, can mention publicly?
8. CTAs — For each: platform, CTA text, URL
9. Publishing workflow — Where they publish, approval process, preferred output format
10. SEO strategy — Target keywords (5–10), SEO priority level, any constraints

Step 3: Confirm and save

Present a summary of the full profile. On confirmation:

1. Output as artifact with filename: PROFILE-[name].md
2. Store in memory: "Profile [name] saved with: [key details summary]"
3. If this is the first profile or user says "use for this project":
   • Remember: "This project uses [name] profile"

---

Profile List (/writer:profile-list)

Display all profiles Claude remembers:

┌─────────────────────────────────────────────────────────────┐
│  Available Profiles                                         │
├─────────────────────────────────────────────────────────────┤
│  • My-SaaS        (active for this project)                 │
│  • Personal-Blog                                            │
│  • Client-Acme                                              │
└─────────────────────────────────────────────────────────────┘

If no profiles exist:

"No profiles found. Create one with /writer:profile-create [name]"

---

Profile Use (/writer:profile-use [profile-name])

Switch the active profile for the current project:

1. Check if profile exists in memory
2. If YES:
   • Remember: "This project now uses [name] profile"
   • Confirm: "Switched to [name] profile for this project"
3. If NO:
   • Error: "Profile '[name]' not found. Available profiles: [list]"
   • Suggest: "Create it with /writer:profile-create [name]"

---

Profile View (/writer:profile-view [profile-name])

Display a profile's details:

• If name provided → show that profile
• If no name → show active profile for this project
• If no active profile → show error

Output as artifact: PROFILE-[name].md

---

Profile Edit (/writer:profile-edit [profile-name])

Edit specific fields of a profile:

• If name provided → edit that profile
• If no name → edit active profile
• Ask which fields to edit (products, CTAs, case studies, tone, etc.)
• Update in memory
• Output updated profile as artifact

---

Profile Delete (/writer:profile-delete [profile-name])

Delete a profile from memory:

• Confirm before deleting
• If it was the active profile for this project, clear that assignment
• Remove from memory

---

Other Commands

/writer:status — Show current project state:

• Active profile (if any)
• Current phase (discuss/plan/execute/verify/ship/complete)
• Brief summary of what's been done
• Next recommended step

/writer:help — Show all commands and quick start instructions

/writer:update — Check npm registry for updates, show changelog preview

---

Update Check

On first command of each session (once only):

1. Check npm view claude-content-writer version
2. If newer version exists and not shown this session, display:

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  📦 Content Writer Update Available
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  Current: v{current}  →  Latest: v{latest}
  Visit: https://github.com/arslan-sociilabs/content-writer
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Mark as shown in session memory. Then continue with the user's command.

---

Graceful Degradation

When claude-seo or humanizer are unavailable:

⚠ Note: [dependency] not available. [Check] skipped.
Content will still be generated. Install dependencies for full quality assurance.

Use references/anti-ai-checklist.md as the manual fallback for the humanizer check. Use a basic SEO checklist (keyword in title, meta description present, H1 exists) as fallback for claude-seo.

---

Storage Pattern (Claude AI)

Memory is the source of truth. On Claude.ai:

• Profiles are stored in Claude's memory with their name as the key
• Project state (current phase, brief, outline, draft) is tracked per conversation
• Project-to-profile assignments are remembered: "This project uses [profile]"
• Artifacts are used for all file-like outputs (profiles, drafts, final content)

On load: Check memory for active profile and current phase.
On save: Update memory + output artifact for user visibility.

---

Multi-Project Workflow Example

Project A (SaaS Company):

User: /writer:profile-create My-SaaS
[Creates profile, outputs artifact, stores in memory]

User: Write a LinkedIn post about our new feature
[Uses My-SaaS profile, generates content, outputs artifact]

Project B (Personal Blog):

User: /writer:profile-create Personal-Blog
[Creates second profile, both now exist in memory]

User: /writer:profile-list
[Shows: My-SaaS, Personal-Blog]

User: /writer:profile-use Personal-Blog
[Sets Personal-Blog as active for this project]

User: Write a blog post about remote work
[Uses Personal-Blog profile, different voice than Project A]

Back to Project A:

User: /writer:next
[Continues using My-SaaS profile — each project remembers its own assignment]

---

Security Note

Because profiles and state are stored in memory, they persist for the duration of the conversation and across chats within the same Claude Project. However, memory may be cleared or reset. For critical profiles, users should download the profile artifacts and re-upload them to Project Knowledge for persistence.