
Qe Defect Intelligence
- 31 installs
- 433 repo stars
- Updated August 4, 2026
- proffesor-for-testing/agentic-qe
qe defect intelligence is a Claude Code skill for ai & agent building.
About
qe defect intelligence is a Claude Code skill for ai & agent building. It helps solo builders move faster with AI-assisted development.
- qe defect intelligence
- AI & Agent Building
- AI-coding skill
Qe Defect Intelligence by the numbers
- 31 all-time installs (skills.sh)
- Ranked #9,165 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-defect-intelligenceAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 31 |
|---|---|
| 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 defect intelligence.
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 defect intelligence is a claude code skill for ai & agent building.
What you get
Structured output aligned to qe defect intelligence: qe defect intelligence, AI & Agent Building.
Files
QE Defect Intelligence
Purpose
Guide the use of v3's defect intelligence capabilities including ML-based defect prediction, pattern recognition from historical data, and automated root cause analysis.
Activation
- When predicting defect-prone code
- When analyzing failure patterns
- When performing root cause analysis
- When learning from past defects
- When prioritizing testing based on risk
Quick Start
# Predict defects in changed code
aqe defect predict --changes HEAD~5..HEAD
# Analyze failure patterns
aqe defect patterns --period 90d --min-occurrences 3
# Root cause analysis
aqe defect rca --failure "test/auth.test.ts:45"
# Learn from resolved defects
aqe defect learn --source jira --status resolvedAgent Workflow
// Defect prediction
Task("Predict defect-prone code", `
Analyze PR #456 changes and predict defect likelihood:
- Historical defect correlation
- Code complexity factors
- Author experience with module
- Test coverage gaps
Flag high-risk changes requiring extra review.
`, "qe-defect-predictor")
// Root cause analysis
Task("Analyze test failure", `
Investigate recurring failure in AuthService tests:
- Collect failure history (last 30 days)
- Identify common patterns
- Trace to potential root causes
- Suggest fixes using 5-whys analysis
`, "qe-root-cause-analyzer")Prediction Models
1. Change-Based Prediction
await defectPredictor.predictFromChanges({
changes: prChanges,
factors: {
codeChurn: { weight: 0.2 },
complexity: { weight: 0.25 },
authorExperience: { weight: 0.15 },
fileHistory: { weight: 0.2 },
testCoverage: { weight: 0.2 }
},
threshold: {
high: 0.7,
medium: 0.4,
low: 0.2
}
});2. Pattern Learning
await patternLearner.learnPatterns({
source: {
defects: 'jira:project=MYAPP&type=bug',
commits: 'git:last-6-months',
tests: 'test-results:last-1000-runs'
},
patterns: [
'code-smell-to-defect',
'change-coupling',
'test-gap-correlation',
'complexity-defect-density'
],
output: {
rules: true,
visualizations: true,
recommendations: true
}
});3. Root Cause Analysis
await rootCauseAnalyzer.analyze({
failure: testFailure,
methods: [
'five-whys',
'fishbone-diagram',
'fault-tree',
'change-impact'
],
context: {
recentChanges: true,
environmentDiff: true,
dependencyChanges: true,
similarFailures: true
}
});Defect Prediction Report
interface DefectPrediction {
file: string;
riskScore: number; // 0-1
riskLevel: 'critical' | 'high' | 'medium' | 'low';
factors: {
name: string;
contribution: number;
details: string;
}[];
historicalDefects: {
count: number;
recent: Defect[];
patterns: string[];
};
recommendations: {
action: string;
priority: string;
expectedRiskReduction: number;
}[];
}Pattern Categories
| Pattern | Detection | Prevention |
|---|---|---|
| Null pointer | Static analysis | Null checks, Optional |
| Race condition | Concurrency analysis | Locks, atomic ops |
| Memory leak | Heap analysis | Resource cleanup |
| Off-by-one | Boundary analysis | Loop invariants |
| Injection | Taint analysis | Input validation |
Root Cause Templates
root_cause_analysis:
five_whys:
max_depth: 5
prompt_template: "Why did {effect} happen?"
fishbone:
categories:
- people
- process
- tools
- environment
- materials
- measurement
fault_tree:
top_event: "Test Failure"
gate_types: [AND, OR, NOT]
basic_events: trueIntegration with Issue Tracking
await defectIntelligence.syncWithTracker({
source: 'jira',
project: 'MYAPP',
sync: {
defectData: 'bidirectional',
predictions: 'create-tasks',
patterns: 'update-labels'
},
automation: {
flagHighRisk: true,
suggestAssignee: true,
linkRelated: true
}
});Coordination
Primary Agents: qe-defect-predictor, qe-pattern-learner, qe-root-cause-analyzer Coordinator: qe-defect-intelligence-coordinator Related Skills: qe-coverage-analysis, qe-quality-assessment
# =============================================================================
# AQE Skill Evaluation Test Suite: QE Defect Intelligence v1.0.0
# =============================================================================
#
# Comprehensive evaluation suite for the qe-defect-intelligence skill.
# Tests ML-based defect prediction, pattern learning from historical data,
# root cause analysis, and proactive quality management.
#
# Schema: .claude/skills/.validation/schemas/skill-eval.schema.json
# Validator: .claude/skills/qe-defect-intelligence/scripts/validate-config.json
#
# Coverage:
# - Change-based defect prediction
# - Pattern learning from defect history
# - Root cause analysis (5-whys, fishbone, fault tree)
# - Failure pattern detection
# - Risk scoring and prioritization
#
# =============================================================================
skill: qe-defect-intelligence
version: 1.0.0
description: >
Comprehensive evaluation suite for the qe-defect-intelligence skill.
Tests AI-powered defect prediction, pattern learning from historical data,
root cause analysis using multiple methodologies, failure pattern detection,
and proactive quality management with risk scoring.
# =============================================================================
# Multi-Model Configuration
# =============================================================================
models_to_test:
- claude-opus-4-8 # Capability ceiling (high-stakes skill)
- 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-defect-predictor
- qe-root-cause-analyzer
# =============================================================================
# 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:
DEFECT_PREDICTION_MODEL: "ml"
PATTERN_LEARNING_ENABLED: "true"
RCA_DEPTH: "5"
fixtures: []
# =============================================================================
# TEST CASES
# =============================================================================
test_cases:
# ---------------------------------------------------------------------------
# CATEGORY: Defect Prediction
# ---------------------------------------------------------------------------
- id: tc001_change_based_defect_prediction
description: "Predict defect likelihood from code changes"
category: prediction
priority: critical
input:
prompt: |
Predict defects in PR #456 changes using:
1. Code churn (weight: 0.2) - how much code changed
2. Complexity (weight: 0.25) - cyclomatic complexity
3. Author experience (weight: 0.15) - familiar with module?
4. File history (weight: 0.2) - past defects in file
5. Test coverage gaps (weight: 0.2) - uncovered changes
For each high-risk change, assign risk score 0-1.
Which would you flag for extra review?
context:
pr_number: 456
factors: "all"
threshold_high: 0.7
threshold_medium: 0.4
expected_output:
must_contain:
- "defect"
- "predict"
- "risk"
- "score"
- "churn"
- "complexity"
must_not_contain:
- "certain"
- "will fail"
severity_classification: critical
finding_count:
min: 1
validation:
schema_check: true
keyword_match_threshold: 0.8
reasoning_quality_min: 0.75
- id: tc002_defect_risk_scoring
description: "Score defect risk across multiple factors"
category: prediction
priority: critical
input:
prompt: |
Score defect risk for modified PaymentService:
- Complexity: cyclomatic 18 (high: > 10)
- Change frequency: modified 8 times in 90 days (high)
- Bug history: 3 bugs in file past 180 days (concerning)
- Test coverage: 65% (below 85% target)
- Author experience: first-time modifier (unfamiliar)
Calculate overall risk score and recommend actions.
context:
factors_detailed: true
recommendations: true
expected_output:
must_contain:
- "risk"
- "score"
- "high"
- "complexity"
- "coverage"
- "recommend"
must_not_contain:
- "low risk"
- "unlikely"
severity_classification: critical
validation:
schema_check: true
keyword_match_threshold: 0.8
# ---------------------------------------------------------------------------
# CATEGORY: Pattern Learning
# ---------------------------------------------------------------------------
- id: tc003_defect_pattern_learning
description: "Learn patterns from historical defect data"
category: patterns
priority: critical
input:
prompt: |
Learn patterns from past 6 months of defects:
1. Code-smell-to-defect correlation (e.g., long methods)
2. Change coupling patterns (e.g., changes to A, B, C together)
3. Test gap correlation (files with < 60% coverage)
4. Complexity defect density (high complexity -> more bugs)
5. File age patterns (older files more stable)
What patterns would reduce future defects?
context:
defects: "jira:past-6-months"
patterns: "all"
output: "rules_and_recommendations"
expected_output:
must_contain:
- "pattern"
- "learn"
- "correlation"
- "defect"
- "rule"
must_not_contain:
- "no patterns"
- "random"
severity_classification: critical
validation:
schema_check: true
keyword_match_threshold: 0.8
reasoning_quality_min: 0.75
- id: tc004_similar_failure_detection
description: "Find similar failures in history to predict patterns"
category: patterns
priority: high
input:
prompt: |
Test failure: "AuthService.login() timeout in production"
Search history for:
1. Same module failures
2. Same error type (timeout)
3. Same time window (peak traffic hours)
4. Same root causes
5. Resolutions that worked
How would you help prevent recurrence?
context:
failure_analysis: true
history_window: "90d"
expected_output:
must_contain:
- "similar"
- "failure"
- "pattern"
- "history"
- "root cause"
finding_count:
min: 1
validation:
schema_check: true
keyword_match_threshold: 0.75
# ---------------------------------------------------------------------------
# CATEGORY: Root Cause Analysis
# ---------------------------------------------------------------------------
- id: tc005_five_whys_analysis
description: "Perform 5-whys root cause analysis"
category: rca
priority: critical
input:
prompt: |
Apply 5-whys for test failure:
"UserService.getById() returns null for valid ID"
1. Why does it return null?
- Because query returns no rows
2. Why does query return no rows?
- Because ID was not saved to database
3. Why was ID not saved?
- Because transaction rolled back
4. Why did transaction rollback?
- Because timeout on DB connection
5. Why is timeout occurring?
- Because connection pool exhausted
ROOT CAUSE: Connection pool misconfiguration
What's the fix?
context:
method: "five-whys"
depth: 5
expected_output:
must_contain:
- "why"
- "root cause"
- "transaction"
- "fix"
- "connection"
must_not_contain:
- "unclear"
- "unknown"
severity_classification: critical
validation:
schema_check: true
keyword_match_threshold: 0.8
reasoning_quality_min: 0.75
- id: tc006_fishbone_diagram_analysis
description: "Use fishbone (Ishikawa) analysis for RCA"
category: rca
priority: high
input:
prompt: |
Organize RCA using fishbone with categories:
- PEOPLE: Lack of training, new team member
- PROCESS: Missing validation, no error handling
- TOOLS: Outdated logger, missing monitoring
- ENVIRONMENT: Wrong config, insufficient resources
- MATERIALS: Bad test data, missing mocks
- MEASUREMENT: No metrics for this code path
For test failures in authentication, what causes in each category?
context:
categories: ["people", "process", "tools", "environment", "materials", "measurement"]
problem: "authentication_failures"
expected_output:
must_contain:
- "fishbone"
- "people"
- "process"
- "tools"
- "environment"
finding_count:
min: 1
validation:
schema_check: true
keyword_match_threshold: 0.75
- id: tc007_fault_tree_analysis
description: "Build fault tree for system failures"
category: rca
priority: high
input:
prompt: |
Build fault tree for "Login Service Unavailable":
Top Event: Login Service Unavailable
Intermediate Events:
- Database Down OR
- API Timeout OR
- Authentication Failed
Basic Events:
- DB connection lost, DB queries slow
- Network latency, service crashed
- Invalid credentials, expired token
How would you use this to prevent failures?
context:
top_event: "login_unavailable"
gate_types: ["AND", "OR", "NOT"]
expected_output:
must_contain:
- "fault tree"
- "event"
- "basic"
- "gate"
- "prevent"
severity_classification: high
validation:
schema_check: true
keyword_match_threshold: 0.75
# ---------------------------------------------------------------------------
# CATEGORY: Failure Pattern Recognition
# ---------------------------------------------------------------------------
- id: tc008_flaky_test_pattern_detection
description: "Identify patterns in flaky test failures"
category: patterns
priority: high
input:
prompt: |
Analyze flaky test: "UserService.getById() flakes 15% of time"
Patterns to investigate:
1. Time-based: Fails at night? During peak load?
2. Data-based: Fails with certain test data?
3. Resource-based: Fails when CPU > 80%?
4. External service: Fails when API times out?
5. Concurrency: Fails in parallel execution?
How would you stabilize this test?
context:
flaky_test: "UserService.getById()"
failure_rate: 0.15
expected_output:
must_contain:
- "pattern"
- "flaky"
- "investigate"
- "stabilize"
- "correlation"
finding_count:
min: 1
validation:
schema_check: true
keyword_match_threshold: 0.75
- id: tc009_regression_pattern_analysis
description: "Identify patterns in regression failures"
category: patterns
priority: high
input:
prompt: |
Analyze regression: "Checkout flow broke after authentication refactor"
Questions:
1. Which checkout modules depend on auth?
2. What changed in auth API?
3. Are there version mismatches?
4. Were integration tests skipped?
5. Was there compatibility testing?
How would you have caught this earlier?
context:
regression_type: "integration"
trigger_change: "auth_refactor"
expected_output:
must_contain:
- "regression"
- "pattern"
- "dependencies"
- "integration"
- "compatibility"
severity_classification: high
validation:
schema_check: true
keyword_match_threshold: 0.75
# ---------------------------------------------------------------------------
# CATEGORY: Negative Tests
# ---------------------------------------------------------------------------
- id: tc010_defect_prevention_strategy
description: "Design strategy to prevent predicted defects"
category: prevention
priority: high
input:
prompt: |
For high-risk changes, recommend:
1. Additional code review checkpoints
2. Extra testing (unit, integration, e2e)
3. Staging environment validation
4. Monitoring/alerting plan
5. Rollback strategy
6. Documentation updates
How would you implement this in CI/CD?
context:
high_risk_detected: true
prevention_focus: true
expected_output:
must_contain:
- "prevent"
- "review"
- "test"
- "monitor"
- "strategy"
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-defect-predictor"
created: "2026-02-02"
last_updated: "2026-02-02"
coverage_target: >
Change-based defect prediction with multi-factor risk scoring,
pattern learning from historical defect data, root cause analysis
using 5-whys/fishbone/fault-tree methods, failure pattern detection,
flaky test and regression analysis, and comprehensive defect prevention
strategies integrated into CI/CD.
{
"$schema": "http://json-schema.org/draft-07/schema#",
"$id": "https://agentic-qe.dev/schemas/skills/qe-defect-intelligence/output.json",
"title": "QE Defect Intelligence Skill Output Schema",
"description": "Schema for qe-defect-intelligence skill output with predictions, patterns, and defect clusters.",
"type": "object",
"required": ["skillName", "version", "timestamp", "status", "trustTier", "output"],
"properties": {
"skillName": {
"type": "string",
"const": "qe-defect-intelligence"
},
"version": {
"type": "string",
"pattern": "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9]+)?$"
},
"timestamp": {
"type": "string"
},
"status": {
"type": "string",
"enum": ["success", "partial", "failed", "skipped"]
},
"trustTier": {
"type": "integer",
"const": 3
},
"output": {
"type": "object",
"required": ["summary", "predictions", "riskScore"],
"properties": {
"summary": {
"type": "string",
"minLength": 50,
"maxLength": 2000,
"description": "Human-readable summary of defect intelligence analysis"
},
"predictions": {
"type": "array",
"items": {
"$ref": "#/$defs/defectPrediction"
},
"minItems": 1,
"maxItems": 200,
"description": "Predicted defect-prone areas"
},
"patterns": {
"type": "array",
"items": {
"$ref": "#/$defs/defectPattern"
},
"maxItems": 100,
"description": "Identified defect patterns"
},
"clusters": {
"type": "array",
"items": {
"$ref": "#/$defs/defectCluster"
},
"maxItems": 50,
"description": "Defect clusters by category or location"
},
"riskScore": {
"$ref": "#/$defs/riskScore",
"description": "Overall defect risk score"
},
"rootCauses": {
"type": "array",
"items": {
"$ref": "#/$defs/rootCause"
},
"maxItems": 50
},
"findings": {
"type": "array",
"items": {
"$ref": "#/$defs/finding"
},
"maxItems": 200
},
"recommendations": {
"type": "array",
"items": {
"$ref": "#/$defs/recommendation"
},
"maxItems": 50
},
"metrics": {
"$ref": "#/$defs/defectMetrics"
}
}
},
"metadata": {
"type": "object",
"properties": {
"executionTimeMs": { "type": "integer", "minimum": 0 },
"toolsUsed": { "type": "array", "items": { "type": "string" } },
"agentId": { "type": "string" },
"analyzedCommits": { "type": "integer", "minimum": 0 },
"analyzedDefects": { "type": "integer", "minimum": 0 },
"modelVersion": { "type": "string" }
}
},
"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": {
"defectPrediction": {
"type": "object",
"required": ["id", "location", "probability"],
"properties": {
"id": { "type": "string", "pattern": "^PRED-\\d{3,6}$" },
"location": {
"type": "object",
"required": ["file"],
"properties": {
"file": { "type": "string" },
"startLine": { "type": "integer", "minimum": 1 },
"endLine": { "type": "integer", "minimum": 1 },
"function": { "type": "string" },
"module": { "type": "string" }
}
},
"probability": { "type": "number", "minimum": 0, "maximum": 1 },
"confidence": { "type": "number", "minimum": 0, "maximum": 1 },
"severity": { "type": "string", "enum": ["critical", "high", "medium", "low"] },
"defectType": { "type": "string", "enum": ["logic-error", "null-pointer", "race-condition", "resource-leak", "security-flaw", "performance-issue", "boundary-error", "type-error"] },
"features": {
"type": "array",
"items": {
"type": "object",
"properties": {
"name": { "type": "string" },
"value": { "type": "number" },
"importance": { "type": "number", "minimum": 0, "maximum": 1 }
}
}
},
"explanation": { "type": "string", "maxLength": 1000 }
}
},
"defectPattern": {
"type": "object",
"required": ["id", "name", "frequency"],
"properties": {
"id": { "type": "string", "pattern": "^PATT-\\d{3,6}$" },
"name": { "type": "string", "minLength": 5, "maxLength": 200 },
"description": { "type": "string", "maxLength": 1000 },
"frequency": { "type": "integer", "minimum": 1 },
"category": { "type": "string", "enum": ["code-smell", "anti-pattern", "security-weakness", "performance-bottleneck", "maintainability-debt"] },
"instances": {
"type": "array",
"items": {
"type": "object",
"properties": {
"file": { "type": "string" },
"line": { "type": "integer" },
"snippet": { "type": "string" }
}
},
"maxItems": 20
},
"remediation": { "type": "string", "maxLength": 2000 },
"cwe": { "type": "string", "pattern": "^CWE-\\d{1,4}$" }
}
},
"defectCluster": {
"type": "object",
"required": ["id", "name", "defectCount"],
"properties": {
"id": { "type": "string", "pattern": "^CLUS-\\d{3,6}$" },
"name": { "type": "string", "maxLength": 200 },
"type": { "type": "string", "enum": ["spatial", "temporal", "categorical", "author-based", "module-based"] },
"defectCount": { "type": "integer", "minimum": 1 },
"centroid": {
"type": "object",
"properties": {
"file": { "type": "string" },
"module": { "type": "string" }
}
},
"members": {
"type": "array",
"items": { "type": "string" },
"description": "IDs of defects/predictions in this cluster"
},
"commonFactors": {
"type": "array",
"items": { "type": "string" }
},
"riskLevel": { "type": "string", "enum": ["critical", "high", "medium", "low"] }
}
},
"riskScore": {
"type": "object",
"required": ["value", "max"],
"properties": {
"value": { "type": "number", "minimum": 0, "maximum": 100 },
"max": { "type": "number", "const": 100 },
"grade": { "type": "string", "pattern": "^[A-F][+-]?$" },
"trend": { "type": "string", "enum": ["improving", "stable", "declining", "unknown"] },
"breakdown": {
"type": "object",
"properties": {
"codeComplexity": { "type": "number", "minimum": 0, "maximum": 100 },
"changeVelocity": { "type": "number", "minimum": 0, "maximum": 100 },
"historicalDefects": { "type": "number", "minimum": 0, "maximum": 100 },
"testCoverage": { "type": "number", "minimum": 0, "maximum": 100 }
}
}
}
},
"rootCause": {
"type": "object",
"required": ["id", "category", "frequency"],
"properties": {
"id": { "type": "string", "pattern": "^ROOT-\\d{3,6}$" },
"category": { "type": "string", "enum": ["requirements", "design", "implementation", "testing", "deployment", "environment"] },
"description": { "type": "string", "maxLength": 1000 },
"frequency": { "type": "integer", "minimum": 1 },
"affectedDefects": { "type": "array", "items": { "type": "string" } },
"preventiveMeasures": { "type": "array", "items": { "type": "string" } }
}
},
"finding": {
"type": "object",
"required": ["id", "title", "severity"],
"properties": {
"id": { "type": "string", "pattern": "^DEF-\\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": ["high-risk-area", "pattern-violation", "trend-concern", "cluster-alert", "prediction-alert"] },
"location": {
"type": "object",
"properties": {
"file": { "type": "string" },
"line": { "type": "integer" }
}
},
"remediation": { "type": "string", "maxLength": 2000 }
}
},
"recommendation": {
"type": "object",
"required": ["id", "title", "priority"],
"properties": {
"id": { "type": "string", "pattern": "^REC-\\d{3,6}$" },
"title": { "type": "string", "maxLength": 200 },
"description": { "type": "string", "maxLength": 2000 },
"priority": { "type": "string", "enum": ["critical", "high", "medium", "low"] },
"effort": { "type": "string", "enum": ["trivial", "low", "medium", "high", "major"] },
"expectedRiskReduction": { "type": "number", "minimum": 0, "maximum": 100 }
}
},
"defectMetrics": {
"type": "object",
"properties": {
"totalPredictions": { "type": "integer", "minimum": 0 },
"highRiskCount": { "type": "integer", "minimum": 0 },
"patternsFound": { "type": "integer", "minimum": 0 },
"clustersIdentified": { "type": "integer", "minimum": 0 },
"modelAccuracy": { "type": "number", "minimum": 0, "maximum": 1 },
"precision": { "type": "number", "minimum": 0, "maximum": 1 },
"recall": { "type": "number", "minimum": 0, "maximum": 1 },
"f1Score": { "type": "number", "minimum": 0, "maximum": 1 }
}
}
}
}
{
"skillName": "qe-defect-intelligence",
"skillVersion": "1.0.0",
"requiredTools": [
"jq"
],
"optionalTools": [
"python3"
],
"schemaPath": "schemas/output.json",
"requiredFields": [
"skillName",
"status",
"output",
"output.summary",
"output.predictions",
"output.riskScore"
],
"requiredNonEmptyFields": [
"output.summary"
],
"mustContainTerms": [
"defect",
"prediction",
"risk"
],
"mustNotContainTerms": [
"TODO",
"FIXME",
"placeholder"
],
"enumValidations": {
".status": [
"success",
"partial",
"failed",
"skipped"
]
}
}
Related skills
FAQ
What does qe defect intelligence do?
qe defect intelligence is a Claude Code skill for ai & agent building.
When should I use qe defect intelligence?
When you need to helps with ai & agent building tasks., or when qe defect intelligence is a claude code skill for ai & agent building.
What are the main capabilities?
qe defect intelligence; AI & Agent Building; AI-coding skill.