ponytail

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

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

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 then write the minimum code that works. ## Core Features & Use Cases - Simplicity ladder: A seven-step decision order (existence check, codebase reuse, stdlib, native platform features, existing dependencies, one-liners, minimal code) applied to every coding task. - Intensity levels: Three modes — lite (suggest the lazier alternative), full (default, enforce the ladder), and ultra (YAGNI extremist, deletion before addition) — switchable at any time. - Root-cause bug fixing: Requires tracing all callers before editing so fixes land once in the shared path rather than 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) and notes in one line what was skipped and when to revisit it. ## Quick Start Ask the assistant to use ponytail mode to implement your next feature or fix with the simplest solution that works.

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 the standard library, then native platform features, then already-installed dependencies. Write the minimum code only after those options are exhausted.

How to choose between a standard library solution and a new dependency?

Prefer the standard library whenever it covers the requirement, and never add a new dependency for something a few lines of code can do. If two stdlib options are equal in size, pick the one that is correct on edge cases rather than the flimsier one.

What are the ponytail intensity levels lite, full, and ultra?

Lite builds what was asked but names the lazier alternative in one line. Full, the default, enforces the simplicity ladder with the shortest diff and explanation. Ultra is YAGNI-extremist: deletion before addition, shipping one-liners and challenging the requirement itself.

When should I not simplify code with a 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 — read the full code flow before choosing a minimal fix.

Why does a minimal bug fix require checking all callers first?

A bug report names a symptom, not the root cause. Grepping every caller before editing lets you place one guard in the shared function instead of patching each call site, which is both the smaller diff and the only fix that covers all paths.