Which Ponytail Rules Are Not Mode-Conditional? The Complete AGENTS.md Reference

All eleven development rules defined in the AGENTS.md file of the DietrichGebert/ponytail repository are non-mode-conditional, meaning they apply universally without runtime flags, environment variables, or build configuration toggles.

The Ponytail coding philosophy establishes invariant constraints rather than configurable guidelines. According to the source code in AGENTS.md, these permanent rules enforce radical simplicity and deliberate engineering across every development context, from local debugging to production deployment.

What Makes Ponytail Rules Non-Mode-Conditional

Unlike typical linting configurations or feature flags that activate based on NODE_ENV or CI pipeline stages, the Ponytail rules are hardcoded principles. They reside in the repository root's AGENTS.md file and function as architectural invariants.

The non-mode-conditional nature means:

• No environment variables gate rule enforcement
• No build modes (development vs. production) alter the constraint set
• No conditional logic in the source code activates or deactivates specific guidelines

The 11 Permanent Ponytail Rules in AGENTS.md

The following rules from AGENTS.md are always active and never mode-conditional:

1. No Unrequested Abstractions

Avoid creating abstractions that were not explicitly requested. This prevents architectural overhead from speculative generalization.

2. Zero New Dependencies

Do not introduce new dependencies if the functionality can be avoided or implemented with existing code.

3. No Unsolicited Boilerplate

Only add code that is explicitly required. Remove templates and scaffolding that serve no immediate purpose.

4. Deletion Over Addition

Prefer removing code to adding it. Choose boring implementations over clever ones. Minimize the total file count.

5. Shortest Working Diff

The smallest change that solves the problem wins, but only after fully understanding the problem space.

6. Question Complexity

When faced with complex requests, ask: "Do you actually need X, or does Y cover it?"

7. Edge-Case-Correct Stdlib Selection

When two standard library approaches require equal code size, pick the one that handles edge cases correctly. Laziness means less code, not fragile algorithms.

8. Document Deliberate Simplifications

Mark intentional shortcuts that cut corners—such as global locks, O(n²) scans, or naive heuristics—with a ponytail: comment naming the ceiling and upgrade path.

9. Non-Lazy Critical Areas

Do not be lazy regarding: understanding the problem fully, input validation at trust boundaries, error handling preventing data loss, security, accessibility, hardware calibration (accounting for clock drift and sensor variance), or anything explicitly requested.

10. Mandatory Sanity Checks

Non-trivial logic must leave exactly one runnable check behind—the smallest assertion or test that fails if the logic breaks. No frameworks or fixtures required. Trivial one-liners need no test.

11. Trivial One-Liners Exempt

Simple, obvious one-line statements do not require dedicated tests.

Practical Code Examples

These universal rules manifest in concrete coding decisions throughout the repository.

Avoiding Unnecessary Abstraction (Rule 1):

// Preferred: Direct use of existing utility
const sum = numbers.reduce((a, b) => a + b, 0);

// Violation: Extra wrapper adding no value
function calculateTotal(nums: number[]) {
  return nums.reduce((a, b) => a + b, 0);
}

Preferring Built-ins Over Dependencies (Rule 2):

// Preferred: Native URLSearchParams
const params = new URLSearchParams(queryString);

// Violation: Unnecessary external library
import qs from 'qs';
const params = qs.parse(queryString);

Shortest Working Diff (Rule 5):

// Before: Multiple fixes scattered across functions
function processA() { /* validation logic */ }
function processB() { /* same validation logic */ }

// After: Single shared helper (smallest working diff)
function validateInput(input: unknown) {
  if (!input) throw new Error('Invalid input');
}

Source File Locations

The non-mode-conditional rules are defined and demonstrated across these key files in the DietrichGebert/ponytail repository:

• AGENTS.md – The primary source document containing all eleven universal rules
• README.md – General project overview and high-level philosophy
• skills/ponytail/SKILL.md – Example implementation showing the rules applied to skill development

Summary

• All eleven Ponytail rules in AGENTS.md are non-mode-conditional and apply universally across all environments
• These constraints prioritize deletion over addition, built-ins over dependencies, and simplicity over cleverness
• Rules are enforced through code review and developer discipline, not runtime configuration or environment variables
• The ponytail: comment syntax marks intentional technical debt and documents upgrade paths
• Critical areas including security, accessibility, and hardware calibration fall under permanent, non-negotiable standards

Frequently Asked Questions

What distinguishes mode-conditional from non-mode-conditional rules?

Mode-conditional rules activate based on runtime environment variables, build configurations, or feature flags. In contrast, the Ponytail rules defined in AGENTS.md are static constraints that apply identically whether you are in development, testing, or production. They represent invariant coding standards rather than situational guidelines.

Are there any exceptions to these rules in the Ponytail codebase?

No exceptions are documented in the source files. The AGENTS.md presents these eleven rules as absolute requirements. Even the skills/ponytail/SKILL.md implementation follows them strictly, suggesting they function as architectural invariants rather than suggestions.

How do Ponytail rules interact with external dependencies?

Rules 2 and 7 specifically govern dependency usage. Rule 2 mandates avoiding new dependencies entirely when possible, while Rule 7 requires selecting the most robust standard library option when code size is equivalent. These constraints apply regardless of whether the project is a greenfield application or legacy maintenance.

Can teams customize Ponytail rules for specific projects?

The rules in AGENTS.md are not configurable within the repository structure. Since they are defined as static markdown documentation rather than a settings file or configuration object, modifying them requires forking the repository and maintaining a separate version of the guidelines. The source code treats these as universal constants.

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