---

name: dev-execution description: "Unified execution engine for all development workflows. Progressive disclosure for phase execution, quick features, story completion, and scaffolding. Integrates with artifact-tracking and meatycapture-capture. Use when running /dev:execute-phase, /dev:quick-feature, /dev:implement-story, /dev:complete-user-story, or /dev:create-feature commands."

Dev Execution Skill

Unified guidance for executing development workflows with token-efficient progressive disclosure.

Quick Start

Execution Modes

Load only the mode-specific content you need:

Core Principles

1. Delegate Everything

• Opus orchestrates; subagents execute
• Never write implementation code directly
• Use batch delegation for parallel work
• Reference @CLAUDE.md for agent assignments

2. Token Efficiency

• Load only mode-specific content when needed
• Use YAML head extraction for large files
• Request-log operations via /mc (token-efficient)
• Read progress YAML only (~2KB), not full files (~25KB)

3. Quality Gates

All modes share these gates - run after each significant change:

Copypnpm test && pnpm typecheck && pnpm lint

Detailed gate requirements: [./validation/quality-gates.md]

Agent Assignment Quick Reference

For detailed assignments: [./orchestration/agent-assignments.md]

Orchestration References

Validation References

Skill Integrations

artifact-tracking

For phase execution, use artifact-tracking skill for:

• CREATE progress files for new phases
• UPDATE task status after completion
• QUERY pending/blocked tasks
• ORCHESTRATE batch delegation

Integration patterns: [./integrations/artifact-tracking.md]

meatycapture-capture

For request-log operations during any execution mode:

• Track work items via /mc commands
• Update item status when starting/completing
• Add notes for progress context
• Search existing logs before creating duplicates

Integration patterns: [./integrations/request-log-workflow.md]

Common Patterns

Start Work on Logged Item

Copy# Mark item in-progress
meatycapture log item update DOC.md ITEM-01 --status in-progress

# Execute work via appropriate agents...

# Mark complete with note
meatycapture log item update DOC.md ITEM-01 --status done
meatycapture log note add DOC.md ITEM-01 -c "Completed in PR #123"

Phase Execution with Artifact Tracking

Copy# 1. Read progress YAML (token-efficient)
head -100 ${progress_file} | sed -n '/^---$/,/^---$/p'

# 2. Identify batch from parallelization field

# 3. Delegate batch (parallel Task() calls in single message)
Task("ui-engineer-enhanced", "TASK-1.1: ...")
Task("backend-typescript-architect", "TASK-1.2: ...")

# 4. Update artifact tracking
Task("artifact-tracker", "Update phase N: Mark TASK-1.1, TASK-1.2 complete")

# 5. Update request-log if applicable
meatycapture log item update REQ-*.md REQ-ITEM --status done

Quick Feature Flow

Copy# 1. Resolve input (REQ-ID, file path, or text)
# 2. codebase-explorer for pattern discovery
# 3. Create lightweight plan
# 4. Delegate to agents
# 5. Quality gates: pnpm test && pnpm typecheck && pnpm lint
# 6. Update request-log if from REQ-ID

Error Recovery

When blocked on any task:

1. Document the blocker in progress tracker
2. Attempt standard recovery (see mode-specific guidance)
3. If unrecoverable: Stop, report to user with clear next steps
4. Track issue in request-log if it warrants separate tracking:

   Copy/mc capture {"title": "...", "type": "bug", "status": "blocked"}
   

Architecture Compliance

All implementations must follow the project's established patterns. Check CLAUDE.md for project-specific conventions.

General Principles

• Follow existing patterns: Match conventions already in the codebase
• Separation of concerns: Keep layers distinct (API, business logic, data access)
• Type safety: Use TypeScript/Python types; avoid any or untyped code
• Error handling: Consistent error responses and proper exception handling
• Observability: Logging, metrics, and tracing where appropriate

Backend Standards

• Layered architecture: Controllers/routers → services → repositories → data store
• DTOs/schemas: Separate API contracts from internal models
• Validation: Input validation at API boundaries
• Pagination: Use cursor or offset pagination for list endpoints
• Documentation: OpenAPI/Swagger specs for APIs

Frontend Standards

• Component library: Use project's designated UI library consistently
• State management: Follow project's chosen pattern (React Query, Redux, etc.)
• Error boundaries: Graceful error handling in UI
• Loading states: Proper feedback during async operations
• Accessibility: WCAG compliance, keyboard navigation, ARIA labels
• Responsive design: Support required viewport sizes

Testing Standards

• Unit tests: Business logic and utility functions
• Integration tests: API endpoints and service interactions
• E2E tests: Critical user flows
• Accessibility tests: Automated a11y checks for UI
• Coverage: Meet project's minimum coverage requirements

Phase Completion Definition

A phase is ONLY complete when:

1. All tasks in plan completed
2. All success criteria met (verified)
3. All tests passing
4. Quality gates passed (types, lint, build)
5. Progress tracker updated to status: completed
6. All commits pushed

Never mark phase complete if any criterion is unmet.

Output Format

Provide structured status updates:

CopyPhase N Execution Update

Orchestration Status:
- Batch 1: ✅ Complete (3/3)
- Batch 2: 🔄 In Progress (1/2)
- Batch 3: ⏳ Pending

Current Work:
- ✅ TASK-2.1 → ui-engineer-enhanced
- 🔄 TASK-2.2 → backend-typescript-architect

Recent Commits:
- abc1234 feat(web): implement X component

Progress: 60% (6/10 tasks)

---

Remember: Follow @CLAUDE.md delegation rules. Orchestrate; don't implement directly. Load only the guidance you need.