# Comprehensive Guide to Ponytail Modes: Full, Lite, Ultra, and Specialized Variants > Explore Ponytail modes like Full, Lite, and Ultra for LLM prompt control. Inject rulesets for coding behavior from minimalism to security auditing with this comprehensive guide. - Repository: [DietrichGebert/ponytail](https://github.com/DietrichGebert/ponytail) - Tags: deep-dive - Published: 2026-09-04 --- **Ponytail provides eight distinct modes—including full, lite, ultra, review, audit, debt, and gain—that inject predefined rulesets into LLM prompts to control coding behavior from aggressive minimalism to security auditing.** The **DietrichGebert/ponytail** repository implements a "lazy senior dev" agent system where **Ponytail modes** determine how aggressively the assistant applies YAGNI principles and code analysis strategies. Each mode corresponds to a specific ruleset defined in dedicated skill files that automatically inject into every LLM call when active. ## Understanding the Core Ponytail Modes The foundation of Ponytail's behavior rests on four primary modes defined in [`skills/ponytail-help/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail-help/SKILL.md). These control the fundamental coding philosophy applied during your session. ### Full Mode (Default) **Full mode** represents the classic "lazy senior dev" approach and serves as the default configuration for new sessions. This mode encourages **YAGNI** (You Aren't Gonna Need It), prioritizes standard-library solutions, and pushes for minimal-code implementations that reuse existing codebase assets. The ruleset defined in [`skills/ponytail-help/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail-help/SKILL.md) emphasizes writing the least possible code to solve the immediate problem. ### Lite Mode **Lite mode** offers a less-opinionated variant of the lazy-senior-dev philosophy. While it maintains guidance toward efficient solutions, it applies a milder tone and reduced pressure for extreme minimalism. Use this mode when you want architectural guidance without the aggressive "write less code" enforcement present in full mode. ### Ultra Mode **Ultra mode** represents the most aggressive setting in the Ponytail ecosystem. It instructs the LLM to generate the absolute minimal code possible, even when doing so sacrifices readability or maintainability. This mode excels for quick-and-dirty scaffolding, prototypes, or situations where code volume matters more than elegance. ### Off / Normal Mode The **off** mode (also referenced as **normal** mode) completely disables Ponytail's behavioral modifications, returning the LLM to its vanilla behavior without lazy-senior-dev constraints. Activate this using the `stop ponytail` command or `/ponytail normal` to bypass all ruleset injections. ## Specialized Ponytail Modes for Code Analysis Beyond the core behavioral modes, Ponytail ships with four specialized modes targeting specific code analysis domains. Each resides in its own skill directory with dedicated prompt templates. ### Review Mode **Review mode** switches the agent into a code-review mindset defined in [`skills/ponytail-review/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail-review/SKILL.md). Rather than writing new code, the model focuses on critiquing existing implementations, suggesting improvements, identifying bugs, and evaluating architectural decisions. This mode excels for pull request reviews and legacy code analysis. ### Audit Mode **Audit mode** transforms the agent into a security specialist, defined in [`skills/ponytail-audit/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail-audit/SKILL.md). This ruleset emphasizes threat modeling, dependency-risk analysis, injection vulnerability detection, and hardening suggestions. Use this mode when scanning codebases for security flaws or reviewing authentication flows. ### Debt Mode **Debt mode** adopts a technical-debt perspective as specified in [`skills/ponytail-debt/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail-debt/SKILL.md). The model surfaces areas requiring refactoring, identifies over-engineered solutions, suggests simplification opportunities, and highlights abstraction improvements. This mode helps prioritize refactoring efforts in mature codebases. ### Gain Mode **Gain mode** activates a performance-optimization mindset defined in [`skills/ponytail-gain/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail-gain/SKILL.md). The ruleset directs the model to suggest algorithmic improvements, profiling strategies, memory-efficiency gains, and execution speed optimizations. Apply this mode when working with performance-critical paths or resource-constrained environments. ## How to Switch Between Ponytail Modes Ponytail provides multiple interfaces for mode switching, with persistence handled through filesystem flags and command parsing. ### Session-Based Commands Switch modes immediately for the current session using slash commands or aliases: ```javascript // Activate ultra-aggressive minimalism await runCommand('/ponytail ultra'); // Switch to code review mode await runCommand('/ponytail review'); // Disable Ponytail entirely await runCommand('stop ponytail'); ``` The system also supports `@ponytail ` syntax as an alternative invocation pattern. ### Setting Persistent Defaults Configure default startup behavior using the `default` subcommand: ```javascript // Set lite mode as the default for all future sessions await runCommand('/ponytail default lite'); ``` This writes the preference to a configuration file in the user's Claude directory, typically stored as `.ponytail-active`. ### Mode Resolution and Injection The mode persistence and injection system relies on two critical components. The **ponytail-mode-tracker** hook ([`hooks/ponytail-mode-tracker.js`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/ponytail-mode-tracker.js)) reads the active mode flag from `.ponytail-active` and writes updates when commands change the state. For the MCP server implementation, [`ponytail-mcp/instructions.js`](https://github.com/DietrichGebert/ponytail/blob/main/ponytail-mcp/instructions.js) contains the `resolveMode` and `buildInstructions` functions that map the current mode flag to the correct ruleset and construct the final prompt template injected into LLM calls. ## Summary - **Ponytail modes** are predefined rulesets that control LLM behavior from aggressive minimalism to specialized analysis. - **Core modes** include **full** (default YAGNI enforcement), **lite** (milder guidance), **ultra** (extreme minimalism), and **off** (disabled). - **Specialized modes** comprise **review** (code critique), **audit** (security analysis), **debt** (refactoring identification), and **gain** (performance optimization). - Mode definitions reside in [`skills/ponytail-help/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail-help/SKILL.md) for core behaviors and individual skill files ([`skills/ponytail-review/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail-review/SKILL.md), etc.) for specialized variants. - The **ponytail-mode-tracker** hook manages state persistence to `.ponytail-active`, while [`ponytail-mcp/instructions.js`](https://github.com/DietrichGebert/ponytail/blob/main/ponytail-mcp/instructions.js) implements `resolveMode` and `buildInstructions` for prompt construction. - Switch modes via `/ponytail ` for sessions or `/ponytail default ` for permanent configuration. ## Frequently Asked Questions ### What is the default Ponytail mode when starting a new session? **Full mode** is the default configuration for new sessions unless you have explicitly set a different default using `/ponytail default `. According to the [`skills/ponytail-help/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail-help/SKILL.md) specification, this mode applies the classic "lazy senior dev" ruleset emphasizing YAGNI principles and minimal-code solutions immediately upon initialization. ### How do I permanently change my default Ponytail mode? Execute `/ponytail default ` (for example, `/ponytail default lite`) to store your preference in the user configuration. The **ponytail-mode-tracker** hook writes this selection to the `.ponytail-active` file in your Claude directory, ensuring all future sessions initialize with your chosen mode rather than the standard full mode default. ### Which Ponytail mode should I use for security code reviews? Use **audit mode** for security-focused analysis. Defined in [`skills/ponytail-audit/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail-audit/SKILL.md), this mode injects rulesets emphasizing threat modeling, dependency-risk analysis, and vulnerability detection. Unlike review mode (which focuses on general code quality), audit mode specifically targets security hardening and potential attack vectors. ### Where does Ponytail store the active mode configuration? Ponytail persists the active mode to a file named `.ponytail-active` located in the user's Claude directory. The [`hooks/ponytail-mode-tracker.js`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/ponytail-mode-tracker.js) file handles both reading this flag on session startup and updating it when mode changes occur, while [`ponytail-mcp/instructions.js`](https://github.com/DietrichGebert/ponytail/blob/main/ponytail-mcp/instructions.js) uses this value to resolve the correct prompt instructions via the `resolveMode` function.