Work

---
name: work
description: Execute work plans efficiently while maintaining quality and finishing features
argument-hint: "[plan file, specification, Notion page URL, or todo ID]"
---

# Work Plan Execution Command

Execute a work plan efficiently while maintaining quality and finishing features.

## Introduction

This command takes a work document (plan, specification, Notion page, or todo ID) and executes it systematically. The focus is on **shipping complete features** by understanding requirements quickly, following existing patterns, and maintaining quality throughout.

## Input Document

<input_document> #$ARGUMENTS </input_document>

## Execution Workflow

### Phase 1: Quick Start

1. **Read Plan and Clarify**

   **If Notion URL or Todo ID provided:**
   - Fetch the Notion page using `mcp__notion__notion-fetch`
   - Parse the Problem Statement, Proposed Solutions, and Acceptance Criteria
   - Review Technical Details and Resources

   **If file path provided:**
   - Read the work document completely
   - Review any references or links provided in the plan

   - If anything is unclear or ambiguous, ask clarifying questions now
   - Get user approval to proceed
   - **Do not skip this** - better to ask questions now than build the wrong thing

2. **Setup Environment**

   Choose your work style:

   **Option A: Live work on current branch**
   ```bash
   git checkout main && git pull origin main
   git checkout -b feature-branch-name

Option B: Parallel work with worktree (recommended for parallel development)

# Ask user first: "Work in parallel with worktree or on current branch?"
# If worktree:
skill: git-worktree
# The skill will create a new branch from main in an isolated worktree

Recommendation: Use worktree if:

• You want to work on multiple features simultaneously
• You want to keep main clean while experimenting
• You plan to switch between branches frequently

Use live branch if:

• You're working on a single feature
• You prefer staying in the main repository

3. Create Todo List
   • Use TodoWrite to break plan into actionable tasks
   • Include dependencies between tasks
   • Prioritize based on what needs to be done first
   • Include testing and quality check tasks
   • Keep tasks specific and completable

Phase 2: Execute

1. Task Execution Loop

   For each task in priority order:

   while (tasks remain):
     - Mark task as in_progress in TodoWrite
     - Read any referenced files from the plan
     - Look for similar patterns in codebase
     - Implement following existing conventions
     - Write tests for new functionality
     - Run tests after changes
     - Mark task as completed
   

2. Follow Existing Patterns

   • The plan should reference similar code - read those files first
   • Match naming conventions exactly
   • Reuse existing components where possible
   • Follow project coding standards (see CLAUDE.md)
   • When in doubt, grep for similar implementations

3. Test Continuously

   • Run relevant tests after each significant change
   • Don't wait until the end to test
   • Fix failures immediately
   • Add new tests for new functionality

4. Figma Design Sync (if applicable)

   For UI work with Figma designs:

   • Implement components following design specs
   • Use figma-design-sync agent iteratively to compare
   • Fix visual differences identified
   • Repeat until implementation matches design

5. Track Progress

   • Keep TodoWrite updated as you complete tasks
   • Note any blockers or unexpected discoveries
   • Create new tasks if scope expands
   • Keep user informed of major milestones

Phase 3: Quality Check

1. Run Core Quality Checks

   Always run before submitting:

   # Run TypeScript checks
   npm run build
   
   # Run linting
   npm run lint
   

2. Consider Reviewer Agents (Optional)

   Use for complex, risky, or large changes:

   • code-simplicity-reviewer: Check for unnecessary complexity
   • kieran-typescript-reviewer: Verify TypeScript/React conventions
   • performance-oracle: Check for performance issues
   • security-sentinel: Scan for security vulnerabilities

   Run reviewers in parallel with Task tool:

   Task(code-simplicity-reviewer): "Review changes for simplicity"
   Task(kieran-typescript-reviewer): "Check TypeScript conventions"
   

   Present findings to user and address critical issues.

3. Final Validation

   • All TodoWrite tasks marked completed
   • All tests pass
   • Linting passes
   • Code follows existing patterns
   • Figma designs match (if applicable)
   • No console errors or warnings

Phase 4: Ship It

1. Create Commit

   git add .
   git status  # Review what's being committed
   git diff --staged  # Check the changes
   
   # Commit with conventional format
   git commit -m "$(cat <<'EOF'
   feat(scope): description of what and why
   
   Brief explanation if needed.
   
   🤖 Generated with [Claude Code](https://claude.com/claude-code)
   
   Co-Authored-By: Claude <noreply@anthropic.com>
   EOF
   )"
   

2. Capture Screenshots for UI Changes (if applicable)

   For any design changes, new views, or UI modifications:

   # Start the dev server if not already running
   npm run dev  # Run in background
   

   Using Playwright MCP tools:

   • browser_resize to set mobile viewport (320x568 or similar)
   • browser_navigate to go to affected pages
   • browser_snapshot to check page state
   • browser_take_screenshot to capture images

3. Create Pull Request

   git push -u origin feature-branch-name
   
   gh pr create --title "Feature: [Description]" --body "$(cat <<'EOF'
   ## Summary
   - What was built
   - Why it was needed
   - Key decisions made
   
   ## Testing
   - Tests added/modified
   - Manual testing performed
   
   ## Before / After Screenshots
   | Before | After |