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

> Discover which Ponytail rules are not mode-conditional. All eleven development rules in AGENTS.md apply universally without runtime flags for consistent development.

- Repository: [DietrichGebert/ponytail](https://github.com/DietrichGebert/ponytail)
- Tags: api-reference
- Published: 2026-09-08

---

**All eleven development rules defined in the [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/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`](https://github.com/DietrichGebert/ponytail/blob/main/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`](https://github.com/DietrichGebert/ponytail/blob/main/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`](https://github.com/DietrichGebert/ponytail/blob/main/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):**

```typescript
// 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):**

```typescript
// 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):**

```typescript
// 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`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md)** – The primary source document containing all eleven universal rules
- **[`README.md`](https://github.com/DietrichGebert/ponytail/blob/main/README.md)** – General project overview and high-level philosophy
- **[`skills/ponytail/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail/SKILL.md)** – Example implementation showing the rules applied to skill development

## Summary

- **All eleven Ponytail rules in [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/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`](https://github.com/DietrichGebert/ponytail/blob/main/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`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) presents these eleven rules as absolute requirements. Even the [`skills/ponytail/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/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`](https://github.com/DietrichGebert/ponytail/blob/main/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.