project-workflow

What this skill does

# Project Workflow Skill

**Complete project lifecycle automation for Claude Code**

This skill provides 7 integrated slash commands that automate the entire project lifecycle from initial idea exploration through planning, execution, session management, and release safety checks.

## Overview

The project-workflow skill saves **35-55 minutes per project lifecycle** by automating repetitive tasks and enforcing best practices for context management, planning documentation, and safe releases.

### What This Skill Does

- **Pre-Planning Research** - Validate ideas, research tech stacks, manage scope
- **Automated Planning** - Generate comprehensive IMPLEMENTATION_PHASES.md with verification criteria
- **Feature Addition** - Integrate new features into existing project plans
- **Session Management** - Handle context across multiple Claude Code sessions
- **Release Safety** - Comprehensive checks before publishing to GitHub
- **Interactive Guidance** - Navigate the workflow system with contextual help

## Installation

### Via Marketplace (Recommended)

```bash
# Add the marketplace
/plugin marketplace add https://github.com/jezweb/claude-skills

# Install project-workflow skill
/plugin install project-workflow@claude-skills
```

All 7 slash commands will be automatically available in Claude Code.

### Manual Installation

```bash
# Clone the repository
git clone https://github.com/jezweb/claude-skills ~/claude-skills

# Copy commands to your Claude config
cp ~/claude-skills/skills/project-workflow/commands/*.md ~/.claude/commands/
```

## The 7 Commands

### 1. `/explore-idea` - Pre-Planning Exploration

**Purpose:** Collaborative exploration and validation BEFORE committing to implementation

**When to use:**
- You have a rough idea but haven't validated the approach
- Multiple tech options and unsure which fits best
- Want research/validation before detailed planning
- Need scope management to prevent feature creep

**What it does:**
1. Engages in free-flowing conversation to understand your vision
2. Conducts heavy research (Explore agents, WebSearch, MCP tools)
3. Validates tech stack and architectural decisions
4. Challenges assumptions and prevents scope creep
5. Creates PROJECT_BRIEF.md with validated decisions
6. Recommends: Proceed/Pause/Pivot
7. Seamlessly hands off to /plan-project if proceeding

**Time savings:** 10-15 minutes per project idea

**Example usage:**
```
User: /explore-idea
Claude: Let's explore your project idea! What are you thinking about building?
User: I want to build a chatbot with memory that runs on Cloudflare
Claude: [Conducts research on Cloudflare Durable Objects vs D1 for memory...]
Claude: [Validates approach, creates PROJECT_BRIEF.md]
Claude: Based on research, I recommend proceeding with Durable Objects for memory...
```

---

### 2. `/plan-project` - Generate Project Planning Docs

**Purpose:** Automate initial project planning for NEW projects

**When to use:**
- Starting a new project with clear requirements
- After /explore-idea when you've decided to proceed
- Need structured IMPLEMENTATION_PHASES.md for context-safe execution

**What it does:**
1. Checks for PROJECT_BRIEF.md (from /explore-idea) and uses it as context
2. Invokes project-planning skill to generate IMPLEMENTATION_PHASES.md
3. Creates SESSION.md for tracking progress
4. Creates initial git commit with planning docs
5. Shows formatted planning summary
6. Asks permission to start Phase 1
7. Optionally pushes to remote

**Time savings:** 5-7 minutes per new project

**Example usage:**
```
User: /plan-project
Claude: I found PROJECT_BRIEF.md from /explore-idea. Using it for context...
Claude: [Generates IMPLEMENTATION_PHASES.md with 8 phases]
Claude: [Creates SESSION.md]
Claude: [Git commit: "docs: Add project planning documentation"]
Claude: Ready to start Phase 1: Project Setup?
```

**Generated files:**
- `IMPLEMENTATION_PHASES.md` - Phased development plan with verification criteria
- `SESSION.md` - Session tracking and handoff protocol
- `DATABASE_SCHEMA.md` - If project uses a database
- `API_ENDPOINTS.md` - If project has an API
- `ARCHITECTURE.md` - System architecture overview

---

### 3. `/plan-feature` - Add Features to Existing Projects

**Purpose:** Add new features to existing projects by generating and integrating phases

**When to use:**
- Want to add a feature to an existing project
- Need to integrate new functionality into current plan
- Existing SESSION.md and IMPLEMENTATION_PHASES.md already exist

**What it does:**
1. Verifies prerequisites (SESSION.md + IMPLEMENTATION_PHASES.md exist)
2. Checks current phase status (warns if work in progress)
3. Gathers feature requirements (5 questions)
4. Generates new phases via project-planning skill
5. Integrates into IMPLEMENTATION_PHASES.md (handles phase renumbering)
6. Updates SESSION.md with new pending phases
7. Updates related docs (DATABASE_SCHEMA.md, API_ENDPOINTS.md if needed)
8. Creates git commit for feature planning
9. Shows formatted summary

**Time savings:** 7-10 minutes per feature addition

**Example usage:**
```
User: /plan-feature
Claude: Found existing planning docs. What feature do you want to add?
User: Add user authentication with Clerk
Claude: [Asks 5 clarifying questions about the feature]
Claude: [Generates 3 new phases for authentication]
Claude: [Integrates into existing IMPLEMENTATION_PHASES.md as Phases 9-11]
Claude: [Updates SESSION.md with new phases]
Claude: [Git commit: "docs: Add authentication feature phases"]
```

---

### 4. `/wrap-session` - End-of-Session Checkpoint

**Purpose:** Automate end-of-session workflow for safe handoffs

**When to use:**
- Context window getting full (>150k tokens)
- End of work session
- Before switching to different task
- Need to checkpoint progress

**What it does:**
1. Uses Task agent to analyze current session state
2. Updates SESSION.md with:
   - Completed tasks
   - Current phase progress
   - Next Action (what to do when resuming)
   - Blockers/issues encountered
3. Detects and updates relevant docs (CHANGELOG.md, ARCHITECTURE.md, etc.)
4. Creates structured git checkpoint commit
5. Outputs formatted handoff summary
6. Optionally pushes to remote

**Time savings:** 2-3 minutes per wrap-up

**Example usage:**
```
User: /wrap-session
Claude: [Analyzes session work via Task agent]
Claude: [Updates SESSION.md with progress]
Claude: [Git commit: "checkpoint: Complete Phase 3 - Database setup"]
Claude:
SESSION HANDOFF SUMMARY
=======================
Phase: 3/8 - Database Integration (100% complete)
Completed: D1 database setup, migrations, schema
Next Action: Start Phase 4 - API Endpoints (src/routes/api.ts)
Blockers: None
```

---

### 5. `/continue-session` - Start-of-Session Context Loading

**Purpose:** Automate start-of-session context loading for seamless resumption

**When to use:**
- Starting a new Claude Code session
- Continuing work from previous session
- After /wrap-session checkpoint

**What it does:**
1. Uses Explore agent to load session context (SESSION.md + planning docs)
2. Shows recent git history (last 5 commits)
3. Displays formatted session summary:
   - Current phase and progress
   - Last completed tasks
   - Next Action
   - Any blockers
4. Shows verification criteria if in "Verification" stage
5. Optionally opens "Next Action" file
6. Asks permission to continue or adjust direction

**Time savings:** 1-2 minutes per resume

**Example usage:**
```
User: /continue-session
Claude: [Loads SESSION.md via Explore agent]
Claude:
SESSION CONTEXT
===============
Phase: 4/8 - API Endpoints (20% complete)
Last Session: Completed /api/users GET endpoint
Next Action: Implement POST /api/users (src/routes/api.ts:45)
Blockers: None

Recent commits:
- checkpoint: Complete Phase 3 - Database setup
- feat: Add D1 migrations

Ready to implement POST /api/users?
```

---

### 6. `/workflow` - Interactive Workflow Guide

**Purpose:** Navigate the workflow system with contextual guidance

**When to use:**
- Fi