agentleFS
jeremymcsjeremymcs/skills/overengineering-review/SKILL.md

overengineering-review

Skill8 starsChanged 6 months agoMITView on GitHub

Review code for overengineering and avoidable complexity, then write an HTML findings report. Use when the user asks whether code is too abstract, too layered, too generic, prematurely extensible, hard to follow, or more complex than the problem requires.

1 other project uses a version of this.

Adopted by

Most recently taken up by

The file

We split this skill into the rules it gives an agent

11 rules. About 0 are common, 10 are distinctive, and 1 is very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈10

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 1

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Use this skill to inspect code for avoidable complexity and produce a self-contained HTML report.

    line 8
  2. Distinctive:

    Prefer evidence from the codebase over generic simplicity advice.

    line 15
  3. Distinctive:

    Look for overengineering signals.

    line 20
  4. Distinctive:

    Check the blast radius before recommending simplification.

    line 28
  5. Distinctive:

    Avoid deleting abstraction that already protects real variability, external contracts, or hard-won operational boundaries.

    line 31
  6. Distinctive:

    Write the HTML report directly.

    line 37
  7. Very specific:

    Create one self-contained .html file with inline CSS and no external assets.

    line 38
  8. Distinctive:

    Use this structure unless the task needs a different layout:

    line 45
  9. Distinctive:

    Do not recommend broad rewrites when a smaller deletion, inline move, rename, or module merge solves the problem.

    line 94
  10. Distinctive:

    Do not treat complexity as automatically bad.

    line 95
  11. Distinctive:

    Do not credit any AI in the report.

    line 96

≈ “Common” is an estimate: at least 1 in 5 of the 350,495 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Overengineering Review

Use this skill to inspect code for avoidable complexity and produce a self-contained HTML report.

Workflow

  1. Define scope.
    • Identify the files, diff, branch, feature, or subsystem under review.
    • Inspect nearby callers, tests, docs, and sibling patterns before judging complexity.
    • Prefer evidence from the codebase over generic simplicity advice.
  2. Map the actual problem being solved.
    • State the concrete behavior or user need the code supports.
    • Identify current scale: number of callers, variants, data shapes, plugins, integrations, and lifecycle states.
    • Separate real requirements from speculative future flexibility.
  3. Look for overengineering signals.
    • Extra layers that only forward calls or rename concepts.
    • Generic abstractions with one real implementation.
    • Factories, registries, adapters, managers, or strategy objects before there is meaningful variation.
    • Configuration that duplicates code paths or exposes internals to callers.
    • Types, schemas, or inheritance hierarchies that are broader than the supported behavior.
    • File or package splits that make a simple change require cross-module navigation.
    • Tests that mainly protect the abstraction instead of user-visible behavior.
  4. Check the blast radius before recommending simplification.
    • Trace callers, public APIs, tests, generated artifacts, migrations, and integration points.
    • Mark each recommendation as Low, Medium, or High risk based on likely breakage.
    • Avoid deleting abstraction that already protects real variability, external contracts, or hard-won operational boundaries.
  5. Produce findings.
    • Lead with actionable findings ordered by severity.
    • Include specific file paths and line references when available.
    • Explain why the code is more complex than the current need, not just that it feels complex.
    • Recommend the smallest simplification that preserves behavior.
  6. Write the HTML report directly.
    • Create one self-contained .html file with inline CSS and no external assets.
    • Include findings, file evidence, impact, recommendation, risk, positive signals, open questions, and verification.
    • Escape code snippets and copied source text so review content renders as text, not markup.
    • Open or inspect the HTML file when possible before claiming the artifact is ready.

HTML Structure

Use this structure unless the task needs a different layout:

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Overengineering Review</title>
  <style>
    /* Inline, readable report styles. */
  </style>
</head>
<body>
  <main>
    <header>
      <h1>Overengineering Review</h1>
      <p><strong>Scope:</strong> Files, diff, feature, or subsystem reviewed.</p>
      <p>Short conclusion and highest-priority theme.</p>
    </header>
    <section>
      <h2>Findings</h2>
      <article>
        <h3>High - Abstraction has one implementation and hides the real behavior</h3>
        <p><strong>Category:</strong> Premature abstraction</p>
        <p><strong>Evidence:</strong> Path and line evidence, caller count, tests, or runtime proof.</p>
        <p><strong>Impact:</strong> Why this makes future work harder or riskier.</p>
        <p><strong>Recommendation:</strong> Smallest safe simplification.</p>
        <p><strong>Risk:</strong> Medium</p>
      </article>
    </section>
    <section>
      <h2>Positive Signals</h2>
    </section>
    <section>
      <h2>Open Questions</h2>
    </section>
    <section>
      <h2>Verification</h2>
    </section>
  </main>
</body>
</html>

Output Standards

  • The final deliverable must be an .html file, not a prose-only answer.
  • The report must be useful to a maintainer deciding what to simplify next.
  • Do not recommend broad rewrites when a smaller deletion, inline move, rename, or module merge solves the problem.
  • Do not treat complexity as automatically bad. Name the requirement that would justify keeping it.
  • Do not credit any AI in the report.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.