ponytail

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

Updated Jun 9, 2026
One-click install
npx skills add https://github.com/timikalo7/Execute --skill ponytail-timikalo7
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ponytail
Source: https://github.com/timikalo7/Execute/tree/main/.claude/skills/ponytail
Command: npx skills add https://github.com/timikalo7/Execute --skill ponytail-timikalo7

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Codebases accumulate over-engineering: unnecessary abstractions, premature dependencies, boilerplate scaffolding, and bloated diffs. This Skill forces the simplest solution that actually works, cutting speculative features and custom code in favor of standard library and native platform capabilities. ## Core Features & Use Cases - The Ladder: A decision hierarchy that stops at the first sufficient rung — question whether the task needs to exist (YAGNI), reuse existing code, prefer stdlib, then native platform features, then existing dependencies, and only then write minimal new code. - Intensity Levels: Three modes (lite, full, ultra) control how aggressively simplification is enforced, from suggesting lazier alternatives to challenging the requirement itself. - Root-Cause Bug Fixes: Directs fixes to the shared function all callers route through rather than patching individual 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 when a custom solution would become necessary. ## Quick Start Ask the AI to implement or refactor any coding task using ponytail mode, for example: "Use ponytail to add caching to this API fetch function."

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?

Follow a decision ladder: first question whether the feature needs to exist (YAGNI), then check for existing code in the codebase, standard library functions, and native platform features before writing anything new. Stop at the first option that works and skip unrequested abstractions like single-implementation interfaces.

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

Prefer the standard library first, then native platform features, then dependencies already installed in the project. Never add a new dependency for something a few lines of code can accomplish. When two stdlib options are equal in size, pick the one correct on edge cases.

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

Lite builds what is asked but names a lazier alternative in one line. Full (the default) enforces the simplification ladder with the shortest working diff. Ultra is YAGNI-extremist: it deletes before adding and challenges the requirement itself while shipping a minimal solution.

When should I not simplify or write minimal code?

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 all affected code fully before choosing a minimal fix.

How do I fix a bug at the root cause instead of the symptom?

Before editing, grep every caller of the function you plan to touch. Place one guard in the shared function all callers route through rather than patching only the path named in the bug report, which leaves sibling callers still broken.

Does minimal code still need tests?

Non-trivial logic such as branches, loops, parsers, or money and security paths should leave one runnable check behind — a small assert-based self-check or single test file. Trivial one-liners need no test, and full test frameworks are avoided unless requested.