absence-of-value-and-meaning-code-quality-review

Absence-of-Value-and-Meaning Code-Quality Review

This is the standard Nihil's Ma'at enforces. For an orchestrated, adversarially-verified run, use the /nihil-maat dynamic workflow; this skill is the doctrine behind it and applies whenever an unusually strict read-only review is requested.

Compatibility is respected, but it is not absolute. Public APIs, existing behavior, and repository conventions may be broken when preserving them would keep the system less correct, less secure, less cohesive, less expressive, more tightly coupled, or harder to maintain. The goal is not destruction — it is a smaller, clearer, more semantically accurate system whose names, boundaries, APIs, dependencies, and implementation choices justify their continued existence.

Above all, be ambitious about code structure. Do not merely identify local cleanup. Actively search for "code-judo" moves: restructurings that preserve behavior while making the implementation dramatically simpler, smaller, more direct, and more elegant.

Core prompt

Perform a deep code-quality audit of the current branch's changes. Rethink how to structure / implement the changes to meaningfully improve code quality without impacting behavior. Improve abstractions and modularity, reduce spaghetti, improve succinctness and legibility. Be ambitious — if there is a clear path to improving the implementation that involves restructuring some of the codebase, go for it. Be extremely thorough and rigorous. Measure twice, cut once.

Non-negotiable standards

1. Be ambitious about structural simplification. Do not stop at "this could be a bit cleaner." Look for reframings that make whole branches, helpers, modes, conditionals, or layers disappear. Prefer the solution that feels inevitable in hindsight. If you can delete complexity rather than rearrange it, push hard for that path.
2. Do not let a change push a file from under 1k lines to over 1k lines without a very strong reason. Treat it as a strong smell. Prefer extracting helpers, subcomponents, modules, or local abstractions. If the diff crosses the threshold, ask whether to decompose first. The ideal source file lives in the 500–1000 line range.
3. Do not allow random spaghetti growth. Be highly suspicious of new ad-hoc conditionals, scattered special cases, or one-off branches inserted into unrelated flows. Treat "weird if statements in random places" as a design problem, not a stylistic nit. Push logic into a dedicated abstraction, helper, state machine, policy object, or module.
4. Bias toward cleaning the design, not just accepting working code. If behavior can stay the same while structure becomes meaningfully cleaner, push the cleaner version. Strongly prefer removing moving pieces over spreading the same complexity around.
5. Prefer direct, boring, maintainable code over hacky or magical code. Treat brittle, ad-hoc, or "magic" behavior as a quality problem. Be skeptical of generic mechanisms that hide simple data-shape assumptions. Flag thin abstractions, identity wrappers, and pass-through helpers that add indirection without buying clarity.
6. Push hard on type and boundary cleanliness. Question unnecessary optionality, unknown, any, or cast-heavy code when a clearer boundary could exist. Prefer explicit typed models or shared contracts over loosely-shaped ad-hoc objects. If a branch relies on silent fallback to paper over an unclear invariant, make the invariant explicit.
7. Keep logic in the canonical layer and reuse existing helpers. Call out feature logic leaking into shared paths or implementation details leaking through APIs. Prefer existing canonical utilities over bespoke one-offs. Push code toward the right package, service, or module instead of normalizing architectural drift.
8. Treat unnecessary sequential orchestration and non-atomic updates as design smells when the cleaner structure is obvious. If independent work is serialized for no reason, ask whether it should run in parallel. If related updates can leave state half-applied, push for atomicity. Do not over-index on micro-optimizations.