Code Quality
This skill should be used when the user asks to "check code quality", "analyze code metrics", "find dead code", "check style compliance", "measure complexity", "find unused imports", "check type hints", "run linting", "PEP8 compliance", or mentions code quality analysis.
How do I install this agent skill?
npx skills add https://github.com/eyadsibai/ltk --skill code-qualityIs this agent skill safe to install?
- Gen Agent Trust Hubpass
The skill provides a comprehensive guide and command-line examples for performing code quality analysis using industry-standard tools for Python and JavaScript/TypeScript. It contains no executable code, network operations, or sensitive data access.
- Socketpass
No alerts
- Snykpass
Risk: LOW · No issues
- Runlayerpass
1 file scanned · No issues
What does this agent skill do?
Code Quality Analysis
Comprehensive code quality analysis skill covering style, complexity, dead code detection, and type checking.
Core Capabilities
Style Compliance
Check adherence to language-specific style guides:
Python (PEP8/Black):
- Line length (88 chars for Black, 79 for PEP8)
- Indentation (4 spaces)
- Import ordering (standard, third-party, local)
- Naming conventions (snake_case for functions/variables, PascalCase for classes)
- Whitespace usage
Style check commands:
# Black formatting check
black --check --diff .
# Flake8 linting
flake8 --max-line-length=88 .
# isort import sorting
isort --check-only --diff .
Complexity Metrics
Measure and report code complexity:
Cyclomatic Complexity:
- Number of independent paths through code
- Target: < 10 per function
- Warning: 10-20
- Critical: > 20
Cognitive Complexity:
- Mental effort to understand code
- Accounts for nesting depth and control flow
Function Length:
- Target: < 50 lines
- Warning: 50-100 lines
- Critical: > 100 lines
Nesting Depth:
- Target: < 4 levels
- Warning: 4-6 levels
- Critical: > 6 levels
Complexity analysis:
# Using radon for Python
radon cc . -a -s # Cyclomatic complexity
radon mi . # Maintainability index
radon hal . # Halstead metrics
Dead Code Detection
Identify unused code elements:
Unused Imports:
# Python - using autoflake
autoflake --check --remove-all-unused-imports .
# Using flake8 with F401
flake8 --select=F401 .
Unused Variables:
- Local variables assigned but never read
- Function parameters ignored
- Class attributes never accessed
Unused Functions/Classes:
- Defined but never called
- Private methods not used internally
- Dead code branches (always false conditions)
Unreachable Code:
- Code after return/raise/break/continue
- Branches with impossible conditions
- Deprecated code still in codebase
Type Hint Analysis
Validate type annotations:
Missing Type Hints:
# Using mypy
mypy --strict .
# Check specific strictness levels
mypy --disallow-untyped-defs .
mypy --disallow-incomplete-defs .
Type Errors:
- Incompatible types in assignments
- Wrong argument types
- Missing return types
- Generic type issues
Type Coverage:
- Percentage of code with type annotations
- Target: > 80% coverage
Quality Metrics Dashboard
When analyzing a codebase, report:
| Metric | Value | Target | Status |
|---|---|---|---|
| Style Compliance | X% | > 95% | Pass/Fail |
| Avg Cyclomatic Complexity | X | < 10 | Pass/Fail |
| Max Function Length | X lines | < 50 | Pass/Fail |
| Dead Code | X items | 0 | Pass/Fail |
| Type Coverage | X% | > 80% | Pass/Fail |
Analysis Workflow
Full Quality Analysis
To perform comprehensive quality check:
- Style check: Run linters and formatters
- Complexity analysis: Calculate metrics
- Dead code scan: Find unused elements
- Type check: Validate annotations
- Report generation: Summarize findings
Quick Quality Check
For rapid assessment of changes:
- Get changed files from git diff
- Run focused linting on changed files
- Check complexity of modified functions
- Validate types in touched code
Language-Specific Guidance
Python
Recommended tooling:
- Black (formatting)
- isort (import sorting)
- flake8 (linting)
- mypy (type checking)
- radon (complexity)
- vulture (dead code)
Configuration (pyproject.toml):
[tool.black]
line-length = 88
target-version = ['py311']
[tool.isort]
profile = "black"
line_length = 88
[tool.mypy]
python_version = "3.11"
strict = true
JavaScript/TypeScript
Recommended tooling:
- ESLint (linting)
- Prettier (formatting)
- TypeScript compiler (type checking)
Configuration (.eslintrc.json):
{
"extends": ["eslint:recommended"],
"rules": {
"complexity": ["warn", 10],
"max-depth": ["warn", 4],
"max-lines-per-function": ["warn", 50]
}
}
Common Quality Issues
High Priority Fixes
- Unused imports: Remove immediately
- Type errors: Fix type mismatches
- High complexity: Refactor into smaller functions
- Long functions: Extract logical blocks
Medium Priority
- Style violations: Apply formatter
- Missing type hints: Add annotations
- Moderate complexity: Consider refactoring
- Unused variables: Remove or use
Low Priority
- Minor style preferences: Team decision
- Optional type hints: Add gradually
- Documentation gaps: Address incrementally
Output Format
Present findings organized by severity:
Errors (must fix):
- Type errors
- Syntax issues
- Critical complexity
Warnings (should fix):
- Unused code
- High complexity
- Missing types in public APIs
Info (consider):
- Style suggestions
- Optimization opportunities
- Best practice recommendations
Integration
Coordinate with other skills:
- refactoring skill: For complexity reduction
- documentation skill: For missing docstrings
- security-scanning skill: For security-related quality issues
How can the creator link this skill?
Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.
<a href="https://skillzs.dev/skills/eyadsibai/ltk/code-quality">View Code Quality on skillZs</a>