How Ponytail Instills a "Lazy Senior Dev" Philosophy into AI Coding Agents

Ponytail propagates a "lazy senior developer" mindset through a layered instruction set that every compatible AI agent consumes automatically, enforcing a six-step ladder of checks before any code is written.

The Ponytail project—hosted at DietrichGebert/ponytail—is not a library but a protocol for AI behavior. It teaches coding agents to mimic experienced engineers who avoid unnecessary work, prefer native solutions, and write the minimal viable code. This philosophy spreads through two core mechanisms: a repository-wide rule file and a persistent skill system that agents can invoke directly.

The Core Mechanism: Two Instruction Layers

Ponytail distributes its philosophy through dual entry points, ensuring agents encounter the rules regardless of how they interact with a project.

AGENTS.md: The Global Rule File

The AGENTS.md file at the repository root (AGENTS.md) declares the lazy senior developer persona as a project-level instruction. Any AI agent that supports repository-wide rules—Claude, Codex, OpenCode, and others—reads this file automatically at session start.

According to the Ponytail source code, this file embeds the complete six-step ladder and establishes the default behavior: question requirements before satisfying them.

SKILL.md: The Persistent Skill System

For finer control, Ponytail provides skills/ponytail/SKILL.md (SKILL.md), a skill definition that implements the same ladder with additional capabilities:

• Command invocation: Users trigger it via /ponytail, /ponytail lite, /ponytail full, or /ponytail ultra
• Response persistence: Lines 28-30 mark the skill ACTIVE EVERY RESPONSE, ensuring the ladder runs on every turn until explicitly stopped
• Intensity switching: Users can grade the laziness level mid-session

The skill system transforms the philosophy from passive rules into an interactive, persistent mode that follows the conversation.

The Six-Step Lazy Developer Ladder

Both AGENTS.md and SKILL.md encode the same decision hierarchy. An agent asks these questions in order, stopping at the first satisfactory answer:

Step	Question	Principle
1️⃣	Does this need to exist at all?	YAGNI—skip speculative work
2️⃣	Is it already in the codebase?	Reuse existing helpers, utils, or patterns
3️⃣	Does the standard library do it?	Prefer built-in APIs (fs, json, structuredClone)
4️⃣	Does the native platform feature cover it?	Use HTML elements, CSS, or DB constraints over libraries
5️⃣	Can it be expressed in one line?	Write the minimal one-liner; defer larger implementations
6️⃣	Only then write code	Add the smallest viable implementation

This ladder is strictly ordered. An agent must exhaust earlier steps before proceeding to later ones.

Intensity Levels: Graded Laziness

The SKILL.md implementation exposes three intensity modes that control how aggressively the agent applies the ladder:

• lite — Performs requested work, then appends a one-line mention of a lazier alternative
• full — Applies complete ladder, selects shortest correct solution, documents every skip (default)
• ultra — Aggressively questions requirements, often refusing to add code without profiler evidence

Users switch modes mid-session:

User: /ponytail ultra
Agent: (now refuses to implement caching without latency metrics)

The skill persists this choice across all subsequent responses until the user issues stop ponytail or changes intensity.

Platform-Native Reinforcement: docs/platform-native.md

Step 4 of the ladder—Does the native platform feature cover it?—relies heavily on docs/platform-native.md (platform-native.md). This file catalogs native equivalents for common third-party dependencies, giving agents concrete substitutions:

Common Library	Native Replacement	Availability
lodash.clonedeep	structuredClone(obj)	Node 17+, modern browsers
qs	new URLSearchParams()	Universal
uuid	crypto.randomUUID()	Node 14+, modern browsers
debounce libraries	One-liner with setTimeout/clearTimeout	Universal

Agents reference this mapping automatically when executing the ladder, ensuring recommendations stay current with platform capabilities.

Agent Portability: docs/agent-portability.md

The philosophy achieves broad compatibility through docs/agent-portability.md (agent-portability.md). This document enumerates adapters for dozens of AI hosts including Claude, Codex, OpenCode, JetBrains, and others.

Each adapter follows the same pattern: load the skills/ folder or AGENTS.md and forward the "lazy senior dev" rules to the underlying LLM. This architecture avoids duplicating logic across hosts. The rules live in one place; adapters merely transport them.

Live Examples: The Ladder in Practice

Example 1: UUID Generation Request

User: I need a unique identifier.
Agent (full mode):
  - Skipped `uuid` npm package.
  - Used native: const id = crypto.randomUUID();

The agent identified step 4 applicability and substituted a native platform feature.

Example 2: Query String Parsing

User: Parse the URL query parameters.
Agent (full mode):
  - Skipped `qs` library.
  - Used: const params = new URLSearchParams(location.search);

Standard library coverage (step 3) satisfied the requirement.

Example 3: Custom Debounce Request

User: Add debounce to my search input.
Agent (full mode):
  - Skipped custom debounce library.
  - One-line implementation:
    let t;
    const debounce = (fn, ms) => (...args) => {
      clearTimeout(t);
      t = setTimeout(() => fn(...args), ms);
    };
  - Add library when you need configurable cancel/flush methods.

Step 5 triggered: expressible in one line, so no dependency added—with explicit documentation of when escalation is justified.

Example 4: Mode Switching in Session

User: /ponytail lite
User: Add a caching layer for this API call.
Agent:
  // Implements custom cache class
  // FYI: functools.lru_cache covers this in one line if you'd rather not own cache logic.

Lite mode completes the request but surfaces the lazier alternative without enforcing it.

Key Source Files

File	Purpose
AGENTS.md	Repository-wide rule declaring lazy senior dev persona and ladder
skills/ponytail/SKILL.md	Skill implementation with persistence, commands, and intensity levels
docs/agent-portability.md	Adapter specifications for multi-agent compatibility
docs/platform-native.md	Native platform substitutions for common dependencies

Summary

• Ponytail instills "lazy senior dev" philosophy through AGENTS.md (automatic rules) and SKILL.md (interactive, persistent skill)
• Six-step ladder enforces YAGNI, reuse, standard libraries, native features, one-liners, and finally minimal implementation
• Three intensity levels (lite, full, ultra) let users grade the strictness of lazy evaluation
• Platform-native documentation provides concrete substitutions that power step 4 of the ladder
• Agent portability layer ensures the same rules propagate across Claude, Codex, OpenCode, JetBrains, and other hosts without duplication
• Response persistence keeps the ladder active across an entire conversation once enabled

Frequently Asked Questions

What makes Ponytail different from other AI coding tools?

Most tools focus on code generation volume; Ponytail optimizes for code omission. It structures agent behavior as a decision ladder rather than a style guide, with explicit checkpoints that often result in less output. The skill-based persistence also means the philosophy follows the conversation rather than requiring repeated prompts.

Can I use Ponytail with my existing AI agent?

Yes—check docs/agent-portability.md for your specific host. If an adapter exists, you drop the skills/ponytail/ folder or AGENTS.md into your project and the agent consumes the rules automatically. For hosts without native support, you can paste the ladder steps directly into your system prompt as a starting point.

How does the "ultra" intensity level actually behave?

Ultra mode applies requirement skepticism as a first-class behavior. The agent will ask for evidence—profiler output, latency metrics, user complaints—before implementing performance optimizations or new features. It treats "I might need this" as insufficient justification, mirroring senior developers who demand concrete problems before accepting solutions.

Does Ponytail work for languages other than JavaScript/TypeScript?

Yes. While docs/platform-native.md emphasizes web platform APIs, the ladder structure is universal. Steps 1, 2, 5, and 6 apply to any language. For step 3 (standard library) and step 4 (native platform), you would extend or fork platform-native.md with equivalents for Python's standard library, Rust's std, Go's primitives, etc. The SKILL.md architecture accepts these extensions without modification.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}