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.