project-continue

Continue project development by analyzing current state and resuming work.

Note: Configure project-specific test/build commands in CLAUDE.md or .claude/rules/ for automatic detection.

Steps:

1. Check current state:

   # Check git status
   git status
   
   # Check recent commits
   git log -5 --oneline
   
   # Check current branch
   git branch --show-current
   

2. Read project context:

   • PRDs: Read all files in .claude/blueprints/prds/
     • Understand project goals and requirements
     • Identify features and phases
   • Feature Tracker: Read docs/blueprint/feature-tracker.json tasks section
     • Current phase and progress
     • Completed, in-progress, and pending tasks
   • Work Orders: Check .claude/blueprints/work-orders/
     • Recent work-orders (see what's been done)
     • Pending work-orders (see what's planned)

3. Analyze state and determine next task:

   If uncommitted changes exist:

   • Review uncommitted files
   • Determine if work-in-progress should be continued
   • Ask user if they want to continue current work or start fresh

   If on clean state:

   • Compare feature tracker tasks against PRD requirements
   • Identify next logical task:
     • Next pending task in feature-tracker.json
     • Next requirement in PRD
     • Next work-order to execute
   • Consider dependencies (start with unblocked tasks first)

4. Report status before starting:

   📊 Project Status:
   
   Current Branch: [branch]
   Uncommitted Changes: [yes/no - list files if yes]
   
   Recent Work:
   - [Last 3 commits]
   
   PRDs Found:
   - [List PRD files with brief summary]
   
   Work Overview: Phase [N] - [Phase name]
   ✅ Completed: [N] tasks
   ⏳ In Progress: [Current task if any]
   ⏹️ Pending: [N] tasks
   
   Next Task: [Identified next task]
   Approach: [Brief plan]
   

5. Begin work following TDD:

   • Activate project-specific skills automatically:
     • Architecture patterns
     • Testing strategies
     • Implementation guides
     • Quality standards
   • Follow RED → GREEN → REFACTOR workflow:
     • Write failing test first
     • Minimal implementation to pass
     • Refactor while keeping tests green
   • Commit incrementally:
     • Use conventional commits
     • Commit after each RED → GREEN → REFACTOR cycle
     • Reference PRD or issue in commit message

6. Update feature tracker as you go:

   • Mark tasks in-progress
   • Mark tasks completed
   • Update next steps

Important:

• Always start with tests (TDD requirement)
• Apply project skills (architecture, testing, implementation, quality)
• Commit incrementally (after each successful cycle)
• Update feature tracker (keep project state current)

Handling Common Scenarios:

Scenario: Starting new feature:

1. Create work-order first with /blueprint-work-order
2. Then continue with this command

Scenario: Blocked by dependency:

1. Report the blocker
2. Suggest working on a different task
3. Or: Suggest implementing the dependency first

Scenario: Tests failing:

1. Analyze failures
2. Fix failing tests (always complete RED step first)
3. Continue once tests pass

Scenario: Unclear what to do next:

1. Review PRDs for requirements
2. Ask user for clarification
3. Suggest creating work-orders for clarity

Agent Teams (Optional)

For large codebases with multiple work fronts, spawn teammates for parallel progress:

Teammate	Focus	Value
Research teammate	Investigate codebase state, PRDs, work-orders	Parallel context gathering
Implementation teammate	Begin work on next task from feature tracker	Start implementation immediately

The research teammate gathers project state while the implementation teammate begins the most obvious next task. This is optional — single-session continuation works for most projects.