| name | project-spinup |
| description | Generate complete project foundations with personalized claude.md, Docker setup, and project structure. Supports Guided Setup or Quick Start. |
project-spinup
Ready to generate your project foundation?"
Then proceed with the skill's main workflow.
To generate your project foundation, I need to understand:
- What's your project name? (kebab-case preferred)
- What's your tech stack? (Frontend, backend, database)
- Where will this deploy? (Localhost, VPS, cloud platform)
- Learning or delivery focus? (Affects scaffolding approach)
Once you share these, I can generate your project foundation."
Gather answers conversationally, then proceed with the skill's main workflow.
Guided Setup - I'll create the foundation, then provide step-by-step prompts to build out the structure incrementally. You'll learn how each layer works. (Recommended if you're new to {tech stack})
Quick Start - I'll generate the complete project scaffolding immediately with all boilerplate code and configuration. (Recommended if you're familiar with {tech stack})
Which approach would you like?
Key insight: You can be in LEARNING mode but use Quick Start if familiar with the stack. Or DELIVERY mode but use Guided Setup for a new framework.
User incrementally asks Claude Code to build out the project.
Project: {project_name} Created: {date} Tech Stack: {tech_stack_summary} Deployment Target: {hosting_approach} Spinup Approach: {guided/quick-start}
What Was Created
- claude.md (project context)
- docker-compose.yml (local development)
- Directory structure
- Configuration files
- README.md
Workflow Status
This marks the completion of the PLANNING and SETUP phases.
[If Localhost:] WORKFLOW TERMINATION POINT Your localhost project is ready for development. No further workflow phases needed.
[If Public Deployment:] Next Phases Available:
- Phase 4: test-orchestrator (optional, when ready for testing infrastructure)
- Phase 5: deploy-guide (when ready to deploy)
- Phase 6: ci-cd-implement (optional, for automation)
{PROJECT_DESCRIPTION}
Status: Active Development | Developer: John | Philosophy: Learning-Focused, Best Practices
Developer Profile
{Experience level, learning goals, development approach, common tasks for Claude Code}
Project Overview
{What project does, tech stack breakdown, architecture decisions}
Development Environment
{Computers/sync, local setup, prerequisites, first-time setup commands}
Infrastructure & Hosting
{Self-hosted infrastructure available, project-specific hosting, access/credentials}
Development Workflow
{Git branching strategy, commit convention, development cycle, testing strategy}
Code Conventions
{File organization, naming conventions, code style/linting}
Common Commands
{Development, database, Docker commands}
Project-Specific Notes
{Authentication, database schema, API endpoints, environment variables}
Deployment
{Deployment workflow, checklist, rollback procedure}
Resources & References
{Project docs, external resources, learning resources}
Troubleshooting
{Common issues and solutions}
Next Steps
{If Guided Setup: detailed step-by-step prompts} {If Quick Start: immediate next actions}
You now have the project foundation. Complete the setup by asking Claude Code to build out the structure step-by-step.
Learning Philosophy
Each step teaches about a specific part of the stack. Take your time, review what gets created, ask questions about why things are structured this way.
Estimated total time: {X hours}
Step 1: Initialize {Framework} Structure
Time: ~{X} minutes | Learning: Project structure and configuration
What you'll learn: How {framework} projects are organized, what each config file does.
Say to Claude Code:
Set up the {Framework} structure with {specifics} as specified in claude.md. Please explain the purpose of each major file and directory.
What will be created: {list}
Verification: {command}
Step 2: Configure Database Connection
Time: ~{X} minutes | Learning: Database configuration and connection patterns
Say to Claude Code:
Set up the database client configuration for {database} with environment variables as specified in claude.md.
Step 3: Implement Authentication Scaffolding
Time: ~{X} minutes | Learning: Authentication patterns, security
Say to Claude Code:
Implement authentication using {auth approach} as specified in claude.md. Include registration, login, logout, and protected route examples.
Step 4: Create Example CRUD Feature
Time: ~{X} minutes | Learning: Full-stack data flow, API design
Say to Claude Code:
Create a simple CRUD feature for {example entity} that demonstrates best practices. Include frontend form, API endpoints, database operations, and basic tests.
Step 5: Add Testing Suite
Time: ~{X} minutes | Learning: Testing strategies
Say to Claude Code:
Set up the testing framework and write example tests for the CRUD feature. Include unit and integration tests.
Step 6: Configure Docker Development Environment
Time: ~{X} minutes | Learning: Docker containerization
Say to Claude Code:
Review and enhance the docker-compose.yml. Explain how to use Docker for local development.
Step 7: Document and Prepare for First Feature
Time: ~{X} minutes | Learning: Documentation practices
Say to Claude Code:
Help me document the project structure, update the README, and create a template for building new features.
You're Ready to Build!
After completing these steps, you'll have:
- Complete {framework} project structure
- Database connected and configured
- Authentication working
- Example CRUD feature as template
- Testing framework ready
- Docker environment running
- Clear development workflow
Files to generate (Quick Start):
- package.json, tsconfig.json, next.config.js
- tailwind.config.ts, postcss.config.js
- app/layout.tsx, app/page.tsx, app/api/
- lib/supabase/client.ts, lib/supabase/server.ts
- components/, middleware.ts
- .eslintrc.json, .prettierrc
- jest.config.js or vitest.config.ts
- tests/, docker-compose.yml
Files to generate (Quick Start):
- composer.json, index.php
- src/Controllers/, src/Models/, src/Views/
- src/Router.php, src/Database.php
- config/database.php, config/config.php
- public/index.php, public/css/, public/js/
- tests/, docker-compose.yml (PHP, MySQL, phpMyAdmin)
Files to generate (Quick Start):
- requirements.txt, pyproject.toml, main.py
- app/init.py, app/models/, app/routers/
- app/schemas/, app/database.py, app/config.py
- tests/, alembic/
- docker-compose.yml
Project: {project_name} Tech Stack: {primary technologies} Spinup Approach: {Guided Setup or Quick Start} Deployment Target: {localhost / hosting approach}
Workflow Status
PLANNING PHASES - COMPLETE
- Phase 0: project-brief-writer
- Phase 1: tech-stack-advisor
- Phase 2: deployment-advisor
SETUP PHASE - COMPLETE
- Phase 3: project-spinup (this skill)
[If Localhost:] WORKFLOW TERMINATION POINT
Your localhost project is ready for development. No further workflow phases needed.
If you later decide to deploy publicly:
- Re-run deployment-advisor to choose a hosting target
- Continue with deploy-guide and optionally ci-cd-implement
[If Public Deployment:] DEVELOPMENT PHASE - START
Build your features! When you're ready:
- Phase 4: test-orchestrator (optional - set up testing infrastructure)
- Phase 5: deploy-guide (deploy your application)
- Phase 6: ci-cd-implement (optional - automate deployments)
Generated Files
- claude.md - Comprehensive project context
- docker-compose.yml - Local development environment
- Directory structure (src/, tests/, docs/)
- .env.example, .gitignore, README.md
- .docs/project-foundation-complete.md - Handoff marker {If Quick Start: - Complete project scaffolding with starter code}
Quick Start Commands
# Initialize git
cd {project_name}
git init
git checkout -b main
git add .
git commit -m "chore: initial project setup via project-spinup skill"
git checkout -b dev
# Start development
docker compose up -d # or native commands
{dev server command}
Open http://localhost:{port} to see your application.
Next Actions
{If Guided Setup:}
- Open claude.md and read "Next Steps (Guided Setup)"
- Copy the first prompt and paste it to Claude Code
- Follow the guided steps incrementally
- Ask questions as you go
{If Quick Start:}
- Review generated code structure
- Copy .env.example to .env.local and configure
- Start building features!
Happy coding!
Status: Phase 0: Project Brief (project-brief-writer) Phase 1: Tech Stack (tech-stack-advisor) Phase 2: Deployment Strategy (deployment-advisor) Phase 3: Project Foundation (you are here) <- TERMINATION POINT (localhost) Phase 4: Test Strategy (test-orchestrator) - optional Phase 5: Deployment (deploy-guide) <- TERMINATION POINT (manual deploy) Phase 6: CI/CD (ci-cd-implement) <- TERMINATION POINT (full automation)
This is a TERMINATION POINT for localhost/learning projects.
Mention this option when users seem uncertain about their progress.