ponytail-review

Detect over-engineering bloat in code diffs with structured findings.

Updated Jul 1, 2026
One-click install
npx skills add https://github.com/yaresimeonthomas/-kate-crm --skill ponytail-review-yaresimeonthomas
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ponytail-review
Source: https://github.com/yaresimeonthomas/-kate-crm/tree/main/.claude/skills/ponytail-review
Command: npx skills add https://github.com/yaresimeonthomas/-kate-crm --skill ponytail-review-yaresimeonthomas

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Standard code reviews often miss unnecessary complexity and over-engineering that accumulates in codebases, such as hand-rolled standard library functions, unneeded dependencies, and speculative abstractions that add maintenance burden without delivering user value.

Core Features & Use Cases

  • Targeted Over-Engineering Detection: Scans code diffs for common bloat patterns including reinvented standard library functionality, unused dependencies, single-implementation abstractions, and dead flexible code.
  • Structured Actionable Findings: Outputs one-line findings with file location, bloat type tag, what to cut, and the exact replacement, using standardized tags for consistency across reviews.
  • Use Case: Use this Skill when reviewing a PR that adds a custom date formatting utility instead of using the platform's native Intl API, or imports a heavy validation library for a single simple check that the standard library can handle.

Quick Start

Use the ponytail-review skill to scan the latest pull request diff for over-engineering and get a prioritized list of code to cut with exact replacements.

Frequently Asked Questions about ponytail-review

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

FAQPage Schema
How do I detect over-engineering bloat in a pull request code diff?

To detect over-engineering bloat in a pull request code diff, scan the changes for hand-rolled standard library functions, unneeded dependencies, and speculative abstractions. This process targets complexity reduction by outputting structured findings with file locations and net line savings scores.

What is speculative abstraction and dead flexibility in code review?

Speculative abstraction and dead flexibility in code review refer to unnecessary complexity like single-implementation interfaces or unused extensible code patterns. Detecting these bloat types helps eliminate maintenance burden by replacing them with direct, standard library functionality.

How do I get structured findings for simplifying code changes?

You get structured findings for simplifying code changes by scanning diffs for bloat patterns and outputting one-line results. Each finding includes the file location, bloat type tag, cut target, exact replacement, and a net line savings score to quantify the simplification impact.

Does this code review approach check for correctness and security bugs?

This code review approach does not check for correctness and security bugs. It focuses exclusively on complexity reduction and over-engineering detection, ensuring you remove unneeded dependencies and reinvented standard library functions without overlapping with security auditing tasks.

Can I use this to find unneeded dependencies in any software project?

You can use this to find unneeded dependencies in any software project. It applies to code review workflows for pull requests and code changes across all platforms, identifying heavy libraries imported for simple checks that standard native APIs can handle.

When should I not use over-engineering detection during code review?

You should not use over-engineering detection when you need to validate functional correctness, fix security vulnerabilities, or enforce architectural patterns. This scanning mechanism is strictly limited to identifying bloat like hand-rolled utilities and speculative abstractions for simplification.