moai-workflow-testing

Development Workflow Specialist

Quick Reference

Unified Development Workflow provides comprehensive development lifecycle management combining DDD testing, AI-powered debugging, performance optimization, automated code review, and quality assurance into integrated workflows.

Core Capabilities:

• DDD Testing: Characterization tests for legacy code, specification tests for greenfield projects, behavior snapshots
• AI-Powered Debugging: Intelligent error analysis and solution recommendations
• Performance Optimization: Profiling and bottleneck detection guidance
• Automated Code Review: TRUST 5 validation framework for quality analysis
• PR Code Review: Multi-agent pattern with Haiku eligibility check and Sonnet parallel review
• Quality Assurance: Comprehensive testing and CI/CD integration patterns
• Workflow Orchestration: End-to-end development process guidance

Workflow Progression: Debug stage leads to Refactor stage, which leads to Optimize stage, then Review stage, followed by Test stage, and finally Profile stage. Each stage benefits from AI-powered analysis and recommendations.

When to Use:

• Complete development lifecycle management
• Enterprise-grade quality assurance implementation
• Multi-language development projects
• Performance-critical applications
• Technical debt reduction initiatives
• Automated testing and CI/CD integration
• Pull request code review automation

---

Implementation Guide

Core Concepts

Unified Development Philosophy:

• Integrates all aspects of development into cohesive workflow
• AI-powered assistance for complex decision-making
• Industry best practices integration for optimal patterns
• Continuous feedback loops between workflow stages
• Automated quality gates and validation

Workflow Components:

Component 1 - AI-Powered Debugging: The debugging component provides intelligent error classification and solution recommendations. When an error occurs, the system analyzes the error type, stack trace, and surrounding context to identify root causes and suggest appropriate fixes. The debugger references current best practices and common error resolution patterns.

Component 2 - Smart Refactoring: The refactoring component performs technical debt analysis and identifies safe automated transformation opportunities. It evaluates code complexity, duplication, and maintainability metrics to recommend specific refactoring actions with risk assessments.

Component 3 - Performance Optimization: The performance component provides real-time monitoring guidance and bottleneck detection. It helps identify CPU-intensive operations, memory leaks, and I/O bottlenecks, then recommends specific optimization strategies based on the identified issues.

Component 4 - DDD Testing Management: The DDD testing component provides specialized testing approaches aligned with domain-driven development. For legacy code, it uses characterization tests to capture current behavior before refactoring (PRESERVE phase). For greenfield projects, it uses specification tests derived from domain requirements. Behavior snapshots ensure behavioral consistency during transformations, and TRUST 5 validation ensures quality standards are maintained.

Component 5 - Automated Code Review: The code review component applies TRUST 5 framework validation with AI-powered quality analysis. It evaluates code against five trust dimensions and provides actionable improvement recommendations.

TRUST 5 Framework

The TRUST 5 framework is a conceptual quality assessment model with five dimensions. This framework provides guidance for evaluating code quality, not an implemented module.

Dimension 1 - Testability: Evaluate whether the code can be effectively tested. Consider whether functions are pure and deterministic, whether dependencies are injectable, and whether the code is modular enough for unit testing. Scoring ranges from low testability requiring significant refactoring to high testability with excellent test coverage support.

Dimension 2 - Readability: Assess how easily the code can be understood by others. Consider whether variable and function names are descriptive, whether the code structure is logical, and whether complex operations are documented. Scoring evaluates naming conventions, code organization, and documentation quality.

Dimension 3 - Understandability: Evaluate the conceptual clarity of the implementation. Consider whether the business logic is clearly expressed, whether abstractions are appropriate, and whether a new developer can understand the code quickly. This goes beyond surface readability to assess architectural clarity.

Dimension 4 - Security: Assess security posture and vulnerability exposure. Consider whether inputs are validated, whether secrets are properly managed, and whether common vulnerability patterns are avoided including injection, XSS, and CSRF. Scoring evaluates adherence to security best practices.

Dimension 5 - Transparency: Evaluate operational visibility and debuggability. Consider whether error handling is comprehensive, whether logs are meaningful and structured, and whether issues can be traced through the system. Scoring assesses observability and troubleshooting capabilities.

Overall TRUST Score Calculation: The overall TRUST score combines all five dimensions using weighted averaging. Critical issues in any dimension can override the average, ensuring security or testability problems are not masked by high scores elsewhere. A passing score typically requires minimum thresholds in each dimension plus an acceptable weighted average.

Basic Workflow Implementation

Debugging Workflow Process:

• Step 1: Capture the error with full context including stack trace, environment, and recent code changes
• Step 2: Classify the error type as syntax, runtime, logic, integration, or performance
• Step 3: Analyze the error pattern against known issue databases and best practices
• Step 4: Generate solution candidates ranked by likelihood of success
• Step 5: Apply the recommended fix and verify resolution
• Step 6: Document the issue and solution for future reference

Refactoring Workflow Process:

• Step 1: Analyze the target codebase for code smells and technical debt indicators
• Step 2: Calculate complexity metrics including cyclomatic complexity and coupling
• Step 3: Identify refactoring opportunities with associated risk levels
• Step 4: Generate a refactoring plan with prioritized actions
• Step 5: Apply refactoring transformations in safe increments
• Step 6: Verify behavior preservation through test execution

Performance Optimization Process:

• Step 1: Configure profiling for target metrics including CPU, memory, I/O, and network
• Step 2: Execute profiling runs under representative load conditions
• Step 3: Analyze profiling results to identify bottlenecks
• Step 4: Generate optimization recommendations with expected impact estimates
• Step 5: Apply optimizations in isolation to measure individual effects
• Step 6: Validate overall performance improvement

DDD Testing Process:

Legacy Code Testing (PRESERVE Phase):

• Step 1: Write characterization tests that capture the current behavior of the system. These tests document what the code actually does, not what it should do.
• Step 2: Organize characterization tests by domain concepts and business rules. Group related behaviors to identify potential domain boundaries.
• Step 3: Use behavior snapshots to record input-output pairs for complex scenarios. These serve as regression safeguards during refactoring.
• Step 4: Verify that all characterization tests pass before making any changes. This establishes a baseline of current behavior.
• Step 5: Apply refactoring transformations while continuously running characterization tests to ensure behavior preservation.
• Step 6: After refactoring, run TRUST 5 validation to ensure code quality standards are maintained.

Greenfield Development Testing:

• Step 1: Derive specification tests directly from domain requirements and use cases. Each test should express a business rule or domain invariant.
• Step 2: Organize tests by domain concepts (aggregates, entities, value objects) following DDD principles.
• Step 3: Write tests that specify domain behavior in business language, avoiding implementation details.
• Step 4: Implement domain logic to satisfy specification tests while maintaining ubiquitous language.
• Step 5: Verify behavior with integration tests that validate domain interactions and invariants.
• Step 6: Apply TRUST 5 validation to ensure testability, readability, and understandability of domain code.

Code Review Process:

• Step 1: Scan the codebase to identify files requiring review
• Step 2: Apply TRUST 5 framework analysis to each file
• Step 3: Identify critical issues requiring immediate attention
• Step 4: Calculate per-file and aggregate quality scores
• Step 5: Generate actionable recommendations with priority rankings
• Step 6: Create a summary report with improvement roadmap

PR Code Review Process:

• Step 1: Eligibility Check using Haiku agent to filter PRs, skipping closed, draft, already reviewed, and trivial changes
• Step 2: Gather Context by finding CLAUDE.md files in modified directories and summarizing PR changes
• Step 3: Parallel Review Agents using five Sonnet agents for independent analysis covering CLAUDE.md compliance, obvious bugs, git blame context, previous comments, and code comment compliance
• Step 4: Confidence Scoring from 0 to 100 for each detected issue where 0 indicates false positive, 25 indicates somewhat confident, 50 indicates moderately confident, 75 indicates highly confident, and 100 indicates absolutely certain
• Step 5: Filter and Report by removing issues below 80 confidence threshold and posting via gh CLI

Common Use Cases

Enterprise Development Workflow: For enterprise applications, the workflow integrates quality gates at each stage. Before deployment, the code must pass minimum TRUST sco

---

Content truncated.