How Ponytail Enforces the 'Lazy Senior Developer' Discipline

Ponytail embeds the lazy senior developer philosophy into AI agents through a three-layer enforcement system that filters prompts by intensity level, injects a YAGNI decision ladder into every request, and persists the discipline across sessions.

The Ponytail repository implements a rigorous code generation framework that treats efficiency as a constraint rather than an afterthought. By enforcing the lazy senior developer discipline, Ponytail ensures AI agents prioritize minimal solutions before writing new code. This enforcement operates through a tightly-coupled architecture of skill definitions, dynamic instruction builders, and runtime mode resolution.

The Three-Layer Enforcement Architecture

Ponytail's enforcement mechanism relies on three integrated layers that transform philosophical guidelines into hard runtime constraints.

Skill Definition in SKILL.md

The foundation resides in skills/ponytail/SKILL.md, which serves as the single source of truth for the discipline. This markdown file declares the intensity ladder—ranging from YAGNI to minimal code—and defines three enforcement levels: lite, full, and ultra. The file also contains the canonical prompt opening: "You are a lazy senior developer. Lazy means efficient, not careless. The best code is the code never written."

Dynamic Instruction Building

The hooks/ponytail-instructions.js module implements the instruction builder pattern. The getPonytailInstructions(mode) function reads SKILL.md, invokes filterSkillBodyForMode() to strip irrelevant content, and returns a complete prompt injected into every request. If the skill file is unreadable, the builder falls back to a static prompt block that maintains the discipline's core constraints.

Configuration and Mode Resolution

Runtime behavior is governed by hooks/ponytail-config.js, which resolves the active mode through getDefaultMode(). This function checks the PONYTAIL_DEFAULT_MODE environment variable, falls back to a JSON configuration file, and ultimately defaults to full intensity. The module exposes normalizeMode() for input validation and writeDefaultMode() for persisting changes across sessions.

Runtime Enforcement Flow

The discipline is not merely documented—it is programmatically enforced through a six-stage pipeline that activates on every request.

Mode Resolution and Initialization

When Ponytail initializes, getDefaultMode() executes a cascading lookup: first checking process.env.PONYTAIL_DEFAULT_MODE, then a local configuration file, and finally settling on full as the default. This ensures the intensity level is determined before any code generation begins.

Content Filtering by Intensity

The filterSkillBodyForMode() function in ponytail-instructions.js implements the core enforcement logic. It parses the intensity table from SKILL.md and removes rows and code examples that exceed the current mode's threshold. In lite mode, the agent sees only lite-compatible constraints, while ultra mode exposes the complete ladder including aggressive minimalism checks.

Prompt Injection and the YAGNI Ladder

Every processed request receives the filtered prompt containing the six-rung ladder: YAGNI → stdlib → native feature → dependency → one-liner → minimal code. This sequence forces the agent to justify each escalation in complexity. The prompt is prepended to the user's request via the hook integration, making the discipline non-optional.

Persistence and Deactivation Safety

The active mode persists across responses until explicitly changed. The isDeactivationCommand() helper prevents accidental shutdowns by requiring exact matches for commands like stop ponytail or normal mode. This safeguard ensures the discipline remains active unless deliberately disabled.

Implementing the Discipline in Practice

Developers interact with Ponytail's enforcement through specific API functions exposed by the configuration and instruction modules.

Retrieving the current prompt:

const { getPonytailInstructions } = require('./hooks/ponytail-instructions');
const prompt = getPonytailInstructions(process.env.PONYTAIL_DEFAULT_MODE);
// Returns filtered SKILL.md content plus the ladder text

Changing modes programmatically:

const { writeDefaultMode } = require('./hooks/ponytail-config');
writeDefaultMode('lite');   // Persists for future sessions

Checking for deactivation:

const { isDeactivationCommand } = require('./hooks/ponytail-config');
if (isDeactivationCommand(userMessage)) {
  // Handle mode transition or shutdown
}

Tooling Integration and Documentation

Beyond runtime enforcement, the discipline is documented redundantly across the repository. The AGENTS.md file provides human-readable explanations of the philosophy, referenced by .windsurf/rules/ponytail.md and .cursor/rules/ponytail.mdc. This distribution ensures that both human reviewers and integrated development tools respect the same constraints as the runtime system.

Summary

• Lazy senior developer discipline is enforced through a three-layer architecture: skill definitions, instruction builders, and configuration management.
• The SKILL.md file serves as the canonical source for intensity levels and the YAGNI ladder.
• getPonytailInstructions() filters content by mode and injects the discipline into every AI request.
• Modes (off, lite, full, ultra) control which rungs of the complexity ladder the agent must consider.
• The system persists mode selections across sessions and requires explicit deactivation commands to prevent accidental disablement.
• Redundant documentation in AGENTS.md and editor-specific rule files ensures consistent enforcement across tooling.

Frequently Asked Questions

What defines the "lazy senior developer" philosophy in Ponytail?

The philosophy treats efficiency as a hierarchy of preferences, codified in skills/ponytail/SKILL.md. It mandates that agents consider existing standard library functions, native language features, and minimal solutions before generating new code, following the principle that the best code is the code never written.

How does filterSkillBodyForMode enforce different intensity levels?

The function parses the markdown table in SKILL.md and strips rows, code examples, and constraints that exceed the current mode's threshold. In lite mode, aggressive minimization rules are hidden, while ultra mode exposes the complete enforcement ladder including strict YAGNI compliance checks.

Can I switch enforcement modes during an active session?

Yes. The writeDefaultMode() function in hooks/ponytail-config.js persists mode changes immediately, and subsequent calls to getPonytailInstructions() will filter content according to the new intensity level. The system checks mode resolution on each request initialization.

What happens if the SKILL.md file is corrupted or missing?

If getPonytailInstructions() cannot read SKILL.md, it falls back to a static prompt block containing the canonical lazy developer statement and basic ladder constraints. This ensures the discipline remains active even when the primary skill definition is unavailable.

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