Test Design Techniques

Name: Test Design Techniques
Author: proffesor-for-testing

proffesor-for-testing/agentic-qe

168 installs
433 repo stars
Updated August 4, 2026
proffesor-for-testing/agentic-qe

Apply equivalence partitioning, boundary analysis, decision tables, and risk-based test design to translate requirements into minimal yet high-yield test cases early in implementation.

About

Teaches foundational test design techniques from agentic-qe—equivalence classes, boundaries, decision tables, and risk prioritization—so teams produce lean, high-signal test plans during build rather than ad hoc case lists after defects appear.

Equivalence partitioning
Boundary value analysis
Decision and state tables
Risk-based prioritization
Traceability to requirements

Test Design Techniques by the numbers

168 all-time installs (skills.sh)
+5 installs in the week ending Aug 4, 2026 (Skillselion tracking)
Ranked #852 of 2,153 Testing & QA skills by installs in the Skillselion catalog
Data as of Aug 5, 2026 (Skillselion catalog sync)

npx skills add https://github.com/proffesor-for-testing/agentic-qe --skill test-design-techniques

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/proffesor-for-testing/agentic-qe/test-design-techniques.svg)](https://skillselion.com/skills/proffesor-for-testing/agentic-qe/test-design-techniques)

Installs	168
repo stars	★ 433
Last updated	August 4, 2026
Repository	proffesor-for-testing/agentic-qe ↗

What it does

Apply equivalence partitioning, boundary analysis, decision tables, and risk-based test design to translate requirements into minimal yet high-yield test cases early in implementation.

Files

SKILL.mdMarkdownGitHub ↗

Test Design Techniques

<default_to_action> When designing test cases, select technique by input type:

Numeric ranges → BVA + EP
Multiple conditions → Decision Tables
Workflows → State Transition
Many parameter combinations → Pairwise Testing

</default_to_action>

Quick Reference Card

When to Use

Designing new test suites
Optimizing existing tests
Complex business rules
Reducing test redundancy

---

Agent-Driven Test Design

// Auto-generate BVA tests
await Task("Generate BVA Tests", {
  field: 'age',
  dataType: 'integer',
  constraints: { min: 18, max: 120 }
}, "qe-test-generator");
// Returns: 6 boundary test cases

// Auto-generate pairwise tests
await Task("Generate Pairwise Tests", {
  parameters: {
    browser: ['Chrome', 'Firefox', 'Safari'],
    os: ['Windows', 'Mac', 'Linux'],
    screen: ['Desktop', 'Tablet', 'Mobile']
  }
}, "qe-test-generator");
// Returns: 9-12 tests (vs 27 full combination)

---

Agent Coordination Hints

Memory Namespace

aqe/test-design/
├── bva-analysis/*       - Boundary value tests
├── partitions/*         - Equivalence partitions
├── decision-tables/*    - Decision table tests
└── pairwise/*           - Combinatorial reduction

Fleet Coordination

const designFleet = await FleetManager.coordinate({
  strategy: 'systematic-test-design',
  agents: [
    'qe-test-generator',    // Apply design techniques
    'qe-coverage-analyzer', // Analyze coverage
    'qe-quality-analyzer'   // Assess test quality
  ],
  topology: 'sequential'
});

---

Related Skills

agentic-quality-engineering - Agent-driven testing
risk-based-testing - Prioritize by risk
mutation-testing - Validate test effectiveness

---

Remember

With Agents: qe-test-generator applies these techniques automatically, generating optimal test suites with maximum coverage and minimum redundancy. Agents identify boundaries, partitions, and combinations from code analysis.

skill: test-design-techniques
version: 1.0.0
description: >
  Evaluation suite for test-design-techniques skill.
  Tests generation of test design techniques including boundary value analysis,
  equivalence partitioning, pairwise testing, and state machine modeling.

models_to_test:
  - claude-sonnet-4-6    # Primary (high accuracy expected)
  - claude-haiku-4-5     # Fast model (minimum quality floor)

mcp_integration:
  enabled: true
  namespace: skill-validation
  query_patterns: true
  track_outcomes: true
  store_patterns: true
  share_learning: true
  target_agents:
    - qe-learning-coordinator

learning:
  store_success_patterns: true
  pattern_ttl_days: 90
  min_confidence_to_store: 0.7

result_format:
  json_output: true
  include_timing: true

setup:
  required_tools:
    - jq

test_cases:
  - id: tc001_boundary_value_analysis
    description: "Skill generates boundary value analysis test cases"
    category: core
    priority: critical

    input:
      requirement: "Age field must accept values 18-65"
      context:
        technique: "boundary_value_analysis"

    expected_output:
      must_contain:
        - "boundary"
        - "test case"

    validation:
      schema_check: true

  - id: tc002_equivalence_partitioning
    description: "Skill applies equivalence partitioning technique"
    category: core
    priority: critical

    input:
      requirement: "User status: active, inactive, suspended"
      context:
        technique: "equivalence_partitioning"

    expected_output:
      must_contain:
        - "equivalence"
        - "partition"

    validation:
      schema_check: true

  - id: tc003_pairwise_testing
    description: "Skill generates pairwise test combinations"
    category: core
    priority: high

    input:
      parameters:
        - browser: "Chrome, Firefox, Safari"
        - os: "Windows, macOS, Linux"
      context:
        technique: "pairwise"

    expected_output:
      must_contain:
        - "pair"
        - "combination"

    validation:
      schema_check: true
      allow_partial: true

  - id: tc004_state_machine_testing
    description: "Skill models state transitions for testing"
    category: core
    priority: high

    input:
      workflow: "Order processing: pending -> processing -> shipped -> delivered"
      context:
        technique: "state_machine"

    expected_output:
      must_contain:
        - "state"
        - "transition"

    validation:
      schema_check: true
      allow_partial: true

  - id: tc005_decision_table_testing
    description: "Skill creates decision table for business logic"
    category: core
    priority: high

    input:
      rules: "Discount applies if customer is VIP AND order > $100"
      context:
        technique: "decision_table"

    expected_output:
      must_contain:
        - "decision"
        - "table"

    validation:
      schema_check: true
      allow_partial: true

success_criteria:
  pass_rate: 0.8
  critical_pass_rate: 1.0
  avg_reasoning_quality: 0.7
  max_execution_time_ms: 300000
  cross_model_variance: 0.15

metadata:
  author: "qe-test-architect"
  created: "2026-02-02"
  last_updated: "2026-02-02"
  coverage_target: "Boundary analysis, equivalence partitioning, pairwise, state machine, decision tables"

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "https://agentic-qe.dev/schemas/test-design-techniques-output.json",
  "title": "AQE Test Design Techniques Skill Output Schema",
  "description": "Schema for systematic test design output including BVA, EP, decision tables, state transitions, and pairwise testing.",
  "type": "object",
  "required": ["skillName", "version", "timestamp", "status", "trustTier", "output"],
  "properties": {
    "skillName": {
      "type": "string",
      "const": "test-design-techniques",
      "description": "Skill identifier"
    },
    "version": {
      "type": "string",
      "pattern": "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9]+)?$"
    },
    "timestamp": {
      "type": "string",
      "pattern": "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})?$"
    },
    "status": {
      "type": "string",
      "enum": ["success", "partial", "failed", "skipped"]
    },
    "trustTier": {
      "type": "integer",
      "const": 3
    },
    "output": {
      "type": "object",
      "required": ["summary", "techniquesApplied", "testCasesGenerated", "metrics"],
      "properties": {
        "summary": {
          "type": "string",
          "minLength": 10,
          "maxLength": 2000
        },
        "score": {
          "$ref": "#/$defs/designScore"
        },
        "techniquesApplied": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/techniqueResult"
          },
          "minItems": 1,
          "description": "Test design techniques applied"
        },
        "testCasesGenerated": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/testCase"
          },
          "description": "Generated test cases"
        },
        "coverageAnalysis": {
          "$ref": "#/$defs/coverageAnalysis",
          "description": "Coverage achieved by generated tests"
        },
        "optimizationResult": {
          "$ref": "#/$defs/optimizationResult",
          "description": "Test reduction/optimization results"
        },
        "findings": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/designFinding"
          },
          "maxItems": 500
        },
        "recommendations": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/recommendation"
          },
          "maxItems": 100
        },
        "metrics": {
          "$ref": "#/$defs/designMetrics"
        },
        "artifacts": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/artifact"
          },
          "maxItems": 50
        }
      }
    },
    "metadata": {
      "type": "object",
      "properties": {
        "executionTimeMs": { "type": "integer", "minimum": 0 },
        "toolsUsed": { "type": "array", "items": { "type": "string" } },
        "agentId": { "type": "string", "pattern": "^qe-[a-z][a-z0-9-]*$" },
        "inputType": {
          "type": "string",
          "enum": ["requirements", "code", "api-spec", "user-story"]
        }
      }
    },
    "validation": {
      "type": "object",
      "properties": {
        "schemaValid": { "type": "boolean" },
        "contentValid": { "type": "boolean" },
        "confidence": { "type": "number", "minimum": 0, "maximum": 1 }
      }
    },
    "learning": {
      "type": "object",
      "properties": {
        "patternsDetected": { "type": "array", "items": { "type": "string" } },
        "reward": { "type": "number", "minimum": 0, "maximum": 1 }
      }
    }
  },
  "$defs": {
    "designScore": {
      "type": "object",
      "required": ["value", "max"],
      "properties": {
        "value": { "type": "number", "minimum": 0, "maximum": 100 },
        "max": { "type": "number", "const": 100 },
        "grade": { "type": "string", "pattern": "^[A-F][+-]?$" },
        "coverageEfficiency": {
          "type": "number",
          "minimum": 0,
          "maximum": 100,
          "description": "Coverage achieved vs test count"
        }
      }
    },
    "techniqueResult": {
      "type": "object",
      "required": ["technique", "applied"],
      "properties": {
        "technique": {
          "type": "string",
          "enum": ["bva", "equivalence-partitioning", "decision-table", "state-transition", "pairwise", "use-case", "classification-tree", "cause-effect"],
          "description": "Test design technique"
        },
        "applied": { "type": "boolean" },
        "testCasesGenerated": { "type": "integer", "minimum": 0 },
        "coverageAchieved": { "type": "number", "minimum": 0, "maximum": 100 },
        "details": {
          "type": "object",
          "additionalProperties": true,
          "description": "Technique-specific details"
        }
      }
    },
    "testCase": {
      "type": "object",
      "required": ["id", "name", "technique"],
      "properties": {
        "id": { "type": "string" },
        "name": { "type": "string" },
        "technique": {
          "type": "string",
          "enum": ["bva", "equivalence-partitioning", "decision-table", "state-transition", "pairwise", "use-case"]
        },
        "description": { "type": "string" },
        "preconditions": { "type": "array", "items": { "type": "string" } },
        "inputs": {
          "type": "object",
          "additionalProperties": true
        },
        "expectedOutput": { "type": "string" },
        "priority": { "type": "string", "enum": ["critical", "high", "medium", "low"] },
        "partitions": {
          "type": "array",
          "items": { "type": "string" },
          "description": "Equivalence partitions covered"
        },
        "boundaries": {
          "type": "array",
          "items": { "type": "string" },
          "description": "Boundary values tested"
        },
        "states": {
          "type": "array",
          "items": { "type": "string" },
          "description": "States covered"
        }
      }
    },
    "coverageAnalysis": {
      "type": "object",
      "properties": {
        "partitionsCovered": {
          "type": "object",
          "properties": {
            "total": { "type": "integer" },
            "covered": { "type": "integer" },
            "percentage": { "type": "number" }
          }
        },
        "boundariesCovered": {
          "type": "object",
          "properties": {
            "total": { "type": "integer" },
            "covered": { "type": "integer" },
            "percentage": { "type": "number" }
          }
        },
        "statesCovered": {
          "type": "object",
          "properties": {
            "total": { "type": "integer" },
            "covered": { "type": "integer" },
            "percentage": { "type": "number" }
          }
        },
        "transitionsCovered": {
          "type": "object",
          "properties": {
            "total": { "type": "integer" },
            "covered": { "type": "integer" },
            "percentage": { "type": "number" }
          }
        },
        "pairsCovered": {
          "type": "object",
          "properties": {
            "total": { "type": "integer" },
            "covered": { "type": "integer" },
            "percentage": { "type": "number" }
          }
        }
      }
    },
    "optimizationResult": {
      "type": "object",
      "properties": {
        "originalTestCount": { "type": "integer", "minimum": 0 },
        "optimizedTestCount": { "type": "integer", "minimum": 0 },
        "reductionPercent": { "type": "number", "minimum": 0, "maximum": 100 },
        "coverageRetained": { "type": "number", "minimum": 0, "maximum": 100 },
        "redundantTestsRemoved": { "type": "integer", "minimum": 0 },
        "technique": {
          "type": "string",
          "description": "Optimization technique used"
        }
      }
    },
    "designFinding": {
      "type": "object",
      "required": ["id", "title", "severity"],
      "properties": {
        "id": { "type": "string", "pattern": "^TDT-\\d{3,6}$" },
        "title": { "type": "string", "minLength": 5, "maxLength": 200 },
        "description": { "type": "string", "maxLength": 2000 },
        "severity": { "type": "string", "enum": ["critical", "high", "medium", "low", "info"] },
        "category": {
          "type": "string",
          "enum": ["coverage-gap", "redundancy", "missing-boundary", "missing-partition", "invalid-transition"]
        },
        "remediation": { "type": "string" }
      }
    },
    "designMetrics": {
      "type": "object",
      "properties": {
        "techniquesUsed": { "type": "integer", "minimum": 0 },
        "testCasesGenerated": { "type": "integer", "minimum": 0 },
        "coverageScore": { "type": "number", "minimum": 0, "maximum": 100 },
        "redundancyRemoved": { "type": "number", "minimum": 0, "maximum": 100 },
        "boundariesIdentified": { "type": "integer", "minimum": 0 },
        "partitionsIdentified": { "type": "integer", "minimum": 0 },
        "statesIdentified": { "type": "integer", "minimum": 0 }
      }
    },
    "recommendation": {
      "type": "object",
      "required": ["id", "title", "priority"],
      "properties": {
        "id": { "type": "string", "pattern": "^REC-\\d{3,6}$" },
        "title": { "type": "string" },
        "description": { "type": "string" },
        "priority": { "type": "string", "enum": ["critical", "high", "medium", "low"] }
      }
    },
    "artifact": {
      "type": "object",
      "required": ["type", "path"],
      "properties": {
        "type": { "type": "string", "enum": ["test-suite", "coverage-report", "decision-table", "state-diagram"] },
        "path": { "type": "string" },
        "format": { "type": "string", "enum": ["json", "yaml", "md", "html", "csv"] }
      }
    }
  }
}

{
  "skillName": "test-design-techniques",
  "skillVersion": "1.0.0",
  "requiredTools": [
    "jq"
  ],
  "optionalTools": [
    "ajv",
    "jsonschema",
    "python3"
  ],
  "schemaPath": "schemas/output.json",
  "requiredFields": [
    "skillName",
    "status",
    "output"
  ],
  "requiredNonEmptyFields": [],
  "mustContainTerms": [
    "test",
    "design",
    "technique"
  ],
  "mustNotContainTerms": [
    "TODO",
    "placeholder"
  ],
  "enumValidations": {
    ".status": [
      "success",
      "partial",
      "failed",
      "skipped"
    ]
  }
}