thermo-nuclear-code-quality-review

Audit code changes for maintainability regressions and structural complexity.

Updated May 28, 2026

Search Tags:#architecture #code review #refactoring #maintainability #branching #decomposition #abstraction

Ready to run

npx skills add https://github.com/haryelramalho/skills --skill thermo-nuclear-code-quality-review-haryelramalho

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: thermo-nuclear-code-quality-review
Source: https://github.com/haryelramalho/skills/tree/main/skills/curated/thermo-nuclear-code-quality-review
Command: npx skills add https://github.com/haryelramalho/skills --skill thermo-nuclear-code-quality-review-haryelramalho

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you catch severe maintainability problems in code changes before they become long-term debt, especially when a refactor starts making the implementation harder to read, harder to split, or structurally messier.

Core Features & Use Cases

Deep Maintainability Review: Critiques abstraction quality, modularity, and code organization with a deliberately strict lens.
Spaghetti-Reduction Focus: Flags ad-hoc branching, special cases, wrapper layers, and unnecessary complexity that make code harder to reason about.
Boundary and Decomposition Checks: Pushes for cleaner type boundaries, canonical helpers, smaller files, and clearer ownership of logic.
Use Case: A pull request adds a feature that works, but it balloons a core file and spreads conditionals across shared paths; this Skill pushes for a more elegant structure instead of rubber-stamping the change.

Quick Start

Ask the Skill to perform a deep maintainability audit of the current branch and identify the most important structural simplifications to make.

Frequently Asked Questions about thermo-nuclear-code-quality-review

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

FAQPage Schema

How do I catch maintainability debt before merging a pull request?▼

A maintainability audit evaluates code changes for structural complexity and modularity regressions. It identifies spaghetti branching, oversized files, and leaky abstractions, pushing for cleaner type boundaries and stricter decomposition before code merges.

How do I reduce spaghetti branching and unnecessary complexity during a refactor?▼

To reduce spaghetti branching, audit refactored code for ad-hoc conditionals, wrapper layers, and unnecessary complexity. Enforcing boundary clarity and canonical helpers replaces messy special cases with simpler, more direct implementations.

Does this code review tool check for leaky abstractions and poor modularity?▼

Yes, this code review approach checks for leaky abstractions and poor modularity. It critiques abstraction quality and code organization with a strict lens, demanding cleaner type boundaries and clearer ownership of logic to prevent maintainability regressions.

What is the best way to enforce decomposition checks on branch diffs?▼

The best way to enforce decomposition checks on branch diffs is applying strict audits that flag oversized files and shared conditional paths. This approach demands smaller files and high-conviction recommendations favoring simpler implementations.

When should I use an automated maintainability audit on my code changes?▼

Use an automated maintainability audit when a refactor risks making implementation harder to read or split, or when a pull request balloons core files and spreads conditionals across shared paths, preventing long-term structural debt.