code-quality

Code quality - patterns, testing, maintainability. Use for code review.

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

When & Why to Use This Skill

This Claude skill serves as an advanced automated code review assistant designed to enforce high-standard engineering patterns, rigorous testing, and long-term maintainability. It focuses on identifying hidden complexities, ensuring strict TypeScript type safety, and eliminating technical debt to make codebases more readable and resilient.

Use Cases

  • Automated Pull Request Audits: Use the skill to evaluate code changes against strict quality guidelines, identifying anti-patterns and fragile logic before merging.
  • Type Safety Enforcement: Detect and resolve 'any' types, incorrect generics, or missing null checks to ensure end-to-end type integrity from DB to UI.
  • Refactoring & Technical Debt Reduction: Identify 'embarrassing' or overly complex code sections that are difficult to modify and suggest structural improvements.
  • Testing Strategy Optimization: Analyze codebases for coverage gaps in critical business logic and ensure alignment with Bun-based testing standards.
  • Maintainability Checks: Scan for TODOs, hacks, and unused code to keep the production environment clean and professional.
namecode-quality
descriptionCode quality - patterns, testing, maintainability. Use for code review.

Code Quality Guideline

Tech Stack

  • Runtime: Bun
  • Linting/Formatting: Biome
  • Testing: Bun test
  • Language: TypeScript (strict)

Non-Negotiables

  • No TODOs, hacks, or workarounds in production code
  • Strict TypeScript with end-to-end type safety (DB → API → UI)
  • No dead or unused code

Context

Code quality isn't about following rules — it's about making the codebase a place where good work is easy and bad work is hard. High-quality code is readable, testable, and changeable. Low-quality code fights you on every change.

Don't just look for rule violations. Look for code that technically works but is confusing, fragile, or painful to modify. Look for patterns that will cause bugs. Look for complexity that doesn't need to exist.

Driving Questions

  • What code would you be embarrassed to show a senior engineer?
  • Where is complexity hiding that makes the codebase hard to understand?
  • What would break if someone new tried to make changes here?
  • Where are types lying (as any, incorrect generics, missing null checks)?
  • What test coverage gaps exist for code that really matters?
  • If we could rewrite one part of this codebase, what would have the highest impact?