code-quality-monitor

Proactive code health monitoring and quality gate enforcement. Use when validating code changes, reviewing PRs, or ensuring code meets quality standards before merging.

⭐2stars🔀0forks📁View on GitHub🕐Updated Jan 4, 2026⬇️1downloads

When & Why to Use This Skill

The Code Quality Monitor is a proactive agentic skill designed to automate code health monitoring and enforce rigorous quality gates. It ensures software reliability by tracking critical metrics such as test coverage, cyclomatic complexity, and security vulnerabilities across Python and TypeScript environments. By integrating seamlessly into PR reviews and pre-commit workflows, it prevents technical debt and ensures that only high-standard code reaches production.

Use Cases

  • Automated Quality Gate Enforcement: Automatically blocking or flagging pull requests that fail to meet specific thresholds for test coverage, type safety, or security standards.
  • Pre-commit Health Checks: Running localized validation scripts (linting, formatting, and quick tests) to ensure developers catch errors before committing code to the repository.
  • Technical Debt Prevention: Monitoring code complexity and file lengths to identify refactoring needs and prevent the codebase from becoming unmanageable.
  • Security and Dependency Auditing: Utilizing tools like Bandit and pip-audit to proactively scan for vulnerabilities and insecure dependencies during the development lifecycle.
  • Cross-Stack Quality Reporting: Generating comprehensive health reports for both Python backends and TypeScript frontends, providing a unified view of project health.
namecode-quality-monitor
descriptionProactive code health monitoring and quality gate enforcement. Use when validating code changes, reviewing PRs, or ensuring code meets quality standards before merging.
model_tiersonnet
can_parallel_with[lint-monorepo, test-writer, coverage-reporter]
must_serialize_with[]
preferred_batch_size5
max_file_context50
compression_level1
requires_git_contexttrue
requires_db_contextfalse
- pattern"security.*critical"
reason"Architectural concerns need human review"
- keyword["architectural", "breaking"]

Code Quality Monitor

A proactive health checker that monitors code quality and enforces strict standards.

When This Skill Activates

  • Before committing changes
  • During PR reviews
  • When validating code health
  • After making multiple edits
  • When user asks about code quality

Quality Standards

Python Backend Standards

Metric Target Critical Threshold
Test Coverage >= 80% >= 70%
Type Coverage 100% public APIs >= 90%
Cyclomatic Complexity <= 10 <= 15
Function Length <= 50 lines <= 100 lines
File Length <= 500 lines <= 800 lines

TypeScript Frontend Standards

Metric Target Critical Threshold
Type Safety No any < 5 any uses
Test Coverage >= 75% >= 60%
Component Size <= 200 lines <= 300 lines
Hook Complexity <= 5 dependencies <= 8 dependencies

Health Check Commands

Quick Health Check

cd /home/user/Autonomous-Assignment-Program-Manager/backend

# Run all quality checks
pytest --tb=no -q && \
ruff check app/ tests/ && \
black --check app/ tests/ && \
mypy app/ --python-version 3.11 --no-error-summary

echo "Backend health: PASS"

Comprehensive Health Check

cd /home/user/Autonomous-Assignment-Program-Manager/backend

# Coverage report
pytest --cov=app --cov-report=term-missing --cov-fail-under=70

# Complexity analysis
radon cc app/ -a -s

# Security scan
bandit -r app/ -ll

# Dependency check
pip-audit

Frontend Health Check

cd /home/user/Autonomous-Assignment-Program-Manager/frontend

npm run type-check && \
npm run lint && \
npm test -- --coverage --watchAll=false

echo "Frontend health: PASS"

Quality Gate Rules

Gate 1: Must Pass (Blocking)

  • All tests pass
  • No linting errors
  • No type errors
  • No critical security issues

Gate 2: Should Pass (Warning)

  • Coverage >= 70%
  • No new complexity issues
  • Documentation updated
  • No TODOs without tickets

Gate 3: Nice to Have (Info)

  • Coverage >= 80%
  • All functions documented
  • No magic numbers
  • Consistent naming

Monitoring Workflow

Pre-Commit Check

Before committing, validate:

#!/bin/bash
set -e

echo "Running pre-commit checks..."

# Format
black app/ tests/

# Lint
ruff check app/ tests/ --fix

# Type check
mypy app/ --python-version 3.11

# Quick tests
pytest --tb=no -q --lf

echo "Pre-commit checks: PASS"

PR Validation Check

For pull request reviews:

#!/bin/bash
set -e

echo "Running PR validation..."

# Full test suite with coverage
pytest --cov=app --cov-report=term-missing

# Security scan
bandit -r app/ -ll

# Check for common issues
ruff check app/ tests/

# Type coverage
mypy app/ --python-version 3.11

echo "PR validation: PASS"

Red Flags to Watch For

Immediate Action Required

  1. Test coverage dropped below 70%
  2. New security vulnerability detected
  3. Type errors in public APIs
  4. Breaking changes without migration

Needs Attention

  1. Coverage trending down
  2. Increasing complexity metrics
  3. Growing file sizes
  4. Missing docstrings on new functions

Nice to Address

  1. Minor style inconsistencies
  2. Optimization opportunities
  3. Documentation gaps
  4. Technical debt

Integration Points

With lint-monorepo (Primary Linting)

For all linting operations, delegate to the lint-monorepo skill:

Quality gate check needed
    → Invoke lint-monorepo skill
    → lint-monorepo runs auto-fix workflow
    → Returns pass/fail with details

Linting workflow:

# lint-monorepo handles both Python and TypeScript
# See .claude/skills/lint-monorepo/ for details

# Quick lint check
cd /home/user/Autonomous-Assignment-Program-Manager/backend
ruff check app/ tests/

cd /home/user/Autonomous-Assignment-Program-Manager/frontend
npm run lint

For persistent lint errors: Use lint-monorepo root-cause analysis workflow.

With automated-code-fixer

When quality issues are detected, the automated-code-fixer skill can be triggered to automatically resolve:

  • Linting issues (auto-fixable) - coordinates with lint-monorepo
  • Formatting issues
  • Simple type annotation additions
  • Import organization

With Existing Commands

  • /run-tests - Full test suite
  • /lint-fix - Auto-fix linting
  • /health-check - System health
  • /check-compliance - ACGME validation

Reporting Format

Quick Status

Code Health: GREEN/YELLOW/RED

Tests: 156 passed, 0 failed
Coverage: 78.2% (target: 80%)
Linting: 0 errors, 3 warnings
Types: 100% coverage
Security: No issues

Detailed Report

## Code Quality Report

### Test Results
- Total: 156 tests
- Passed: 156
- Failed: 0
- Skipped: 2

### Coverage Analysis
- Current: 78.2%
- Target: 80.0%
- Delta: -1.8%
- Uncovered: app/services/new_feature.py (lines 45-67)

### Linting
- Errors: 0
- Warnings: 3
  - W291: trailing whitespace (3 occurrences)

### Type Safety
- Checked files: 147
- Errors: 0
- Coverage: 100%

### Security
- Critical: 0
- High: 0
- Medium: 0
- Low: 0

### Recommendations
1. Add tests for app/services/new_feature.py
2. Remove trailing whitespace
3. Consider splitting large function in resilience.py

Escalation Rules

Escalate to human when:

  1. Coverage drops below 60%
  2. Critical security issue found
  3. Multiple interdependent failures
  4. Unclear how to improve metrics
  5. Architectural concerns detected