Code Scoring

Code Scoring

Systematic, quantitative code quality assessment using weighted categories and standardized deductions.

Quick Start

Full code review with score:

Score this code on a 1-10 scale using the code-scoring rubric

Category-specific assessment:

Evaluate the error handling in this module using the scoring rubric

Compare implementations:

Score both implementations and recommend which is better

Scoring Methodology

The Formula

Final Score = 10 - Total Deductions

Where:
Total Deductions = SUM(Category Deductions * Category Weight)
Category Deduction = SUM(Issue Points * Severity Multiplier)

Category Weights

Total: 100%

Severity Multipliers

Quick Scoring Cheat Sheet

Common Deductions Table

Quick reference for frequent issues. See references/deduction-catalog.md for complete list.

High-Impact Deductions

Medium-Impact Deductions

Low-Impact Deductions

Scoring Workflow

Step 1: Initial Scan

1. Count lines of code
2. Identify file/module structure
3. Note language and framework
4. Check for tests presence
5. Scan for obvious red flags

Step 2: Category Assessment

For each of the 10 categories:

1. Review relevant code sections
2. Identify issues
3. Classify severity (critical/major/minor/nitpick)
4. Calculate: Issues * Severity Multiplier
5. Apply category weight

Step 3: Calculate Final Score

Final Score = 10 - (Sum of weighted deductions)

If score < 1: score = 1
If score > 10: score = 10

Step 4: Generate Report

## Code Score: X.X/10

### Score Breakdown
| Category | Weight | Deductions | Weighted |
|----------|--------|------------|----------|
| Organization | 12% | ... | ... |
| ... | ... | ... | ... |

### Critical Issues (Fix Immediately)
- [Issue 1]

### Major Issues (Fix Before Merge)
- [Issue 1]

### Minor Issues (Fix When Convenient)
- [Issue 1]

### Recommendations
- [Improvement 1]

Category Quick Guides

Organization (12%)

Excellent (0 deductions):

• Clear module boundaries
• Single responsibility per file
• Logical folder structure
• No circular dependencies

Red flags:

• Files > 500 lines: -1.0
• Mixed concerns in module: -1.0
• No clear structure: -1.5
• Circular dependencies: -1.0

Naming (10%)

Excellent (0 deductions):

• Descriptive, intention-revealing names
• Consistent convention (camelCase, snake_case)
• Domain terminology used correctly
• Acronyms handled consistently

Red flags:

• Single-letter variables (non-loop): -0.5
• Misleading names: -1.0
• Inconsistent convention: -1.0
• Magic numbers: -1.0

Error Handling (12%)

Excellent (0 deductions):

• All external calls wrapped
• Specific error types used
• Errors logged with context
• Graceful degradation where appropriate

Red flags:

• Empty catch blocks: -1.0
• Generic catch-all: -0.5
• Missing validation: -1.5
• Swallowed errors: -1.0

Testing (12%)

Excellent (0 deductions):

• 80%+ coverage on critical paths
• Unit, integration, and E2E tests
• Edge cases covered
• Tests are maintainable

Red flags:

• No tests: -2.0
• Only happy path: -1.0
• Flaky tests: -1.0
• Test code duplication: -0.5

Performance (10%)

Excellent (0 deductions):

• Efficient algorithms
• Appropriate caching
• No memory leaks
• Optimized queries

Red flags:

• N+1 queries: -1.5
• Blocking operations in hot path: -1.0
• Memory leaks: -1.5
• No pagination on lists: -1.0

Security (12%)

Excellent (0 deductions):

• Input validation on all boundaries
• Parameterized queries
• Secrets in environment variables
• Proper authentication/authorization

Red flags:

• SQL/command injection: -2.0
• Hardcoded secrets: -2.0
• Missing auth checks: -1.5
• XSS vulnerabilities: -1.5

Documentation (8%)

Excellent (0 deductions):

• Public API documented
• Complex logic explained
• README with setup instructions
• Changelog maintained

Red flags:

• No documentation: -1.5
• Outdated docs: -1.0
• Missing API docs: -1.0
• No README: -0.5

SOLID Principles (10%)

Excellent (0 deductions):

• Single responsibility classes
• Open for extension, closed for modification
• Proper abstractions
• Dependency injection used

Red flags:

• God classes: -1.5
• Tight coupling: -1.0
• Violation of LSP: -1.0
• Concrete dependencies: -0.5

Dependencies (6%)

Excellent (0 deductions):

• Minimal dependencies
• Locked versions
• No vulnerabilities
• Clear dependency boundaries

Red flags:

• CVE vulnerabilities: -2.0
• Circular dependencies: -1.0
• Excessive dependencies: -0.5
• Unlocked versions: -0.5

Maintainability (8%)

Excellent (0 deductions):

• Low cyclomatic complexity
• DRY principle followed
• Consistent style
• Easy to understand

Red flags:

• Cyclomatic complexity > 15: -1.0
• Duplicated code: -1.0
• Deep nesting (4+): -1.0
• Inconsistent style: -0.5

Score Interpretation Guide

Deployment Readiness

Review Actions

Reference Files

• references/scoring-rubrics.md - Detailed rubric for each category
• references/severity-weights.md - How to weight different issue types
• references/score-descriptors.md - What each score 1-10 means with examples
• references/deduction-catalog.md - Common issues and their point deductions