
Qe Quality Assessment
- 36 installs
- 433 repo stars
- Updated August 4, 2026
- proffesor-for-testing/agentic-qe
qe quality assessment is a Claude Code skill for ai & agent building.
About
qe quality assessment is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted development.
- qe quality assessment
- AI & Agent Building
- AI-coding skill
Qe Quality Assessment by the numbers
- 36 all-time installs (skills.sh)
- Ranked #8,638 of 16,546 AI & Agent Building 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 qe-quality-assessmentAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 36 |
|---|---|
| repo stars | ★ 433 |
| Last updated | August 4, 2026 |
| Repository | proffesor-for-testing/agentic-qe ↗ |
How do I helps with ai & agent building tasks.?
Helps with ai & agent building tasks.
Who is it for?
Best when you're working on ai & agent building and need structured help with qe quality assessment.
Skip if: Teams with no ai & agent building needs, or anyone wanting a generic chat assistant without this specific workflow.
When should I use this skill?
When you need to helps with ai & agent building tasks., or when qe quality assessment is a claude code skill for ai & agent building.
What you get
Structured output aligned to qe quality assessment: qe quality assessment, AI & Agent Building.
Files
QE Quality Assessment
Purpose
Guide the use of v3's quality assessment capabilities including automated quality gates, metrics aggregation, trend analysis, and deployment readiness evaluation.
Activation
- When evaluating code quality
- When setting up quality gates
- When assessing deployment readiness
- When tracking quality metrics
- When generating quality reports
Quick Start
# Run quality assessment
aqe quality assess --scope src/ --gates all
# Check deployment readiness
aqe quality deploy-ready --environment production
# Generate quality report
aqe quality report --format dashboard --period 30d
# Compare quality between releases
aqe quality compare --from v1.0 --to v2.0Agent Workflow
// Comprehensive quality assessment
Task("Assess code quality", `
Evaluate quality for src/:
- Code complexity (cyclomatic, cognitive)
- Test coverage and mutation score
- Security vulnerabilities
- Code smells and technical debt
- Documentation coverage
Generate quality score and recommendations.
`, "qe-quality-analyzer")
// Deployment readiness check
Task("Check deployment readiness", `
Evaluate if release v2.1.0 is ready for production:
- All tests passing
- Coverage thresholds met
- No critical vulnerabilities
- Performance benchmarks passed
- Documentation updated
Provide go/no-go recommendation.
`, "qe-deployment-advisor")Quality Dimensions
1. Code Quality Metrics
await qualityAnalyzer.assessCode({
scope: 'src/**/*.ts',
metrics: {
complexity: {
cyclomatic: { max: 15, warn: 10 },
cognitive: { max: 20, warn: 15 }
},
maintainability: {
index: { min: 65 },
duplication: { max: 3 } // percent
},
documentation: {
publicAPIs: { min: 80 },
complexity: { min: 70 }
}
}
});2. Quality Gates
await qualityGate.evaluate({
gates: {
coverage: { min: 80, blocking: true },
complexity: { max: 15, blocking: false },
vulnerabilities: { critical: 0, high: 0, blocking: true },
duplications: { max: 3, blocking: false },
techDebt: { maxRatio: 5, blocking: false }
},
action: {
onPass: 'proceed',
onFail: 'block-merge',
onWarn: 'notify'
}
});3. Deployment Readiness
await deploymentAdvisor.assess({
release: 'v2.1.0',
criteria: {
testing: {
unitTests: 'all-pass',
integrationTests: 'all-pass',
e2eTests: 'critical-pass',
performanceTests: 'baseline-met'
},
quality: {
coverage: 80,
noNewVulnerabilities: true,
noRegressions: true
},
documentation: {
changelog: true,
apiDocs: true,
releaseNotes: true
}
}
});Quality Score Calculation
quality_score:
components:
test_coverage:
weight: 0.25
metrics: [statement, branch, function]
code_quality:
weight: 0.20
metrics: [complexity, maintainability, duplication]
security:
weight: 0.25
metrics: [vulnerabilities, dependencies]
reliability:
weight: 0.20
metrics: [bug_density, flaky_tests, error_rate]
documentation:
weight: 0.10
metrics: [api_coverage, readme, changelog]
scoring:
A: 90-100
B: 80-89
C: 70-79
D: 60-69
F: 0-59Quality Dashboard
interface QualityDashboard {
overallScore: number; // 0-100
grade: 'A' | 'B' | 'C' | 'D' | 'F';
dimensions: {
name: string;
score: number;
trend: 'improving' | 'stable' | 'declining';
issues: Issue[];
}[];
gates: {
name: string;
status: 'pass' | 'fail' | 'warn';
value: number;
threshold: number;
}[];
trends: {
period: string;
scores: number[];
alerts: Alert[];
};
recommendations: Recommendation[];
}CI/CD Integration
# Quality gate in pipeline
quality_check:
stage: verify
script:
- aqe quality assess --gates all --output report.json
rules:
- if: $CI_PIPELINE_SOURCE == "merge_request_event"
artifacts:
reports:
quality: report.json
allow_failure:
exit_codes:
- 1 # Warnings onlyRun History
After each quality assessment, append results to run-history.json in this skill directory:
node -e "
const fs = require('fs');
const h = JSON.parse(fs.readFileSync('.claude/skills/qe-quality-assessment/run-history.json'));
h.runs.push({date: new Date().toISOString().split('T')[0], gate_result: 'PASS_OR_FAIL', failed_checks: []});
fs.writeFileSync('.claude/skills/qe-quality-assessment/run-history.json', JSON.stringify(h, null, 2));
"Read run-history.json before each run — alert if quality gate failed 3 of last 5 runs.
Skill Composition
- Before assessment → Run
/qe-coverage-analysisand/mutation-testingfirst - If issues found → Use
/test-failure-investigatorto diagnose failures - For PR review → Combine with
/code-review-qualityfor comprehensive review
Gotchas
- NEVER trust agent-reported pass/fail status — 12 test failures were caught that agents claimed were passing (Nagual pattern, reward 0.92)
- Completion theater: agent hardcoded version '3.0.0' instead of reading from package.json — verify actual values in output
- Fix issues in priority waves (P0 → P1 → P2) with verification between each wave — don't fix everything in parallel
- quality-assessment domain has 53.7% success rate — expect failures and have fallback
- If HybridMemoryBackend initialization fails, run
aqe healthto diagnose, oraqe initto re-initialize
Coordination
Primary Agents: qe-quality-analyzer, qe-deployment-advisor, qe-metrics-collector Coordinator: qe-quality-coordinator Related Skills: qe-coverage-analysis, security-testing
# =============================================================================
# AQE Skill Evaluation Test Suite: QE Quality Assessment v1.0.0
# =============================================================================
#
# Comprehensive evaluation suite for the qe-quality-assessment skill.
# Tests quality gates, metrics aggregation, trend analysis, deployment
# readiness evaluation, and quality scoring.
#
# Schema: .claude/skills/.validation/schemas/skill-eval.schema.json
# Validator: .claude/skills/qe-quality-assessment/scripts/validate-config.json
#
# Coverage:
# - Code quality metrics (complexity, maintainability, duplication)
# - Quality gates with pass/fail criteria
# - Deployment readiness assessment
# - Quality scoring and grading
# - Trend analysis and alerts
#
# =============================================================================
skill: qe-quality-assessment
version: 1.0.0
description: >
Comprehensive evaluation suite for the qe-quality-assessment skill.
Tests automated quality gates, metrics aggregation, trend analysis,
deployment readiness evaluation, quality scoring with grading, and
comprehensive quality dashboards.
# =============================================================================
# Multi-Model Configuration
# =============================================================================
models_to_test:
- claude-sonnet-4-6 # Primary (high accuracy expected)
- claude-haiku-4-5 # Fast model (minimum quality floor)
# =============================================================================
# MCP Integration Configuration
# =============================================================================
mcp_integration:
enabled: true
namespace: skill-validation
query_patterns: true
track_outcomes: true
store_patterns: true
share_learning: true
update_quality_gate: true
target_agents:
- qe-learning-coordinator
- qe-queen-coordinator
- qe-quality-analyzer
- qe-deployment-advisor
# =============================================================================
# ReasoningBank Learning Configuration
# =============================================================================
learning:
store_success_patterns: true
store_failure_patterns: true
pattern_ttl_days: 90
min_confidence_to_store: 0.7
cross_model_comparison: true
# =============================================================================
# Result Format Configuration
# =============================================================================
result_format:
json_output: true
markdown_report: true
include_raw_output: false
include_timing: true
include_token_usage: true
# =============================================================================
# Environment Setup
# =============================================================================
setup:
required_tools:
- jq
environment_variables:
QUALITY_GATE_BLOCKING: "true"
MIN_QUALITY_SCORE: "70"
fixtures: []
# =============================================================================
# TEST CASES
# =============================================================================
test_cases:
# ---------------------------------------------------------------------------
# CATEGORY: Code Quality Metrics
# ---------------------------------------------------------------------------
- id: tc001_code_complexity_assessment
description: "Assess code complexity across multiple metrics"
category: code_quality
priority: critical
input:
prompt: |
Assess code quality for UserService module:
- Cyclomatic complexity (max 15, warn 10)
- Cognitive complexity (max 20, warn 15)
- Method length (max 50 lines, warn 30)
- Nesting depth (max 4, warn 3)
- Duplicate code (max 3%, warn 5%)
For each metric, assign status (OK/WARN/FAIL).
What's the overall code quality score?
context:
scope: "src/services/UserService.ts"
metrics: "all"
include_recommendations: true
expected_output:
must_contain:
- "complexity"
- "cyclomatic"
- "cognitive"
- "quality"
- "score"
must_not_contain:
- "error"
- "cannot assess"
severity_classification: critical
finding_count:
min: 1
validation:
schema_check: true
keyword_match_threshold: 0.8
reasoning_quality_min: 0.75
- id: tc002_maintainability_index
description: "Calculate maintainability index for codebase"
category: code_quality
priority: high
input:
prompt: |
Calculate maintainability index (0-100) for src/:
- Lines of code
- Cyclomatic complexity
- Halstead volume
- Comment ratio
Score: 86-100 = A, 66-85 = B, 51-65 = C, 36-50 = D, <36 = F
What does score B mean and how to improve?
context:
metric: "maintainability_index"
include_grade: true
expected_output:
must_contain:
- "maintainability"
- "index"
- "grade"
- "improve"
- "score"
severity_classification: high
validation:
schema_check: true
keyword_match_threshold: 0.75
- id: tc003_documentation_coverage
description: "Assess API documentation completeness"
category: code_quality
priority: high
input:
prompt: |
Assess documentation coverage:
- Public APIs (classes, functions) must have JSDoc
- Parameters and return types documented
- Complex functions need usage examples
- Critical modules need overview comments
Target: >= 80% for public APIs
How would you measure and track this?
context:
scope: "src/**/*.ts"
coverage_target: 0.8
expected_output:
must_contain:
- "documentation"
- "coverage"
- "API"
- "JSDoc"
- "track"
finding_count:
min: 1
validation:
schema_check: true
keyword_match_threshold: 0.75
# ---------------------------------------------------------------------------
# CATEGORY: Quality Gates
# ---------------------------------------------------------------------------
- id: tc004_quality_gate_evaluation
description: "Evaluate code against quality gates"
category: gates
priority: critical
input:
prompt: |
Evaluate PR against quality gates:
1. Coverage gate: new code >= 85% (ACTUAL: 82%) -> FAIL
2. Complexity gate: cyclomatic max 15 (ACTUAL: 18) -> FAIL
3. Vulnerabilities gate: critical = 0 (ACTUAL: 1) -> FAIL
4. Duplication gate: max 3% (ACTUAL: 2%) -> PASS
5. Tech debt gate: max 5% (ACTUAL: 6%) -> FAIL
Should this merge be blocked?
context:
gates: "all"
block_on_fail: true
expected_output:
must_contain:
- "gate"
- "fail"
- "block"
- "threshold"
- "blocked"
must_not_contain:
- "pass"
- "approved"
severity_classification: critical
validation:
schema_check: true
keyword_match_threshold: 0.8
reasoning_quality_min: 0.75
- id: tc005_gate_failure_remediation
description: "Help fix quality gate failures"
category: gates
priority: high
input:
prompt: |
Fix the gate failures from previous test:
1. Coverage 82% (need 85%): What tests to add?
2. Complexity 18 (max 15): Refactor strategy?
3. Vulnerabilities: 1 critical - fix?
4. Tech debt 6% (max 5%): Paydown plan?
Prioritize by effort vs impact.
context:
failures: "critical"
remediation_guidance: true
expected_output:
must_contain:
- "fix"
- "test"
- "refactor"
- "prioritize"
- "remediation"
finding_count:
min: 1
validation:
schema_check: true
keyword_match_threshold: 0.75
# ---------------------------------------------------------------------------
# CATEGORY: Deployment Readiness
# ---------------------------------------------------------------------------
- id: tc006_deployment_readiness_check
description: "Assess if release is ready for production"
category: deployment
priority: critical
input:
prompt: |
Assess release v2.1.0 for production readiness:
TESTING:
- Unit tests: PASS (all 245 passing)
- Integration tests: PASS (all 89 passing)
- E2E tests: 95% pass (1 flaky test)
- Performance tests: P95 latency 425ms (target 500ms) PASS
QUALITY:
- Coverage: 84% (target 80%) PASS
- Vulnerabilities: 0 critical (target 0) PASS
- Code review: 2 approvals PASS
- Documentation: Updated PASS
OPERATIONS:
- Changelog: Complete
- Rollback plan: Ready
- Monitoring: Configured
GO or NO-GO?
context:
release_version: "v2.1.0"
strict_checks: true
expected_output:
must_contain:
- "ready"
- "deployment"
- "pass"
- "go"
- "production"
must_not_contain:
- "concerns"
- "risks"
severity_classification: critical
validation:
schema_check: true
keyword_match_threshold: 0.8
reasoning_quality_min: 0.75
- id: tc007_pre_deployment_risks
description: "Identify risks before deployment"
category: deployment
priority: critical
input:
prompt: |
Identify pre-deployment risks for v2.2.0:
- 45 files changed (large change set)
- Database migration required (can't rollback easily)
- Changes to payment processing (high-risk)
- New external API integration
- Only 3 days of staging testing
Risk level: HIGH/MEDIUM/LOW?
Recommended actions?
context:
risk_assessment: true
recommendations: true
expected_output:
must_contain:
- "risk"
- "high"
- "action"
- "recommend"
severity_classification: critical
validation:
schema_check: true
keyword_match_threshold: 0.8
# ---------------------------------------------------------------------------
# CATEGORY: Quality Scoring
# ---------------------------------------------------------------------------
- id: tc008_quality_score_calculation
description: "Calculate overall quality score"
category: scoring
priority: critical
input:
prompt: |
Calculate quality score for project using:
1. Test coverage: 82% (weight 25%) -> 82*0.25 = 20.5
2. Code quality: 78/100 (weight 20%) -> 78*0.20 = 15.6
3. Security: 8/10 vulns (weight 25%) -> 80*0.25 = 20
4. Reliability: 99.5% uptime (weight 20%) -> 99.5*0.20 = 19.9
5. Documentation: 75% (weight 10%) -> 75*0.10 = 7.5
Total: 20.5 + 15.6 + 20 + 19.9 + 7.5 = 83.5
Grade: A (90-100), B (80-89), C (70-79), D (60-69), F (<60)
Grade: B
How would you explain this to stakeholders?
context:
weights: "default"
include_grade: true
executive_summary: true
expected_output:
must_contain:
- "score"
- "grade"
- "quality"
- "weight"
- "coverage"
must_not_contain:
- "error"
- "invalid"
severity_classification: critical
validation:
schema_check: true
keyword_match_threshold: 0.8
- id: tc009_quality_trend_tracking
description: "Track quality score trends over time"
category: scoring
priority: high
input:
prompt: |
Track quality score trend:
- Week 1: 75 (C)
- Week 2: 77 (C)
- Week 3: 80 (B) - improvement!
- Week 4: 78 (C) - regression
Trend: Volatile, slightly improving
Next: Monitor closely, spike team focus
How would you alert on declining quality?
context:
trend_period: "4 weeks"
alert_triggers: true
expected_output:
must_contain:
- "trend"
- "score"
- "quality"
- "alert"
- "monitor"
finding_count:
min: 1
validation:
schema_check: true
keyword_match_threshold: 0.75
# ---------------------------------------------------------------------------
# CATEGORY: Quality Dashboard
# ---------------------------------------------------------------------------
- id: tc010_quality_dashboard_design
description: "Design comprehensive quality dashboard"
category: dashboard
priority: high
input:
prompt: |
Design quality dashboard showing:
1. Overall quality score (prominent)
2. Dimension breakdown (coverage, complexity, security, reliability)
3. Gate status (all gates, pass/fail)
4. Trend charts (30-day, 90-day)
5. Top issues (critical, high priority)
6. Deployment readiness
7. Team recommendations
What visualizations would be most useful?
context:
dashboard_scope: "comprehensive"
stakeholders: ["engineers", "managers", "executives"]
expected_output:
must_contain:
- "dashboard"
- "quality"
- "metric"
- "trend"
- "visualization"
finding_count:
min: 1
validation:
schema_check: true
allow_partial: true
# =============================================================================
# SUCCESS CRITERIA
# =============================================================================
success_criteria:
pass_rate: 0.8
critical_pass_rate: 1.0
avg_reasoning_quality: 0.75
max_execution_time_ms: 300000
cross_model_variance: 0.15
# =============================================================================
# METADATA
# =============================================================================
metadata:
author: "qe-quality-analyzer"
created: "2026-02-02"
last_updated: "2026-02-02"
coverage_target: >
Code complexity metrics (cyclomatic, cognitive, nesting), maintainability
index calculation, documentation coverage assessment, quality gates with
fail criteria and remediation guidance, deployment readiness evaluation with
pre-deployment risk identification, quality scoring with multi-factor
weighting and grading (A-F), trend analysis and alerting, and comprehensive
quality dashboards for all stakeholders.
{
"_description": "Quality assessment run history. Append after each run. Claude reads this to track quality gate pass/fail trends.",
"_format": "Each entry: {date, scope, gate_result, scores, failed_checks, recommendation}",
"_instructions": "After running quality assessment, append results here. Alert if quality gate fails 3 of last 5 runs. Track which checks fail most often.",
"runs": []
}
{
"$schema": "https://json-schema.org/draft/2020-12/schema",
"$id": "https://agentic-qe.dev/schemas/qe-quality-assessment-output.json",
"title": "AQE Quality Assessment Skill Output Schema",
"description": "Schema for quality assessment skill output validation. Includes quality gates, scores, trends, and risk assessment for deployment readiness.",
"type": "object",
"required": ["skillName", "version", "timestamp", "status", "trustTier", "output"],
"properties": {
"skillName": {
"type": "string",
"const": "qe-quality-assessment",
"description": "Must be 'qe-quality-assessment'"
},
"version": {
"type": "string",
"pattern": "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9]+)?$",
"description": "Semantic version of the skill"
},
"timestamp": {
"type": "string",
"format": "date-time",
"description": "ISO 8601 timestamp of output generation"
},
"status": {
"type": "string",
"enum": ["success", "partial", "failed", "skipped"],
"description": "Overall execution status"
},
"trustTier": {
"type": "integer",
"const": 3,
"description": "Trust tier 3 indicates full validation with eval suite"
},
"output": {
"type": "object",
"required": ["summary", "qualityGates", "scores"],
"properties": {
"summary": {
"type": "string",
"minLength": 50,
"maxLength": 2000,
"description": "Human-readable summary of quality assessment"
},
"qualityGates": {
"$ref": "#/$defs/qualityGates",
"description": "Quality gate evaluation results"
},
"scores": {
"$ref": "#/$defs/qualityScores",
"description": "Quality dimension scores"
},
"trends": {
"$ref": "#/$defs/qualityTrends",
"description": "Historical trends and comparison data"
},
"riskAssessment": {
"$ref": "#/$defs/riskAssessment",
"description": "Deployment risk assessment"
},
"recommendations": {
"type": "array",
"items": {
"$ref": "#/$defs/recommendation"
},
"maxItems": 50,
"description": "Prioritized quality improvement recommendations"
},
"metrics": {
"$ref": "#/$defs/qualityMetrics",
"description": "Detailed quality metrics"
},
"artifacts": {
"type": "array",
"items": {
"$ref": "#/$defs/artifact"
},
"maxItems": 20,
"description": "Generated quality reports and artifacts"
},
"deploymentReadiness": {
"$ref": "#/$defs/deploymentReadiness",
"description": "Deployment readiness evaluation"
}
}
},
"metadata": {
"$ref": "#/$defs/metadata"
},
"validation": {
"$ref": "#/$defs/validationResult"
},
"learning": {
"$ref": "#/$defs/learningData"
}
},
"$defs": {
"qualityGates": {
"type": "object",
"required": ["overallStatus", "gates"],
"properties": {
"overallStatus": {
"type": "string",
"enum": ["pass", "fail", "warn"],
"description": "Overall quality gate status"
},
"gates": {
"type": "array",
"items": {
"$ref": "#/$defs/qualityGate"
},
"minItems": 1,
"description": "Individual gate evaluations"
},
"blocking": {
"type": "array",
"items": {
"type": "string"
},
"description": "Names of gates that are blocking"
}
}
},
"qualityGate": {
"type": "object",
"required": ["name", "status", "value", "threshold"],
"properties": {
"name": {
"type": "string",
"minLength": 1,
"maxLength": 100,
"description": "Gate name (e.g., coverage, complexity, vulnerabilities)"
},
"status": {
"type": "string",
"enum": ["pass", "fail", "warn", "skip"],
"description": "Gate status"
},
"value": {
"type": "number",
"description": "Actual measured value"
},
"threshold": {
"type": "number",
"description": "Threshold for pass/fail"
},
"operator": {
"type": "string",
"enum": [">=", "<=", ">", "<", "=="],
"default": ">=",
"description": "Comparison operator"
},
"blocking": {
"type": "boolean",
"default": false,
"description": "Whether this gate blocks deployment"
},
"description": {
"type": "string",
"description": "Gate description"
}
}
},
"qualityScores": {
"type": "object",
"required": ["overall"],
"properties": {
"overall": {
"$ref": "#/$defs/scoreValue",
"description": "Overall quality score"
},
"testCoverage": {
"$ref": "#/$defs/scoreValue",
"description": "Test coverage score"
},
"codeQuality": {
"$ref": "#/$defs/scoreValue",
"description": "Code quality score"
},
"security": {
"$ref": "#/$defs/scoreValue",
"description": "Security score"
},
"reliability": {
"$ref": "#/$defs/scoreValue",
"description": "Reliability score"
},
"maintainability": {
"$ref": "#/$defs/scoreValue",
"description": "Maintainability score"
},
"documentation": {
"$ref": "#/$defs/scoreValue",
"description": "Documentation score"
},
"performance": {
"$ref": "#/$defs/scoreValue",
"description": "Performance score"
}
}
},
"scoreValue": {
"type": "object",
"required": ["value", "max"],
"properties": {
"value": {
"type": "number",
"minimum": 0,
"maximum": 100,
"description": "Score value (0-100)"
},
"max": {
"type": "number",
"const": 100
},
"grade": {
"type": "string",
"pattern": "^[A-F][+-]?$",
"description": "Letter grade"
},
"weight": {
"type": "number",
"minimum": 0,
"maximum": 1,
"description": "Weight in overall score"
}
}
},
"qualityTrends": {
"type": "object",
"properties": {
"direction": {
"type": "string",
"enum": ["improving", "stable", "declining", "unknown"],
"description": "Overall trend direction"
},
"comparison": {
"type": "object",
"properties": {
"previousScore": {
"type": "number",
"minimum": 0,
"maximum": 100
},
"currentScore": {
"type": "number",
"minimum": 0,
"maximum": 100
},
"delta": {
"type": "number",
"description": "Score change"
},
"period": {
"type": "string",
"description": "Comparison period"
}
}
},
"history": {
"type": "array",
"items": {
"type": "object",
"properties": {
"timestamp": {
"type": "string",
"format": "date-time"
},
"score": {
"type": "number",
"minimum": 0,
"maximum": 100
}
}
},
"maxItems": 30,
"description": "Historical scores"
},
"alerts": {
"type": "array",
"items": {
"type": "string"
},
"description": "Trend-related alerts"
}
}
},
"riskAssessment": {
"type": "object",
"required": ["level"],
"properties": {
"level": {
"type": "string",
"enum": ["critical", "high", "medium", "low", "minimal"],
"description": "Overall risk level"
},
"score": {
"type": "number",
"minimum": 0,
"maximum": 100,
"description": "Risk score (0=minimal, 100=critical)"
},
"factors": {
"type": "array",
"items": {
"$ref": "#/$defs/riskFactor"
},
"description": "Risk factors identified"
},
"mitigations": {
"type": "array",
"items": {
"type": "string"
},
"description": "Recommended risk mitigations"
}
}
},
"riskFactor": {
"type": "object",
"required": ["name", "severity"],
"properties": {
"name": {
"type": "string",
"description": "Risk factor name"
},
"severity": {
"type": "string",
"enum": ["critical", "high", "medium", "low"],
"description": "Severity level"
},
"description": {
"type": "string",
"description": "Risk description"
},
"impact": {
"type": "string",
"description": "Potential impact"
}
}
},
"recommendation": {
"type": "object",
"required": ["id", "title", "priority"],
"properties": {
"id": {
"type": "string",
"pattern": "^REC-\\d{3,6}$",
"description": "Recommendation ID"
},
"title": {
"type": "string",
"minLength": 10,
"maxLength": 200
},
"description": {
"type": "string",
"maxLength": 2000
},
"priority": {
"type": "string",
"enum": ["critical", "high", "medium", "low"]
},
"effort": {
"type": "string",
"enum": ["trivial", "low", "medium", "high", "major"]
},
"impact": {
"type": "integer",
"minimum": 1,
"maximum": 10,
"description": "Expected quality impact (1-10)"
},
"category": {
"type": "string",
"description": "Quality dimension affected"
}
}
},
"qualityMetrics": {
"type": "object",
"properties": {
"coverage": {
"type": "object",
"properties": {
"statement": { "type": "number", "minimum": 0, "maximum": 100 },
"branch": { "type": "number", "minimum": 0, "maximum": 100 },
"function": { "type": "number", "minimum": 0, "maximum": 100 },
"line": { "type": "number", "minimum": 0, "maximum": 100 }
}
},
"complexity": {
"type": "object",
"properties": {
"cyclomaticAvg": { "type": "number", "minimum": 0 },
"cyclomaticMax": { "type": "number", "minimum": 0 },
"cognitiveAvg": { "type": "number", "minimum": 0 },
"cognitiveMax": { "type": "number", "minimum": 0 }
}
},
"maintainability": {
"type": "object",
"properties": {
"index": { "type": "number", "minimum": 0, "maximum": 100 },
"duplication": { "type": "number", "minimum": 0, "maximum": 100 },
"techDebtRatio": { "type": "number", "minimum": 0 }
}
},
"issues": {
"type": "object",
"properties": {
"bugs": { "type": "integer", "minimum": 0 },
"vulnerabilities": { "type": "integer", "minimum": 0 },
"codeSmells": { "type": "integer", "minimum": 0 },
"securityHotspots": { "type": "integer", "minimum": 0 }
}
},
"filesAnalyzed": {
"type": "integer",
"minimum": 0
},
"linesOfCode": {
"type": "integer",
"minimum": 0
}
}
},
"deploymentReadiness": {
"type": "object",
"required": ["status", "recommendation"],
"properties": {
"status": {
"type": "string",
"enum": ["go", "conditional", "no-go"],
"description": "Deployment recommendation"
},
"recommendation": {
"type": "string",
"description": "Deployment recommendation details"
},
"criteria": {
"type": "object",
"properties": {
"testsPass": { "type": "boolean" },
"coverageMet": { "type": "boolean" },
"noVulnerabilities": { "type": "boolean" },
"performanceOk": { "type": "boolean" },
"documentationComplete": { "type": "boolean" }
}
},
"blockers": {
"type": "array",
"items": { "type": "string" },
"description": "Blocking issues"
}
}
},
"artifact": {
"type": "object",
"required": ["type", "path"],
"properties": {
"type": {
"type": "string",
"enum": ["report", "dashboard", "data", "log"]
},
"path": {
"type": "string",
"maxLength": 500
},
"format": {
"type": "string",
"enum": ["json", "html", "md", "txt", "csv"]
},
"description": {
"type": "string",
"maxLength": 500
}
}
},
"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-]*$"
},
"targetPath": {
"type": "string"
},
"environment": {
"type": "string",
"enum": ["development", "staging", "production", "ci"]
}
}
},
"validationResult": {
"type": "object",
"properties": {
"schemaValid": { "type": "boolean" },
"contentValid": { "type": "boolean" },
"confidence": { "type": "number", "minimum": 0, "maximum": 1 },
"warnings": {
"type": "array",
"items": { "type": "string" },
"maxItems": 20
},
"errors": {
"type": "array",
"items": { "type": "string" },
"maxItems": 20
}
}
},
"learningData": {
"type": "object",
"properties": {
"patternsDetected": {
"type": "array",
"items": { "type": "string" },
"maxItems": 20
},
"reward": {
"type": "number",
"minimum": 0,
"maximum": 1
},
"qualityPatterns": {
"type": "array",
"items": {
"type": "object",
"properties": {
"pattern": { "type": "string" },
"frequency": { "type": "integer" },
"impact": { "type": "string" }
}
}
}
}
}
}
}
{
"skillName": "qe-quality-assessment",
"skillVersion": "1.0.0",
"requiredTools": [
"jq"
],
"optionalTools": [
"ajv",
"jsonschema",
"python3"
],
"schemaPath": "schemas/output.json",
"requiredFields": [
"skillName",
"status",
"output",
"output.summary",
"output.qualityGates",
"output.scores"
],
"requiredNonEmptyFields": [
"output.summary"
],
"mustContainTerms": [
"quality",
"score",
"gate"
],
"mustNotContainTerms": [
"TODO",
"placeholder",
"FIXME"
],
"enumValidations": {
".status": [
"success",
"partial",
"failed",
"skipped"
],
".output.qualityGates.overallStatus": [
"pass",
"fail",
"warn"
]
}
}
Related skills
FAQ
What does qe quality assessment do?
qe quality assessment is a Claude Code skill for ai & agent building.
When should I use qe quality assessment?
When you need to helps with ai & agent building tasks., or when qe quality assessment is a claude code skill for ai & agent building.
What are the main capabilities?
qe quality assessment; AI & Agent Building; AI-coding skill.