storyboard-manager
Storyboard Manager assists writers with creative writing projects by providing tools for character development, plot structuring, chapter composition, and consistency verification. Use this skill when working with organized writing folders containing character profiles, chapter drafts, story planning documents, and project summaries to accomplish tasks like developing characters, writing new chapters, tracking event timelines, and identifying narrative inconsistencies across the manuscript.
git clone --depth 1 https://github.com/ailabs-393/ai-labs-claude-skills /tmp/storyboard-manager && cp -r /tmp/storyboard-manager/packages/skills/storyboard-manager ~/.claude/skills/storyboard-managerSKILL.md
# Storyboard Manager
## Overview
The Storyboard Manager skill equips Claude with specialized knowledge and tools for creative writing workflows. It provides frameworks for character development, story structure patterns, automated timeline tracking, and consistency checking across narrative projects. This skill automatically adapts to various storyboard folder structures while maintaining best practices for novel, screenplay, and serialized fiction writing.
## Core Capabilities
The skill provides four main capabilities:
### 1. Character Development & Management
Support creating deep, consistent character profiles with backstories, arcs, and relationships.
### 2. Story Planning & Structure
Guide plot development using established frameworks (Three-Act, Hero's Journey, Save the Cat, etc.) and help organize narrative elements.
### 3. Chapter & Scene Writing
Generate chapter content, scene breakdowns, and dialogue that maintains consistency with established characters and plot.
### 4. Timeline Tracking & Consistency Checking
Use automated tools to verify chronological consistency, character continuity, and world-building coherence.
## Detecting Project Structure
The Storyboard Manager automatically detects and adapts to various folder organizations. Look for these common directory patterns:
**Character folders:** `characters/`, `Characters/`, `cast/`, `Cast/`
**Chapter folders:** `chapters/`, `Chapters/`, `scenes/`, `Scenes/`, `story/`
**Planning folders:** `story-planning/`, `planning/`, `outline/`, `notes/`
**Summary files:** `summary.md`, `README.md`, `overview.md`
When triggered, scan the project root to identify the structure and adjust workflows accordingly. If no standard structure exists, recommend organizing files using the pattern: `characters/`, `chapters/`, `story-planning/`, and `summary.md`.
## Workflow Decision Tree
Use this decision tree to determine the appropriate workflow:
```
User Request
├─ Character-related? ("develop character," "create backstory," "character arc")
│ └─ → Character Development Workflow
│
├─ Planning/Plot? ("outline story," "plan act 2," "plot structure")
│ └─ → Story Planning Workflow
│
├─ Writing content? ("write chapter," "generate scene," "continue story")
│ └─ → Chapter/Scene Writing Workflow
│
└─ Checking/Analysis? ("check consistency," "track timeline," "find contradictions")
├─ Timeline? → Use timeline_tracker.py script
└─ Consistency? → Use consistency_checker.py script
```
## Character Development Workflow
### Step 1: Gather Context
Before developing a character, read existing character files to understand:
- Established naming conventions and profile format
- Existing characters and relationships
- Story genre and tone
- Character archetypes already in use
Use the Read tool to examine existing character files in the characters directory.
### Step 2: Access Character Development Framework
When detailed character guidance is needed, read `references/character_development.md` which contains:
- Core character elements (personality, motivation, goals)
- Backstory framework (ghost/wound, formative relationships)
- Character arc types (positive change, flat, negative)
- Relationship dynamics
- Voice development techniques
- Consistency guidelines
To efficiently find specific guidance, use Grep to search for relevant sections:
```bash
# Example: Find guidance on character arcs
grep -i "character arc" references/character_development.md
```
### Step 3: Develop Character Profile
Create or enhance character profiles with these essential elements:
**Basic Information**
- Name, age, role, physical appearance
- Key personality traits (both positive and negative)
**Background**
- Origin and formative experiences
- Ghost/wound that shapes their behavior
- Key relationships and family dynamics
**Character Arc**
- Starting belief or flaw
- Want vs. Need (external goal vs. internal growth)
- Transformation journey
- End state
**Relationships**
- Connections to other characters
- Dynamic types (ally, rival, mentor, etc.)
- How relationships evolve
**Unique Elements**
- Abilities, skills, or special knowledge
- Secrets or hidden aspects
- Voice/speech patterns
- Character-specific quirks
### Step 4: Ensure Consistency
Cross-reference with:
- Existing character profiles (avoid redundancy in roles/traits)
- Story planning documents (ensure alignment with plot needs)
- Summary/overview (match genre and tone)
### Step 5: Create or Update File
Write the character profile to `characters/[character-name].md` using markdown format. Match the existing style and structure found in other character files.
## Story Planning Workflow
### Step 1: Assess Current Planning State
Read existing planning documents to understand:
- Story concept and premise
- Established plot points or outline
- Target audience and genre
- Themes and central questions
- Planned structure (if any)
Look in folders like `story-planning/`, `outline/`, or files like `summary.md`.
### Step 2: Access Story Structure Reference
For detailed structural guidance, read `references/story_structures.md` which includes:
- Three-Act Structure
- Hero's Journey (Campbell's Monomyth)
- Save the Cat Beat Sheet
- Character arc templates
- Scene structure components
- Pacing guidelines by genre
- Subplot integration techniques
- Genre-specific structures
Use Grep to find specific frameworks:
```bash
# Example: Find Three-Act Structure details
grep -A 20 "Three-Act Structure" references/story_structures.md
```
### Step 3: Determine Structure Needs
Based on the user's request and story genre, recommend appropriate frameworks:
- **Thriller/Mystery**: Three-Act with strong midpoint reversal
- **Fantasy/Adventure**: Hero's Journey for quest narratives
- **YA/Contemporary**: Save the Cat for tight emotional beats
- **Literary Fiction**: Focus on character arc structure
- **Romance**: Genre-specific structure with relationship beats
### Step 4: Develop Planning Document
CreatThis skill should be used when the user requests brand analysis, brand guidelines creation, brand audits, or establishing brand identity and consistency standards. It provides comprehensive frameworks for analyzing brand elements and creating actionable brand guidelines based on requirements.
This skill should be used when analyzing business sales and revenue data from CSV files to identify weak areas, generate statistical insights, and provide strategic improvement recommendations. Use when the user requests a business performance report, asks to analyze sales data, wants to identify areas of weakness, or needs recommendations on business improvement strategies.
This skill should be used when the user requests to create professional business documents (proposals, business plans, or budgets) from templates. It provides PDF templates and a Python script for generating filled documents from user data.
This skill should be used when creating or configuring CI/CD pipeline files for automated testing, building, and deployment. Use this for generating GitHub Actions workflows, GitLab CI configs, CircleCI configs, or other CI/CD platform configurations. Ideal for setting up automated pipelines for Node.js/Next.js applications, including linting, testing, building, and deploying to platforms like Vercel, Netlify, or AWS.
This skill should be used when writing documentation for codebases, including README files, architecture documentation, code comments, and API documentation. Use this skill when users request help documenting their code, creating getting-started guides, explaining project structure, or making codebases more accessible to new developers. The skill provides templates, best practices, and structured approaches for creating clear, beginner-friendly documentation.
This skill should be used when working with CSV files to create interactive data visualizations, generate statistical plots, analyze data distributions, create dashboards, or perform automatic data profiling. It provides comprehensive tools for exploratory data analysis using Plotly for interactive visualizations.
This skill should be used when analyzing CSV datasets, handling missing values through intelligent imputation, and creating interactive dashboards to visualize data trends. Use this skill for tasks involving data quality assessment, automated missing value detection and filling, statistical analysis, and generating Plotly Dash dashboards for exploratory data analysis.
This skill should be used when containerizing applications with Docker, creating Dockerfiles, docker-compose configurations, or deploying containers to various platforms. Ideal for Next.js, React, Node.js applications requiring containerization for development, production, or CI/CD pipelines. Use this skill when users need Docker configurations, multi-stage builds, container orchestration, or deployment to Kubernetes, ECS, Cloud Run, etc.