Waza: tw93/claude-health: the Claude Code skill that audits Claude Code

It checks prompts, rules, skills, hooks, subagents, and verifiers from inside the agent itself, then tells you what your setup is missing.

8 min read · tw93/claude-health

A Claude Code terminal sits like a diagnostic machine on a workbench, with drawers, tools, and paper files arranged around it. A report page slides out of the terminal while the surrounding workspace suggests that the system is inspecting its own operating setup. — The unusual part is not that it checks configuration. It is that the check runs inside the same environment it is grading.

Key Takeaways

claude-health turns Claude Code setup review into an in-agent governance loop, so the audit runs where the work actually happens.
The six-layer model matters because it separates memory, rules, methods, enforcement, workers, and verification into distinct responsibilities.
Complexity detection keeps the tool opinionated without becoming rigid, which makes the audit useful for both small and larger setups.
Its main contrast with external checkers is not score versus no score, but workflow change versus passive reporting.

The setup checks itself

Most health checks stand outside the system they measure. This one sits inside Claude Code and grades the environment that spawned it. That changes the question from Do I have the right files? to Does my agent stack behave like a system?

The `/health` command is the hook. It looks at the setup, then reports what is missing, duplicated, or overbuilt. The point is not a perfect score. It is to make the shape of the stack visible.

The check becomes legible when the layers, branches, and priority order are visible together.

A Claude Code skill that systematically reviews your project's setup using the six-layer framework: `CLAUDE.md → rules → skills → hooks → subagents → verifiers`. It detects project complexity, runs two parallel diagnostic agents, and outputs a prioritized report telling you what to fix first.

tw93, Project Creator and Maintainer · tw93/claude-health

The six layers that make a setup legible

tw93's own framework gives the project its logic. CLAUDE.md and memory define what this is. Rules constrain what should happen. Skills define on-demand methods. Hooks enforce behavior. Subagents isolate context. Verifiers close the loop.

That separation matters because agent setups usually fail by blending those roles together. When prompts, policy, and automation all live in the same blob, nobody knows what should change when something breaks.

claude-health treats each layer as a different kind of evidence. If the project is simple, it should not demand a cathedral of controls. If it is complex, it should not let missing safeguards hide behind a clean prompt.

How the diagnosis runs

The README says the skill detects complexity, runs two parallel diagnostic agents, and returns a prioritized report. That workflow is the quiet innovation. It lets the tool check structure and behavior at the same time.

Instead of one monolithic pass, the check fans out. One agent can read for setup integrity while another looks for governance gaps. The main skill deduplicates the findings, ranks them, and turns them into fixes rather than a score.

Embedded beats external when the checker should change behavior

External tools are useful when you want a snapshot. An embedded skill is better when you want the audit to shape the same workflow it inspects. That difference sounds subtle until you decide whether the check should only report, or also influence what Claude does next.

cc-health-check scans Claude Code from the outside and gives you a numeric readout. claude-health lives inside Claude Code, sees the live session context, and responds with prioritized fixes. One is a report card. The other is closer to a governance loop.

Tool	Where it runs	What it sees	What it returns	Best for
tw93/claude-health	Inside Claude Code as a skill	Live agent context plus project setup	Prioritized fixes and layer-specific recommendations	Teams already working inside Claude Code
yurukusa/cc-health-check	Outside Claude Code as a CLI	Files and config it can read directly	A numeric score and pass or fail checks	Fast external audits
Manual review	Wherever a human opens the repo	Whatever the reviewer remembers to inspect	Narrative judgment and tribal knowledge	Ad hoc cleanup, not repeatable governance

A split scene shows a detached terminal on the left and an integrated Claude Code workspace on the right. It visualizes the difference between an outside scanner that returns a score and an in-workflow skill that inspects the live environment while it works. — The real difference is not the checklist itself. It is whether the checklist lives inside the workflow it is trying to improve.

What this says about Claude Code maturity

The deeper argument is that agent tools are moving from prompt stuffing to operational discipline. If your setup cannot explain itself, your team cannot trust it.

claude-health is interesting because it does not promise magic. It asks for a stack that can be inspected, reasoned about, and improved layer by layer. That is what mature agent tooling looks like. Less folklore. More control surfaces.