ponytail

Enforces minimal, standard-library-first solutions for coding tasks with adjustable intensity levels.

Updated Jul 3, 2026
One-click install
npx skills add https://github.com/CHENHUI-X/toolbox --skill ponytail-chenhui-x
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: ponytail
Source: https://github.com/CHENHUI-X/toolbox/tree/main/codex-skill/codex/ponytail
Command: npx skills add https://github.com/CHENHUI-X/toolbox --skill ponytail-chenhui-x

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Codebases accumulate over-engineered abstractions, unnecessary dependencies, and boilerplate that create maintenance burden. This Skill forces the simplest working solution for any coding task by applying a strict decision ladder: question whether the work is needed at all (YAGNI), reuse existing code, prefer the standard library and native platform features, and only write new code as a last resort. ## Core Features & Use Cases - The Ladder: A seven-step decision hierarchy that stops at the first sufficient solution, from deleting the task entirely down to writing the minimum code that works. - Intensity Levels: Three modes (lite, full, ultra) control how aggressively simplification is enforced, switchable at any time with /ponytail lite|full|ultra. - Root-Cause Bug Fixing: Requires tracing all callers before editing so fixes land once in the shared code path instead of patching symptoms. - Use Case: When asked to add a response cache, instead of building a custom cache class, the Skill applies @lru_cache(maxsize=1000) in one line and notes when a custom cache would actually be needed. ## Quick Start Ask the AI to use ponytail mode to implement your next feature or fix with the simplest possible solution.

Frequently Asked Questions about ponytail

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

FAQPage Schema
How do I avoid over-engineering when writing new code?▼

Apply a decision ladder before writing anything: check if the feature is needed at all, reuse existing helpers in the codebase, prefer standard library functions, then native platform features, and only write new code as a last resort. Stop at the first rung that solves the problem.

How to choose between standard library and third-party dependencies?▼

Prefer the standard library whenever it covers the use case, and use already-installed dependencies before adding new ones. Never add a dependency for something a few lines of code can accomplish, since each dependency adds maintenance and supply-chain cost.

What are the ponytail intensity levels and how do I switch them?▼

Ponytail supports three levels: lite suggests a lazier alternative while building what was asked, full (the default) enforces the simplification ladder strictly, and ultra challenges the requirement itself. Switch anytime with /ponytail lite, full, or ultra.

When should I not simplify or take the minimal approach?▼

Never simplify away input validation at trust boundaries, error handling that prevents data loss, security measures, accessibility basics, or anything explicitly requested. Also never skip understanding the problem first, since a small diff in the wrong place creates a second bug.

Why fix the root cause instead of the reported symptom?▼

A bug report names a symptom, but sibling callers of the same function usually share the defect. Fixing once in the shared code path produces a smaller diff than guarding every caller and prevents the same bug from resurfacing through other paths.