---

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:

1. What's your project name? (kebab-case preferred)
2. What's your tech stack? (Frontend, backend, database)
3. Where will this deploy? (Localhost, VPS, cloud platform)
4. 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.

1. 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})

2. 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.

.docs/project-foundation-complete.md

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:

CopySet 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:

CopySet 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:

CopyImplement 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:

CopyCreate 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:

CopySet 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:

CopyReview 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:

CopyHelp 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:

1. Re-run deployment-advisor to choose a hosting target
2. 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

Copy# 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:}

1. Open claude.md and read "Next Steps (Guided Setup)"
2. Copy the first prompt and paste it to Claude Code
3. Follow the guided steps incrementally
4. Ask questions as you go

{If Quick Start:}

1. Review generated code structure
2. Copy .env.example to .env.local and configure
3. 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.