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.
When & Why to Use This Skill
The Code Quality Monitor is a proactive Claude skill designed to automate code health checks and enforce strict quality gates throughout the software development lifecycle. It streamlines the development workflow by performing automated testing, linting, type checking, and security scans for both Python and TypeScript projects. By integrating rigorous standards for test coverage, cyclomatic complexity, and security compliance, this skill ensures that only high-quality code is merged, effectively reducing technical debt and preventing regressions during PR reviews and pre-commit phases.
Use Cases
- Pre-commit Validation: Automatically running a suite of linting, formatting, and quick tests before a developer commits code to ensure local changes meet project standards.
- Pull Request Auditing: Conducting comprehensive health checks during PR reviews, including coverage analysis and security scans, to provide detailed reports and block merges that fail quality gates.
- Continuous Health Monitoring: Periodically analyzing the codebase for increasing complexity, decreasing test coverage, or new security vulnerabilities to maintain long-term project maintainability.
- Automated Technical Debt Assessment: Identifying oversized files, complex functions, and missing documentation to provide actionable recommendations for refactoring and code cleanup.
| name | code-quality-monitor |
|---|---|
| description | Proactive code health monitoring and quality gate enforcement. Use when validating code changes, reviewing PRs, or ensuring code meets quality standards before merging. |
| model_tier | sonnet |
| can_parallel_with | [lint-monorepo, test-writer, coverage-reporter] |
| must_serialize_with | [] |
| preferred_batch_size | 5 |
| max_file_context | 50 |
| compression_level | 1 |
| requires_git_context | true |
| requires_db_context | false |
| - 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
- Test coverage dropped below 70%
- New security vulnerability detected
- Type errors in public APIs
- Breaking changes without migration
Needs Attention
- Coverage trending down
- Increasing complexity metrics
- Growing file sizes
- Missing docstrings on new functions
Nice to Address
- Minor style inconsistencies
- Optimization opportunities
- Documentation gaps
- 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:
- Coverage drops below 60%
- Critical security issue found
- Multiple interdependent failures
- Unclear how to improve metrics
- Architectural concerns detected