project-continue

description	Resume development from current project state. Use when the user asks to continue work, pick up where we left off, find the next task, or resume a TDD cycle after a break.
args	[--task <id>] [--skip-status]
argument-hint	--task to resume specific task, --skip-status to skip state analysis
allowed-tools	Read, Bash(git status *), Bash(git log *), Bash(git branch *), Grep, Glob, Edit, Write
created	"2025-12-16T00:00:00.000Z"
modified	"2026-06-05T00:00:00.000Z"
reviewed	"2026-06-05T00:00:00.000Z"
name	project-continue

/project:continue

When to Use This Skill

Use this skill when...	Use project-discovery instead when...
Resuming work on a known project with PRDs and feature-tracker state	Entering an unfamiliar codebase needing orientation on tooling/structure
Picking the next task off the feature tracker after a break	Use project-test-loop instead when the next step is iterating on failing tests
Asking "what's next" in a project with established blueprint state	Use project-init instead when no project structure exists yet
Resuming a TDD session and beginning implementation yourself	Use /blueprint:execute instead when you want blueprint to pick and run the next logical blueprint action (derive/sync/work-order) rather than continue coding

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 docs/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 docs/blueprint/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.