pm-skill-creator
Design a new PM skill through guided conversation. Use when you have raw content or an idea and want to shape it into a compliant skill.
What this skill does
## Purpose
Walk through the full skill design process interactively — from raw idea or content to a structured, repo-compliant SKILL.md draft. Asks adaptive questions to determine skill type, scope, structure, and content, then generates a ready-to-validate draft.
This skill is the conversational complement to `skill-authoring-workflow`. That skill defines the process and validation gates. This one sits with you and figures out what to build before you build it.
## Key Concepts
### When to Use This vs. Other Authoring Tools
| Tool | Best When |
|------|-----------|
| **This skill (skill-creator)** | You have an idea or raw content and need help shaping it into the right structure through conversation |
| `skill-authoring-workflow` | You already know what to build and need the process checklist and validation steps |
| `scripts/build-a-skill.sh` | You know the structure and want a terminal wizard to collect sections |
| `scripts/add-a-skill.sh` | You have a source document and want AI-assisted generation end-to-end |
### The Three Skill Types (Decision Criteria)
- **Component**: One artifact or template. Self-contained. Gets referenced by other skills. Ask: "Is this a thing someone creates?"
- **Interactive**: Guided conversation with adaptive questions and enumerated recommendations. Ask: "Does this require back-and-forth to be useful?"
- **Workflow**: Multi-phase orchestration referencing other skills. Ask: "Does this coordinate multiple activities across steps?"
### Skill Anatomy (Non-Negotiable Sections)
Every skill requires these sections in order:
1. **Purpose** — What it does + when to use it (outcome-focused)
2. **Key Concepts** — Frameworks, definitions, mental models
3. **Application** — Step-by-step instructions an agent can follow
4. **Examples** — At least one concrete, specific example
5. **Common Pitfalls** — Named failure modes with consequences and fixes
6. **References** — Related skills, external frameworks, source material
### Metadata Constraints
- `name`: lowercase kebab-case, ≤ 64 characters
- `description`: ≤ 200 characters, must include trigger cue ("Use when...")
- `intent`: longer repo-facing summary (no character limit)
- `type`: one of `component`, `interactive`, `workflow`
### Facilitation Source of Truth
Use [`workshop-facilitation`](../workshop-facilitation/SKILL.md) as the default interaction protocol for this skill.
It defines:
- Session heads-up + entry mode (Guided, Context dump, Best guess)
- One-question turns with plain-language prompts
- Progress labels (e.g., Context Q1/5)
- Interruption handling and pause/resume behavior
- Numbered recommendations at decision points
- Quick-select numbered response options (include `Other (specify)` when useful)
This file defines the domain-specific content. If there is a conflict, follow this file's domain logic.
## Application
This interactive skill asks **up to 5 adaptive questions**, then delivers a **complete SKILL.md draft** with frontmatter, all required sections, and repo-compliant structure.
---
### Step 0: Session Start
**Agent says:**
"I'll help you design a new PM skill from scratch. This takes about 10-15 minutes and up to 5 questions. How do you want to start?
1. **Guided** — I'll ask questions one at a time and build the skill from your answers (recommended)
2. **Context dump** — Paste your raw content, notes, or framework and I'll propose a skill structure
3. **Best guess** — Tell me just the topic and I'll draft a skill you can refine"
---
### Question 1: What's the Raw Material? (Q1/5)
**Agent asks:**
"What are we turning into a skill? Give me whatever you have."
1. **A framework or mental model** — A structured way of thinking about a PM problem (e.g., prioritization matrix, decision tree)
2. **A template or artifact** — A deliverable PMs create (e.g., PRD section, positioning statement, epic format)
3. **A process or workflow** — A multi-step method for completing a PM task (e.g., discovery sprint, roadmap planning)
4. **A coaching or advisory topic** — A domain where PMs need guided, adaptive help (e.g., stakeholder navigation, pricing decisions)
**Or describe what you have in your own words.**
**Agent note:** If the user pastes raw content instead of choosing an option, analyze the content and infer the answer. Confirm your interpretation before proceeding.
---
### Question 2: Skill Type Decision (Q2/5)
**Based on Q1 answer, agent recommends a type and confirms:**
*If Q1 = Framework or Template:*
"This sounds like a **component skill** — a self-contained artifact or reference. It would include a template, quality criteria, and examples. Does that fit, or is there a conversational/adaptive element I'm missing?
1. **Yes, component** — It's a standalone deliverable or reference
2. **Actually, it needs conversation** — Users need guided questions to use it well (→ interactive)
3. **It's bigger than one artifact** — It orchestrates multiple steps or other skills (→ workflow)"
*If Q1 = Process or Workflow:*
"This sounds like a **workflow skill** — a multi-phase process. Does it reference or orchestrate other discrete skills/artifacts, or is it more of a guided conversation?
1. **Yes, workflow** — It has distinct phases and may reference other skills
2. **It's more conversational** — The value comes from adaptive questions and recommendations (→ interactive)
3. **It's simpler than I described** — Really it's one artifact with steps (→ component)"
*If Q1 = Coaching or Advisory:*
"This sounds like an **interactive skill** — guided questions that adapt based on answers, ending with enumerated recommendations. Sound right?
1. **Yes, interactive** — It needs back-and-forth to be useful
2. **It's more of a reference** — Users just need the framework, not a conversation (→ component)
3. **It's a full process** — Multiple phases, orchestrates other skills (→ workflow)"
---
### Question 3: Scope and Naming (Q3/5)
**Agent asks:**
"What should we call this skill? I need two things:
**a) A working name** — lowercase-kebab-case, max 64 characters (e.g., `feature-investment-advisor`, `user-story`, `discovery-process`)
**b) A one-sentence description** — What it does + when to use it. Must fit in 200 characters and start with a verb or 'Use when...'
Give me your best attempt and I'll tighten it if needed. Or just describe the skill's purpose and I'll propose both."
**Agent note:** Validate the name format (kebab-case, ≤ 64 chars) and description length (≤ 200 chars) before proceeding. If either fails, suggest a fix.
---
### Question 4: Key Content (Q4/5)
**This question adapts based on skill type from Q2:**
*For component skills:*
"What are the core elements of this artifact or framework? I need:
1. **The template or structure** — What sections/fields does it contain?
2. **Quality criteria** — What separates a good one from a bad one?
3. **One concrete example** — A filled-in version showing it done well
Give me whatever you have — bullet points, rough notes, or a full draft."
*For interactive skills:*
"Walk me through the conversation flow:
1. **What's the opening question?** — What does the user need to tell you first?
2. **What are the 2-4 branching paths?** — How do answers change what comes next?
3. **What recommendations emerge?** — What are the 3-5 outcomes you'd offer?
Give me the decision tree as you see it — even if it's rough."
*For workflow skills:*
"Map out the phases:
1. **What are the major steps?** (Usually 3-6 phases)
2. **What's the input and output of each phase?**
3. **Which existing skills does this reference?** (Check with `scripts/find-a-skill.sh --keyword <topic>`)
4. **Where are the decision points?**
Give me the flow — sequential, branching, or both."
---
### Question 5: Pitfalls and Edge Cases (Q5/5)
**Agent asks:**
"What goes wrong when people do this badly? I need 2-3 failure modes:
1. **Name the failure** — Give it a label (e.g., 'Metrics Theater', 'Hero Syndrome')
2. **Describe Related in Design
contribute
IncludedLocal-only OSS contribution command center. Auto-refreshes the user's in-flight PR and issue state on invoke so conversations start with full context — no need to brief Claude on what's in flight. Helps the user find issues to contribute to on GitHub, builds per-repo dossiers of what each upstream expects (CLA, DCO, branch convention, AI policy, draft-first, review bots, issue templates), runs deterministic gates before any external action so AI-assisted contributions don't reach maintainers as slop. State is markdown-only: candidate files at ~/.contribute-system/candidates/, repo dossiers at ~/.contribute-system/research/, append-only event log at ~/.contribute-system/log.jsonl. No database, no cloud calls. Use when the user asks about their PRs / issues / contributions, wants to find new work to take on, claim an issue, build/refresh a repo's dossier, or draft a Design Issue or PR. Trigger with "/contribute", "what's my PR status", "find a contribution", "claim issue X", "draft a Design Issue for Y", "refresh dossier for Z".
architectural-analysis
IncludedUser-triggered deep architectural analysis of a codebase or scoped subtree across eight modes — information architecture, data flow, integration points, UI surfaces, interaction patterns, data model, control flow, and failure modes. This skill should be used when the user asks to "diagram this codebase," "map the architecture," "show the data flow," "give me an ERD," "trace control flow," "find the integration points," "verify the layout pattern," "audit the UX architecture," or any similar request whose primary deliverable is mermaid diagrams plus cited reports under docs/architecture/. Dispatches haiku/sonnet sub-agents in parallel for per-mode exploration, then verifies every citation mechanically before any node lands in a diagram. Not for one-off prose explanations of code (use code-explanation) or for high-level system design from scratch (use system-design).
mcp
IncludedModel Context Protocol (MCP) server development and tool management. Languages: Python, TypeScript. Capabilities: build MCP servers, integrate external APIs, discover/execute MCP tools, manage multi-server configs, design agent-centric tools. Actions: create, build, integrate, discover, execute, configure MCP servers/tools. Keywords: MCP, Model Context Protocol, MCP server, MCP tool, stdio transport, SSE transport, tool discovery, resource provider, prompt template, external API integration, Gemini CLI MCP, Claude MCP, agent tools, tool execution, server config. Use when: building MCP servers, integrating external APIs as MCP tools, discovering available MCP tools, executing MCP capabilities, configuring multi-server setups, designing tools for AI agents.
react-native-skia
IncludedDesign, build, debug, and optimise high-polish animated graphics in React Native or Expo using @shopify/react-native-skia, Reanimated, and Gesture Handler. Use when the user wants canvas-driven UI, shaders, paths, rich text, image filters, sprite fields, Skottie, video frames, snapshots, web CanvasKit setup, or performance tuning for custom motion-heavy elements such as loaders, hero art, cards, charts, progress indicators, particle systems, or gesture-driven surfaces. Also use when the user asks for fluid, glow, glass, blob, parallax, 60fps/120fps, or GPU-friendly animated effects in React Native, even if they do not explicitly say "Skia". Do not use for ordinary form/layout work with standard views.
plaid
IncludedProduct Led AI Development — guides founders from idea to launched product. Six capabilities: Idea (discover a product idea), Validate (pressure-test the idea against fatal flaws, problem reality, competition, and 2-week MVP feasibility), Plan (vision intake + document generation), Design (translate image references into a design.md spec), Launch (go-to-market strategy), and Build (roadmap execution). Use when someone says "PLAID", "plaid idea", "help me find an idea", "product idea", "idea from my business", "idea from my expertise", "plaid validate", "validate my idea", "pressure-test", "is this idea good", "find fatal flaws", "validate the problem", "plan a product", "define my vision", "generate a PRD", "product strategy", "plaid design", "design from image", "translate image to design", "create design.md", "extract design tokens", "plaid launch", "go-to-market", "launch plan", "GTM strategy", "launch playbook", "plaid build", "build the app", "start building", or "execute the roadmap".
nextjs-framer-motion-animations
IncludedAdds production-safe Motion for React or Framer Motion animations to Next.js apps, including reveal, hover and tap micro-interactions, whileInView, stagger, AnimatePresence, layout and layoutId transitions, reorder, scroll-linked UI, and lightweight route-content transitions. Use when the user asks to add, refactor, or debug Motion or Framer Motion in App Router or Pages Router codebases, especially around server/client boundaries, reduced motion, LazyMotion, bundle size, hydration, or route transitions. Avoid for GSAP-style timelines, WebGL or 3D scenes, heavy scroll storytelling, or CSS-only effects unless Motion is explicitly requested.