From studio-startup
Orchestrates journey from startup idea to working MVP via phases: product strategy, requirements, tech stack, architecture, implementation. Useful for new projects, MVPs, or apps from scratch.
How this skill is triggered — by the user, by Claude, or both
Slash command
/studio-startup:studio-startupThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
This skill orchestrates the complete journey from startup idea to working MVP by coordinating specialized marketplace plugins. It provides a structured workflow that ensures proper product strategy, requirements gathering, technical validation, architecture design, and implementation - preventing common startup pitfalls like building the wrong thing or making poor technical decisions.
This skill orchestrates the complete journey from startup idea to working MVP by coordinating specialized marketplace plugins. It provides a structured workflow that ensures proper product strategy, requirements gathering, technical validation, architecture design, and implementation - preventing common startup pitfalls like building the wrong thing or making poor technical decisions.
This skill should be used when the user asks to "start a project", "new startup", "side project idea", "create an app", "build an MVP", "help me launch", or describes wanting to build something new. It applies to web applications, mobile apps, APIs, and CLI tools.
Execute the following phases in sequence, clearly announcing each phase transition to the user. Use the TodoWrite tool at the start to create phase tracking todos.
Before beginning the main workflow:
Check for settings file at .claude/studio-startup.local.md
Determine starting phase
Create phase tracking
Announce: "Moving to Product Strategy phase - defining vision and market fit..."
Use the product strategy frameworks from references/product-strategy.md:
The product strategy phase will guide:
Output from this phase: Clear product strategy with defined goals, target users, and success metrics.
Mark phase complete and move to Requirements.
Announce: "Product strategy complete. Moving to Requirements phase - gathering detailed specifications..."
Invoke the ideation skill using the Skill tool:
Skill tool → "ideation"
The ideation skill will:
Output from this phase: Detailed requirements documents in docs/ideation/ directory.
Mark phase complete and move to Tech Selection.
Announce: "Requirements gathered. Moving to Tech Selection phase - analyzing optimal stack..."
Invoke the tech-stack-advisor agent (defined in this plugin) using the Task tool:
Task tool → subagent_type: "tech-stack-advisor"
Prompt: "Based on the requirements in docs/ideation/, recommend 2-3 optimal tech stacks. Consider: [requirements summary], team experience: [from settings], scalability needs: [from strategy]"
The agent will:
User interaction: Present options and let user choose or request alternatives.
Output from this phase: Selected tech stack with rationale.
Mark phase complete and move to Technical Validation.
Announce: "Tech stack selected. Moving to Technical Validation phase - ensuring solid architecture principles..."
Use the CTO frameworks from references/cto-frameworks.md to validate:
The technical validation phase will:
Output from this phase: Technical validation report with architecture guidance.
Mark phase complete and move to System Design.
Announce: "Technical decisions validated. Moving to System Design phase - creating detailed architecture..."
Invoke the senior-architect skill using the Skill tool:
Skill tool → "architecture:senior-architect"
Prompt: "Create detailed system design for this [project type] using [selected stack]. Requirements in docs/ideation/, CTO guidance available. Include component architecture, data flow, and key design patterns."
The senior-architect will:
Output from this phase: Architecture documentation in docs/architecture.md or similar.
Mark phase complete and prepare for Implementation.
Before implementation, gather final details:
Ask user for output path:
default_pathConfirm project name:
Create project directory:
mkdir -p /chosen/path/project-name
cd /chosen/path/project-name
Initialize git if configured:
# If settings.output_preferences.git_init is true
git init
Announce: "System design complete. Moving to Implementation phase - generating MVP code..."
Implementation strategy depends on project type:
Invoke both frontend-design and code-assistant skills:
Skill tool → "frontend-design"
Prompt: "Design and implement the UI for this [app type]. Requirements in docs/ideation/, architecture in docs/architecture.md. Use [selected stack]. Focus on core MVP features."
Skill tool → "developer-tools:code-assistant"
Prompt: "Implement the complete web application based on frontend design and architecture. Include authentication, API routes, database setup, and core features from requirements."
Invoke code-assistant:
Skill tool → "developer-tools:code-assistant"
Prompt: "Implement mobile app using [selected stack]. Requirements in docs/ideation/, architecture in docs/architecture.md. Include navigation, screens, state management, and API integration for core features."
Invoke code-assistant:
Skill tool → "developer-tools:code-assistant"
Prompt: "Implement API service using [selected stack]. Requirements in docs/ideation/, architecture in docs/architecture.md. Include endpoints, data models, authentication, and database integration."
Invoke code-assistant:
Skill tool → "developer-tools:code-assistant"
Prompt: "Implement CLI tool using [selected stack]. Requirements in docs/ideation/, architecture in docs/architecture.md. Include command structure, argument parsing, and core functionality."
Mark phase complete and move to Finalization.
Announce: "Implementation complete. Finalizing project artifacts..."
Generate project documentation:
README.md:
Create project manifest (.studio-startup.json):
{
"plugin_version": "0.1.0",
"created_at": "[timestamp]",
"project_type": "[web|mobile|api|cli]",
"tech_stack": {
"frontend": "[if applicable]",
"backend": "[stack]",
"database": "[if applicable]",
"deployment": "[platforms]"
},
"phases_completed": [
"strategy", "requirements", "tech-selection",
"validation", "design", "implementation"
],
"documentation": {
"product_specs": "docs/ideation/",
"architecture": "docs/architecture.md",
"readme": "README.md"
}
}
Organize documentation:
docs/ directory structure if neededInitial git commit (if git_init enabled):
git add .
git commit -m "feat: initial project setup from studio-startup plugin
Complete MVP implementation with:
- Product strategy and requirements
- [Selected tech stack]
- Core features: [list key features]
Generated by studio-startup plugin v0.1.0"
Mark all phase todos complete
Present final summary to user:
✅ Project successfully created at: [path]
📋 What was created:
- Complete [project type] MVP using [stack]
- Product specifications in docs/ideation/
- Architecture documentation in docs/architecture.md
- Comprehensive README with setup instructions
- [X features] implemented and ready to use
🚀 Next steps:
1. Review README.md for setup instructions
2. Install dependencies: [command]
3. Configure environment: Copy .env.example to .env
4. Run development server: [command]
5. Deploy to [recommended platforms]
💡 To iterate: Use the generated documentation as foundation
and continue development with code-assistant or specialized agents.
Throughout the workflow, reference user settings from .claude/studio-startup.local.md:
If settings file exists, extract preferences:
# Check if settings exist
test -f .claude/studio-startup.local.md
Key settings to use:
favorite_stacks.[project_type] - Prioritize these in tech recommendationsteam_context.experience_level - Influences stack complexity recommendationsteam_context.team_size - Affects architecture decisions (monolith vs microservices)default_patterns.* - Apply these patterns in implementationoutput_preferences.default_path - Default project locationdeployment_preferences.* - Use in hosting recommendationsIn Tech Selection phase:
In Implementation phase:
default_patterns.testing: truedefault_patterns.docker: truedefault_patterns.eslint: trueIn Finalization phase:
output_preferences.git_init: truereadme_template level (minimal vs detailed)output_preferences.include_license: trueThis skill can be triggered two ways:
User phrases like "help me start a SaaS project" trigger this skill automatically.
Behavior: Full interactive workflow with questions and guidance.
User runs /studio-startup:new command (see commands/new.md).
Behavior: Command may pass arguments (project type, name, starting phase) that skip some interactive questions. The skill still executes the same workflow phases.
Coordination: When command invokes this skill, it will pass context about any arguments provided. Use this context to skip redundant questions.
Use TodoWrite throughout:
This gives users clear visibility into workflow progress.
If required plugins are unavailable:
Example:
Required plugin 'architecture' not found.
Install with: cc plugin install architecture
Would you like to continue without architecture design phase?
(Warning: This may result in less optimal system design)
If a phase fails (skill throws error, user cancels, etc.):
.studio-startup-state.jsonIf user interrupts workflow (changes topic, asks different question):
If user says "I already have requirements" or "I already did product strategy":
If user wants to change tech stack after selection:
Adjust phase depth based on project scope:
Small projects (single developer, simple app):
Large projects (team, complex requirements):
Detection: Ask during Phase 0: "Is this a simple side project or a more complex startup?" Use response to calibrate phase depth.
Use Skill tool for skill invocation:
# Correct
Skill(skill="product-strategist")
Skill(skill="ideation")
Skill(skill="architecture:senior-architect")
# Note: Skills from other plugins require plugin prefix
# This plugin's skills don't need prefix
Use Task tool for agent invocation:
# For agents in this plugin
Task(subagent_type="tech-stack-advisor", prompt="...", description="...")
# For agents in other plugins (use full identifier)
Task(subagent_type="developer-tools/code-assistant", prompt="...", description="...")
Before invoking external plugins:
.claude/studio-startup.local.md should be loaded once at start, not re-read at every phaseFor detailed orchestration patterns and advanced coordination strategies, see:
references/orchestration-guide.md - Deep dive on skill coordination patternsreferences/tech-stack-catalog.md - Common stacks with detailed pros/consreferences/project-types.md - Type-specific guidance and patternsreferences/cto-frameworks.md - DORA metrics, team ratios, ADR templatesreferences/product-strategy.md - OKRs, RICE prioritization, product visionnpx claudepluginhub kriscard/kriscard-claude-plugins --plugin studio-startupGuides a new idea from vague concept to working MVP through scoping, stack choice, architecture, implementation, and deployment in a structured workflow.
Guides non-technical users from a raw idea to a launched project with an interactive kickoff, autonomous build loop, and built-in security/privacy validation.
Creates production-grade PRD for greenfield projects via discovery interview, battle-tested architecture defaults, adversarial analysis, and sprint-ready specs output.