Dev Workflows

Dev Workflows

Overview

Unify build, test, and DX improvement workflows so they are repeatable and reliable. Focus on safe execution, clear diagnostics, and actionable follow-ups.

When to Use

• Running builds or resolving build failures
• Executing tests or analyzing test failures
• Improving onboarding, tooling, or developer workflows

Avoid when:

• The task is pure code implementation
• A full release process is required (use release-prep)

Quick Reference

Workflow

1. Select the workflow type: build, test, or DX. 2. Load the matching reference file. 3. Execute with monitoring and capture diagnostics. 4. Apply fixes or improvements as needed. 5. Verify outcomes and document next steps.

Output

• Execution summary (status, errors, next steps)
• Suggested follow-ups or improvements

Common Mistakes

• Skipping baseline environment checks
• Running tests without capturing failing output
• Changing DX workflows without documenting impact

Reference: build

/dev:build - Project Building and Packaging

Triggers

• Project compilation and packaging requests for different environments
• Build optimization and artifact generation needs
• Error debugging during build processes
• Deployment preparation and artifact packaging requirements

Usage

/dev:build [target] [--type dev|prod|test] [--clean] [--optimize] [--verbose]

Behavioral Flow

1. Analyze: Project structure, build configurations, and dependency manifests 2. Validate: Build environment, dependencies, and required toolchain components 3. Execute: Build process with real-time monitoring and error detection 4. Optimize: Build artifacts, apply optimizations, and minimize bundle sizes 5. Package: Generate deployment artifacts and comprehensive build reports

Key behaviors:

• Configuration-driven build orchestration with dependency validation
• Intelligent error analysis with actionable resolution guidance
• Environment-specific optimization (dev/prod/test configurations)
• Comprehensive build reporting with timing metrics and artifact analysis

MCP Integration

• Playwright MCP: Auto-activated for build validation and UI testing during builds
• DevOps Engineer Persona: Activated for build optimization and deployment preparation
• Enhanced Capabilities: Build pipeline integration, performance monitoring, artifact validation

Personas (Thinking Modes)

• devops-engineer: Build pipeline optimization, deployment preparation, artifact management
• performance-engineer: Build performance, optimization strategies, bundle analysis

Delegation Protocol

When to delegate (use Task tool):

• ✅ Build failure analysis (complex error diagnosis)
• ✅ Build optimization (--optimize flag with analysis)
• ✅ Multi-component builds (>3 targets)
• ✅ Validation with Playwright (--validate flag)

Available subagents:

• general-purpose: Complex error analysis, optimization implementation

Delegation strategy for build issues:

<invoke name="Task">
  <subagent_type>general-purpose</subagent_type>
  <description>Analyze build failure and optimize</description>
  <prompt>
    Build failed. Analyze errors and apply fixes:
    - Parse build logs
    - Identify root cause
    - Apply appropriate fixes
    - Re-run build
    - Generate report
    DevOps engineer thinking for deployment.
  </prompt>
</invoke>

When NOT to delegate (use direct tools):

• ❌ Simple build execution (standard dev/prod builds)
• ❌ Clean builds (no analysis needed)
• ❌ Quick artifact generation

Tool Coordination

• Task tool: Delegates to subagent for complex error analysis and optimization
• Bash: Build execution (direct)
• Read: Configuration analysis (direct)
• Grep: Error parsing (direct for simple, by subagent for complex)
• Glob: Artifact discovery (direct)
• Write: Build reports (direct)

Key Patterns

• Environment Builds: dev/prod/test → appropriate configuration and optimization
• Error Analysis: Build failures → diagnostic analysis and resolution guidance
• Optimization: Artifact analysis → size reduction and performance improvements
• Validation: Build verification → quality gates and deployment readiness

Examples

Standard Project Build

/dev:build
# Builds entire project using default configuration
# Generates artifacts and comprehensive build report

Production Optimization Build

/dev:build --type prod --clean --optimize
# Clean production build with advanced optimizations
# Minification, tree-shaking, and deployment preparation

Targeted Component Build

/dev:build frontend --verbose
# Builds specific project component with detailed output
# Real-time progress monitoring and diagnostic information

Development Build with Validation

/dev:build --type dev --validate
# Development build with Playwright validation
# UI testing and build verification integration

Boundaries

Will:

• Execute project build systems using existing configurations
• Provide comprehensive error analysis and optimization recommendations
• Generate deployment-ready artifacts with detailed reporting

Will Not:

• Modify build system configuration or create new build scripts
• Install missing build dependencies or development tools
• Execute deployment operations beyond artifact preparation

Reference: dx

/dev:dx - Developer Experience Optimization

Triggers

• Onboarding friction, slow setup, or inconsistent environments
• Repetitive development workflows that should be automated
• Build/test feedback loops that feel slow or unreliable
• Tooling or documentation gaps hurting productivity

Usage

/dev:dx [scope] [--focus onboarding|workflow|tooling|docs|automation] [--depth light|normal|deep]

Behavioral Flow

1. Profile: Map the current developer journey and daily workflows 2. Identify: Surface pain points, time sinks, and manual steps 3. Improve: Propose concrete automation and tooling changes 4. Implement: Update scripts, configs, docs, and helpers 5. Validate: Measure impact and provide a follow-up plan

Key behaviors:

• Prefer low-risk, incremental improvements with quick wins
• Document changes so teams can maintain them
• Provide before/after metrics when possible

Delegation Protocol

When to delegate (use Task tool):

• ✅ Multi-area DX work (onboarding + tooling + docs)
• ✅ Large repos with multiple workflows and environments
• ✅ Cross-team tooling audits

Available subagents:

• dx-optimizer: Workflow profiling, automation, tooling, documentation updates

Delegation strategy:

<function_calls>
<invoke name="Task">
  <subagent_type>dx-optimizer</subagent_type>
  <description>Audit developer experience and propose improvements</description>
  <prompt>
    Analyze DX for the provided scope:
    - Onboarding time and setup steps
    - Workflow friction and automation opportunities
    - Tooling and docs gaps
    Deliver prioritized recommendations + implementation plan.
  </prompt>
</invoke>
</function_calls>

When NOT to delegate (use direct tools):

• ❌ Single script tweak or small README update
• ❌ One-off command alias creation

Tool Coordination

• Task tool: Delegates to dx-optimizer for audits and plans
• Read: Inspect docs and tooling configs
• Write: Apply updates to scripts, docs, and config files
• Exec: Validate tooling changes where safe

Examples

Onboarding Improvements

/dev:dx onboarding --focus onboarding --depth deep

Workflow Automation

/dev:dx "frontend build/test" --focus workflow

Tooling and Docs Sweep

/dev:dx --focus tooling --depth normal

Boundaries

Will:

• Improve onboarding, workflows, and documentation for developer productivity
• Recommend automation with clear justification and rollout steps

Will Not:

• Make sweeping changes without validation or a rollback plan
• Introduce tooling that conflicts with existing stack constraints

Reference: test

/dev:test - Testing and Quality Assurance

Triggers

• Test execution requests for unit, integration, or e2e tests
• Coverage analysis and quality gate validation needs
• Continuous testing and watch mode scenarios
• Test failure analysis and debugging requirements

Usage

/dev:test [target] [--type unit|integration|e2e|all] [--coverage] [--watch] [--fix]

Behavioral Flow

1. Discover: Categorize available tests using runner patterns and conventions 2. Configure: Set up appropriate test environment and execution parameters 3. Execute: Run tests with monitoring and real-time progress tracking 4. Analyze: Generate coverage reports and failure diagnostics 5. Report: Provide actionable recommendations and quality metrics

Key behaviors:

• Auto-detect test framework and configuration
• Generate comprehensive coverage reports with metrics
• Activate Playwright MCP for e2e browser testing
• Provide intelligent test failure analysis
• Support continuous watch mode for development

MCP Integration

• Playwright MCP: Auto-activated for --type e2e browser testing
• QA Specialist Persona: Activated for test analysis and quality assessment
• Enhanced Capabilities: Cross-browser testing, visual validation, performance metrics

Personas (Thinking Modes)

• qa-specialist: Quality standards, test strategy, comprehensive coverage mindset
• developer: Code understanding, debugging, practical test scenarios

Delegation Protocol

When to delegate (use Task tool):

• ✅ Test failure analysis (--fix flag with complex failures)
• ✅ Test generation (discovered gaps need new tests)
• ✅ E2E testing with deep validation
• ✅ Coverage gap analysis (>20% uncovered)

Available subagents:

• general-purpose: Test failure diagnosis and fixes
• test-automator: Generate missing tests for coverage gaps

Delegation strategy for test issues:

<invoke name="Task">
  <subagent_type>general-purpose</subagent_type>
  <description>Analyze and fix test failures</description>
  <prompt>
    Tests failing. Diagnose and fix:
    - Parse test output
    - Identify failure patterns
    - Apply appropriate fixes
    - Re-run tests
    - Verify resolution
    QA specialist thinking for quality.
  </prompt>
</invoke>

Delegation for coverage gaps:

<invoke name="Task">
  <subagent_type>test-automator</subagent_type>
  <description>Generate tests for uncovered code</description>
  <prompt>
    Coverage below target. Generate tests for:
    - Identified uncovered code paths
    - Edge cases
    - Error scenarios
    Target: [coverage-target]%
  </prompt>
</invoke>

When NOT to delegate (use direct tools):

• ❌ Simple test execution (tests passing)
• ❌ Watch mode (continuous execution)
• ❌ Quick coverage report generation

Tool Coordination

• Task tool: Delegates for complex failure analysis or test generation
• Bash: Test execution (direct)
• Glob: Test discovery (direct)
• Grep: Result parsing (direct for simple, by subagent for complex)
• Write: Coverage reports (direct)

Key Patterns

• Test Discovery: Pattern-based categorization → appropriate runner selection
• Coverage Analysis: Execution metrics → comprehensive coverage reporting
• E2E Testing: Browser automation → cross-platform validation
• Watch Mode: File monitoring → continuous test execution

Examples

Basic Test Execution

/dev:test
# Discovers and runs all tests with standard configuration
# Generates pass/fail summary and basic coverage

Targeted Coverage Analysis

/dev:test src/components --type unit --coverage
# Unit tests for specific directory with detailed coverage metrics

Browser Testing

/dev:test --type e2e
# Activates Playwright MCP for comprehensive browser testing
# Cross-browser compatibility and visual validation

Development Watch Mode

/dev:test --watch --fix
# Continuous testing with automatic simple failure fixes
# Real-time feedback during development

Boundaries

Will:

• Execute existing test suites using project's configured test runner
• Generate coverage reports and quality metrics
• Provide intelligent test failure analysis with actionable recommendations

Will Not:

• Generate test cases or modify test framework configuration
• Execute tests requiring external services without proper setup
• Make destructive changes to test files without explicit permission