# What Is Ponytail Review Mode? Detecting Over-Engineered Code > Discover Ponytail review mode, a tool that detects over-engineered code by identifying YAGNI, stdlib, and delete patterns. Quantify potential line reductions with this specialized scanner. - Repository: [DietrichGebert/ponytail](https://github.com/DietrichGebert/ponytail) - Tags: deep-dive - Published: 2026-09-13 --- **Ponytail review mode is a specialized configuration that scans code exclusively for over-engineered patterns, outputting tagged one-line findings like `yagni`, `stdlib`, and `delete` to quantify potential line reductions.** Ponytail is an open-source code assistant designed to streamline development workflows. The **review mode** provides a focused audit capability that targets unnecessary complexity without addressing correctness, security, or performance concerns. When activated via environment variables or slash commands, the plugin loads a dedicated skill file and injects specific instructions to identify where code can be simplified or eliminated entirely. ## How Ponytail Review Mode Works The review mode is implemented as a first-class configuration option within the `DietrichGebert/ponytail` repository. According to the source code, the mode triggers a unique context injection that prioritizes deletion over modification. ### Configuration Entry Points In [`__init__.py`](https://github.com/DietrichGebert/ponytail/blob/main/__init__.py), the `CONFIG_MODES` tuple defines `"review"` as a valid configuration option at line 13, alongside standard runtime modes including `off`, `lite`, `full`, and `ultra`. You can activate review mode through two primary mechanisms: - Setting the `PONYTAIL_DEFAULT_MODE=review` environment variable - Issuing the `/ponytail-review` slash command, registered in `SKILL_COMMANDS` at line 15 When either method is used, the `build_injected_context` function detects the `"review"` branch at lines 110-115 and loads the corresponding skill instructions. ### The Review Skill Architecture The mode's behavior is governed by [`skills/ponytail-review/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail-review/SKILL.md). According to the skill definition at lines 4-10, the purpose is strictly "Code review focused exclusively on over-engineering." The skill mandates a specific output format consisting of one-line findings with standardized tags: - **`delete`**: Code that serves no purpose and can be removed entirely - **`stdlib`**: Custom implementations that should be replaced with standard library equivalents - **`native`**: Dependencies that can be replaced with built-in language features - **`yagni`**: "You Aren't Gonna Need It" abstractions that add unnecessary indirection - **`shrink`**: Verbose implementations that can be condensed ## Activating and Using Review Mode Developers can activate review mode through environment configuration or chat-based commands. To enable review mode globally via environment variable: ```bash export PONYTAIL_DEFAULT_MODE=review ``` Upon initialization, the plugin automatically loads the review skill and injects the header "PONYTAIL MODE ACTIVE — level: review" into the processing context. For on-demand usage within chat interfaces that use the Hermes plugin: ```text /ponytail-review ``` The `rewrite_gateway_command` hook processes this command and rewrites it to invoke the appropriate skill prompt. ## Interpreting Review Mode Output The review mode produces machine-readable findings designed for immediate action. Each line follows the format specified in [`SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/SKILL.md) at lines 18-42: location, tag, description, and concise replacement suggestion. Example output from a typical review session: ```text L12-38: stdlib: 27‑line validator class. "@" in email, 1 line, real validation is the confirmation mail. L4: native: moment.js imported for one format call. Intl.DateTimeFormat, 0 deps. repo.py:L88: yagni: AbstractRepository with one implementation. Inline it until a second one exists. L52-71: delete: retry wrapper around an idempotent local call. Nothing replaces it. L30-44: shrink: manual loop builds dict. dict(zip(keys, values)), 1 line. net: -27 lines possible. ``` The final `net: -N lines possible` metric aggregates all potential deletions, providing a quantitative measure of code bloat that can be eliminated. ## Summary - Ponytail review mode is defined in [`__init__.py`](https://github.com/DietrichGebert/ponytail/blob/main/__init__.py) as part of `CONFIG_MODES` and activates via `PONYTAIL_DEFAULT_MODE=review` or the `/ponytail-review` slash command. - The mode exclusively targets over-engineering through the `build_injected_context` function at lines 110-115, ignoring correctness, security, or performance issues. - Output uses standardized tags (`delete`, `stdlib`, `native`, `yagni`, `shrink`) defined in [`skills/ponytail-review/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail-review/SKILL.md). - The `rewrite_gateway_command` hook enables chat-based activation through the Hermes plugin interface. - Results include a "net -N lines possible" metric quantifying total potential code reductions. ## Frequently Asked Questions ### How does review mode differ from other Ponytail modes? Standard Ponytail modes like `lite`, `full`, and `ultra` provide comprehensive code assistance including correctness checks and security analysis. Review mode exclusively targets over-engineering and code bloat, producing a narrow, actionable report focused solely on deletions and simplifications without evaluating functional correctness. ### What file controls the behavior of review mode? The behavior is defined in [`skills/ponytail-review/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail-review/SKILL.md), which specifies the purpose, output format, and tagging system. The main plugin logic in [`__init__.py`](https://github.com/DietrichGebert/ponytail/blob/main/__init__.py) handles the mode activation through `CONFIG_MODES` and the `build_injected_context` function. ### Can review mode be used on individual files or only diffs? According to the implementation in `build_injected_context`, review mode can process any target supplied to the plugin, whether a diff or a specific file path. The skill documentation confirms it scans "a diff (or a supplied target)," making it flexible for both CI/CD pipeline integration and single-file analysis. ### What does the "net -N lines possible" metric indicate? This metric appears at the end of review output and represents the total number of lines that could be removed from the codebase if all suggestions were applied. It serves as a quantitative measure of over-engineering density in the reviewed code, allowing teams to track simplification progress over time.