Content Writing

Content Writing Skill

Purpose: Unified content creation workflow with comprehensive lineage tracking Subskills: outline, draft, edit, feedback Lineage: Tracks sources, reasoning, rule compliance, edit history, and persona feedback through YAML frontmatter + inline HTML comments

Usage

# Create outline
content-writing-skill outline <project-name> <asset-name> [--interactive]

# Generate draft
content-writing-skill draft <project-name> <asset-name> [--section "Section Name"]

# Review draft with persona-based feedback
content-writing-skill feedback <project-name> <asset-name> [--persona "name"] [--focus "area"]

# Edit content
content-writing-skill edit <file-path> --instructions "Edit instructions" [--section "Section Name"]

Routing Logic

This skill routes to the appropriate subskill based on the first argument:

• outline → subskills/outline-content.md
• draft → subskills/draft-content.md
• feedback → subskills/feedback-content.md
• edit → subskills/edit-content.md

Step 1: Parse Arguments

Extract subskill and arguments: $ARGUMENTS

Expected format:

• First argument: outline, draft, feedback, or edit
• Remaining arguments: passed to subskill

If no arguments or invalid subskill: Show usage help and available subskills.

Step 2: Load Shared Context

Project Context (for outline/draft/feedback)

If subskill is outline, draft, or feedback:

• Project name from arguments
• Locate project directory: /projects/<project-name>/
• Read project.md or project-brief.md for context
• Check for task-breakdown.md
• Locate draft file (for feedback subskill)

Rule Files Context (Dynamic)

Load all available rule types and directories from registry:

# Dynamically discover all enabled rule types
registry="rules/rules-config.yaml"
enabled_types=$(yq '.rule_types | to_entries | .[] | select(.value.enabled == true) | .key' "$registry")

# Build context for each rule type
for type in $enabled_types; do
  name=$(yq ".rule_types.${type}.name" "$registry")
  directory=$(yq ".rule_types.${type}.directory" "$registry")

  # Store for context handoff
  RULES_${type^^}_DIR="rules/$directory/"
done

Result: Dynamically available rule directories:

• RULES_STYLE_DIR: rules/style/ (built-in)
• RULES_STRUCTURE_DIR: rules/structure/ (built-in)
• RULES_PERSONAS_DIR: rules/personas/ (built-in)
• RULES_PUBLISHER_DIR: rules/publisher/ (built-in)
• RULES_VERTICALS_DIR: rules/verticals/ (if configured)
• RULES_CHANNELS_DIR: rules/channels/ (if configured)
• RULES_USE_CASES_DIR: rules/use-cases/ (if configured)
• [Any other custom rule types]

Validation

• Confirm project directory exists
• Dynamically load rule types from registry
• Confirm referenced rule directories exist
• Log any missing directories as warnings
• Check if rule files exist in each directory

Step 3: Route to Subskill

For outline: Invoke subskills/outline-content.md with arguments:

• Project name
• Asset name
• Optional flags (--interactive, --template-override)
• Loaded context (project, rules)

For draft: Invoke subskills/draft-content.md with arguments:

• Project name
• Asset name
• Optional flags (--section)
• Loaded context (project, rules, outline path)

For edit: Invoke subskills/edit-content.md with arguments:

• File path to edit
• Edit instructions (--instructions flag)
• Optional flags (--section, --mode, --focus)
• Loaded context (project if derivable, rules)

Step 4: Context Handoff

Pass the following to subskills:

Shared Context:

PROJECT_NAME: <name>
PROJECT_PATH: /projects/<name>/
PROJECT_BRIEF: /projects/<name>/project.md
REGISTRY_PATH: rules/rules-config.yaml

[Dynamically generated rule directory paths for all enabled types:]
RULES_PUBLISHER_DIR: rules/publisher/
RULES_STYLE_DIR: rules/style/
RULES_STRUCTURE_DIR: rules/structure/
RULES_PERSONAS_DIR: rules/personas/
RULES_VERTICALS_DIR: rules/verticals/ (if configured)
RULES_CHANNELS_DIR: rules/channels/ (if configured)
RULES_USE_CASES_DIR: rules/use-cases/ (if configured)
[... any other custom rule types]

ENABLED_RULE_TYPES: <comma-separated list of enabled types>

Note: Subskills should dynamically iterate over ENABLED_RULE_TYPES rather than assuming specific rule types exist. This ensures compatibility with custom rule configurations.

Asset-Specific Context (outline/draft):

ASSET_NAME: <name>
ASSET_OUTPUT_DIR: /projects/<name>/drafts/
OUTLINE_PATH: /projects/<name>/drafts/<name>-outline.md (if exists)
DRAFT_PATH: /projects/<name>/drafts/<name>-draft.md (if exists)

Step 5: Lineage Tracking Standards

All subskills must follow these lineage tracking conventions:

YAML Frontmatter (High-Level)

• Track rule files applied
• Track source documents used
• Track update patterns applied (project-specific)
• Track quality metrics and compliance
• Track edit sessions and version history

Inline HTML Comments (Granular)

• Section-level source attribution
• Reasoning for additions/changes
• Update pattern application notes
• Rule compliance notes

Metadata Templates

Use templates from /skills/content-writing-skill/templates/:

• outline-metadata-schema.yaml
• draft-metadata-schema.yaml
• inline-comment-patterns.md

Error Handling

If project not found:

Error: Project '<name>' not found in /projects/

Available projects:
  - project-1
  - project-2

Create a new project with: /create-project "<name>"

If rule files missing:

Warning: Some rule files not found:
  - rules/personas/data-engineer.md

Continue anyway? (Y/n)

If subskill invalid:

Error: Unknown subskill '<name>'

Available subskills:
  - outline  : Create detailed content outline
  - draft    : Generate content draft from outline
  - edit     : Interactive content editing

Usage: content-writing-skill <subskill> [arguments]

Success Indicators

✅ Skill invoked successfully when:

• Subskill identified and routed correctly
• Shared context loaded and validated
• Subskill execution completes
• Output includes proper lineage metadata

✅ Lineage tracking complete when:

• YAML frontmatter includes all required fields
• Section-level inline comments present
• Source documents referenced
• Rule compliance documented
• Edit history tracked (for edits)

Integration with Existing Workflow

This skill replaces the following slash commands:

• /outline-content → content-writing-skill outline
• /write-content → content-writing-skill draft
• /edit-content → content-writing-skill edit

Advantages over commands:

• Unified entry point with consistent context loading
• Enhanced lineage tracking built-in
• Reusable metadata templates
• Better error handling and validation
• Skill can be invoked by other skills

Next Steps After Invocation

After successful subskill execution, suggest next steps:

After outline:

✅ Outline created: /projects/<name>/drafts/<name>-outline.md

Next steps:
  1. Review outline structure and section flow
  2. Generate draft: content-writing-skill draft <project> <asset>
  3. Or edit outline: content-writing-skill edit <outline-path> --instructions "..."

After draft:

✅ Draft created: /projects/<name>/drafts/<name>-draft.md
   Word count: X words
   Rule compliance: Y%

Next steps:
  1. Review draft for accuracy and completeness
  2. Edit draft: content-writing-skill edit <draft-path> --instructions "..."
  3. Or check lineage: grep "SECTION:" <draft-path>

After edit:

✅ Edit session complete: <file-path>
   Version: X.Y
   Sections modified: [list]
   Session ID: <id>

Next steps:
  1. Review changes in file
  2. Further edits: content-writing-skill edit <file-path> --instructions "..."
  3. Check edit history: head -100 <file-path> | grep "edit_sessions:"

This is the main entry point for the content-writing-skill. It provides unified routing to outline, draft, and edit subskills with comprehensive lineage tracking capabilities.