phase-3-validator

Validates Implementation Phase completion before advancing to Testing Phase. Checks code compilation, test coverage, implementation completeness, and code quality standards.

⭐5stars🔀1forks📁View on GitHub🕐Updated Jan 11, 2026

When & Why to Use This Skill

The Phase 3 Validator is an automated quality gate tool designed to ensure the Implementation Phase of software development is fully complete and meets rigorous standards before transitioning to the Testing Phase. It systematically evaluates code compilation, implementation completeness across API and Web layers, code quality (TypeScript/C#), and documentation readiness, providing a quantitative score against pre-defined quality thresholds to minimize technical debt and prevent broken builds.

Use Cases

  • Automated Quality Gates: Enforce mandatory checks in the development workflow to ensure that features, bug fixes, or hotfixes meet specific quality percentages before being handed over to QA.
  • Architectural Compliance: Automatically detect critical architectural violations, such as direct database access from the web layer or missing error handling in API endpoints, early in the lifecycle.
  • Vertical Slice Validation: Validate the first complete feature path (UI to Database) to identify and rectify systemic architectural issues before they are replicated across the entire project.
  • Multi-Stack Code Review: Perform comprehensive static analysis across different technologies (TypeScript, C#, ESLint) to ensure consistent code standards and successful builds for both API and Web components.
namephase-3-validator
descriptionValidates Implementation Phase completion before advancing to Testing Phase. Checks code compilation, test coverage, implementation completeness, and code quality standards.

Phase 3 (Implementation) Validation Skill

Purpose: Automate validation of Implementation Phase before advancing to Testing Phase.

When to Use: When orchestrator needs to verify implementation is ready for comprehensive testing.

How to Use This Skill

Executable Script: execute.sh

# Basic usage
bash .claude/skills/phase-3-validator/execute.sh <feature-name> [work-type] [required-percentage]

# Examples:
bash .claude/skills/phase-3-validator/execute.sh events
bash .claude/skills/phase-3-validator/execute.sh vetting Bug 75
bash .claude/skills/phase-3-validator/execute.sh payment-processing Hotfix 70

Parameters:

  • feature-name: Name of feature being validated (required)
  • work-type: Feature|Bug|Hotfix|Docs|Refactor (optional, default: Feature)
  • required-percentage: Override quality gate threshold (optional)

Script validates:

  • API and Web build successfully
  • Implementation completeness (endpoints, components, migrations, services)
  • Code quality (TypeScript, C#, ESLint, error handling)
  • Testing infrastructure (unit, integration, E2E tests, fixtures)
  • Documentation (implementation notes, API docs, examples, limitations)

Exit codes:

  • 0: Implementation Phase complete, ready for Testing Phase
  • 1: Implementation incomplete or quality gates not met

Quality Gate Checklist (85% Required for Features)

Code Compilation (10 points)

  • API builds without errors (5 points)
  • Web builds without errors (5 points)

Implementation Completeness (15 points)

  • All API endpoints implemented (4 points)
  • All React components created (4 points)
  • Database migrations created (3 points)
  • Service layer implemented (2 points)
  • Type definitions match API (2 points)

Code Quality (10 points)

  • No TypeScript errors (2 points)
  • No C# warnings (2 points)
  • ESLint passes (2 points)
  • Proper error handling (2 points)
  • Code follows project patterns (2 points)

Testing Infrastructure (10 points)

  • Unit tests created (3 points)
  • Integration test stubs created (3 points)
  • E2E test files created (2 points)
  • Test data/fixtures prepared (2 points)

Documentation (5 points)

  • Implementation notes documented (2 points)
  • API endpoints documented (1 point)
  • Component usage examples (1 point)
  • Known limitations noted (1 point)

Usage Examples

From Orchestrator

Use the phase-3-validator skill to check if implementation is ready for testing

Manual Validation

# Run validation for specific feature
bash .claude/skills/phase-3-validator.md "event-management"

Common Issues

Issue: Build Failures

Critical - Must fix before testing:

  • Compilation errors in API
  • TypeScript errors in Web
  • Missing dependencies

Solution: Loop back to react-developer or backend-developer agents.

Issue: Missing Test Files

Solution: Test files should exist even if not fully implemented:

  • Unit tests for services and components
  • Integration test stubs for API endpoints
  • E2E test files for user workflows

Issue: Architectural Violations

Critical violations:

  • Direct database access from Web service
  • Using Blazor patterns in React code
  • Missing error handling in API endpoints

Issue: No Type Definitions

Solution: After creating API endpoints:

cd packages/shared-types
npm run generate

First Vertical Slice Checkpoint

MANDATORY: After implementing the first vertical slice (one complete feature from UI → API → Database):

  1. Run phase-3-validator
  2. If score ≥ 85%, PAUSE for human review
  3. Wait for explicit approval before continuing with remaining features

Why: This catches architectural issues early before they propagate to all features.

Output Format

{
  "phase": "implementation",
  "status": "pass|fail",
  "score": 43,
  "maxScore": 50,
  "percentage": 86,
  "requiredPercentage": 85,
  "compilation": {
    "api": "success",
    "web": "success"
  },
  "codeQuality": {
    "typescriptErrors": 0,
    "csharpWarnings": 2,
    "eslintErrors": 0,
    "architecturalViolations": 0
  },
  "testing": {
    "unitTests": 12,
    "integrationTests": 3,
    "e2eTests": 2
  },
  "missingItems": [
    "Component usage examples",
    "Known limitations not documented"
  ],
  "criticalIssues": [],
  "readyForNextPhase": true,
  "requiresHumanReview": false
}

Integration with Quality Gates

This skill enforces the quality gate thresholds by work type:

  • Feature: 85% required (43/50 points)
  • Bug Fix: 75% required (38/50 points)
  • Hotfix: 70% required (35/50 points)
  • Refactoring: 90% required (45/50 points)

Progressive Disclosure

Initial Context: Show compilation and critical checks only On Request: Show full validation with all scoring On Failure: Show specific failing items with fix suggestions On First Vertical Slice: Show full report + human review prompt


Remember: This skill validates implementation quality but doesn't test functionality. That's Phase 4's job. This ensures code is test-ready.