review-code-quality

Analyze codebases for quality and maintainability issues with evidence.

1|Updated Jan 12, 2026
One-click install
npx skills add https://github.com/cwilliams5/Alt-Tabby --skill review-code-quality
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: review-code-quality
Source: https://github.com/cwilliams5/Alt-Tabby/tree/main/.claude/skills/review-code-quality
Command: npx skills add https://github.com/cwilliams5/Alt-Tabby --skill review-code-quality

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill identifies and addresses code quality and maintainability issues, ensuring the codebase is robust, easy to understand, and simple to modify in the future.

Core Features & Use Cases

  • Code Analysis: Detects issues like magic numbers, DRY violations, poor separation of concerns, problematic function design, inconsistent error handling, and misleading naming.
  • Maintainability Focus: Prioritizes issues that impact future development and debugging efforts.
  • Use Case: A developer can use this Skill to perform a thorough review of a new feature's code before merging, catching potential long-term issues and ensuring adherence to best practices.

Quick Start

Use the review-code-quality skill to deep-review the codebase for code quality and maintainability issues.

Frequently Asked Questions about review-code-quality

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I perform a code review for maintainability issues?

To review code quality, you analyze codebases for magic numbers, DRY violations, and separation of concerns issues. This Skill explores different code modules in parallel and validates findings with evidence and counter-arguments.

What is the best way to detect DRY violations and magic numbers in a codebase?

Detecting DRY violations and magic numbers requires analyzing the codebase across different code modules in parallel. This approach identifies problematic function design and naming convention issues while validating findings with evidence and counter-arguments.

How does deep code analysis identify problematic function design and naming conventions?

Deep code analysis identifies problematic function design and naming conventions by employing a parallel exploration strategy across different code modules. It validates these quality findings with evidence and counter-arguments to ensure accurate maintainability assessments.

Can I use an automated code analysis to check for poor separation of concerns before merging?

Yes, you can use automated code analysis to check for poor separation of concerns, inconsistent error handling, and misleading naming before merging. It performs a thorough review to catch potential long-term issues and ensure adherence to best practices.

Does code quality analysis require any specific dependencies or environment setup?

Code quality analysis requires no specific dependencies or environment setup. It operates directly on the codebase to identify maintainability issues like magic numbers and DRY violations without needing external components.

When should I use a deep codebase review for refactoring instead of standard linting?

You should use a deep codebase review for refactoring when you need to catch complex maintainability issues like DRY violations and poor separation of concerns. It validates findings with counter-arguments, going beyond standard linting to ensure long-term robustness.