# What Are the Available Mode Intensity Levels in Ponytail?

> Discover Ponytail's four intensity levels: off, lite, full, and ultra. Control AI optimization aggressiveness to suit your needs. Learn more about Ponytail's flexible settings.

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

---

**Ponytail supports four runtime intensity levels—off, lite, full, and ultra—that control how aggressively the AI applies "lazy senior-dev" optimization rules, with full set as the default.**

The DietrichGebert/ponytail repository implements a coding assistant that enforces YAGNI principles through configurable mode intensity levels. These settings determine whether the tool silently builds features, challenges requirements, or disables itself entirely. Understanding the available intensity levels allows developers to control the trade-off between automation and manual oversight.

## The Four Mode Intensity Levels in Ponytail

Ponytail operates on a spectrum of intervention intensity defined in the core module. Each level dictates how strictly the assistant enforces code minimalism and requirement validation.

**Off**  
When set to off, Ponytail injection is completely disabled. The assistant reverts to standard behavior without applying any lazy senior-dev rules or alternative suggestions.

**Lite**  
In lite mode, the system builds what the user requests but also proposes a lazier one-line alternative. The user retains explicit control to choose between the original implementation and the more concise option.

**Full**  
As the default intensity defined in [`__init__.py`](https://github.com/DietrichGebert/ponytail/blob/main/__init__.py), full mode applies the complete ladder of checks: YAGNI → stdlib → native → installed dependency → one-line → minimum code. This represents the standard "lazy senior-dev" experience.

**Ultra**  
The ultra setting pushes optimization to the extreme. It prefers deletion before addition, challenges the requirement before building, and automatically selects the most concise possible solution.

## Source Code Definitions of Mode Intensity Levels

The canonical list of runtime modes is defined in [`__init__.py`](https://github.com/DietrichGebert/ponytail/blob/main/__init__.py) at lines 11-13:

```python

# https://github.com/DietrichGebert/ponytail/blob/main/__init__.py#L11-L13

DEFAULT_MODE = "full"
RUNTIME_MODES = {"off", "lite", "full", "ultra"}
CONFIG_MODES = RUNTIME_MODES | {"review"}   # “review” is a config‑only mode, not an intensity level

```

While `CONFIG_MODES` includes an additional `"review"` option, this is strictly a configuration mode and not available as a runtime intensity level. The human-readable behavior descriptions are documented in [`skills/ponytail/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail/SKILL.md) at lines 8-30, which confirm that full is the default and describe the progressive laziness from lite through ultra.

## How to Configure Mode Intensity Levels

Users can switch between intensity levels through three mechanisms: slash commands, environment variables, or configuration files.

**Slash Commands**

Within any chat where Ponytail is registered, type:

```text
/ponytail lite      # set to lite

/ponytail           # show current level

/ponytail off       # disable Ponytail

```

**Environment Variables**

Set `PONYTAIL_DEFAULT_MODE` to affect new sessions:

```bash
export PONYTAIL_DEFAULT_MODE=ultra   # or lite / full / off

```

**Configuration File**

Create or edit `~/.config/ponytail/config.json` to persist settings across restarts:

```json
{
  "defaultMode": "lite"
}

```

## Querying the Current Mode Programmatically

Developers can inspect the active intensity level by importing the internal state variables from the main package:

```python

# Example: programmatically query the current mode

from ponytail import _current_mode, _default_mode
print("Current mode:", _current_mode or _default_mode())

# → Current mode: full

```

This reads the runtime state, falling back to the default configuration when no session-specific override exists.

## Summary

- Ponytail provides four distinct mode intensity levels: **off**, **lite**, **full**, and **ultra**.
- The **full** mode serves as the default, implementing the complete YAGNI optimization ladder.
- Constants `RUNTIME_MODES` and `DEFAULT_MODE` are defined in [`__init__.py`](https://github.com/DietrichGebert/ponytail/blob/main/__init__.py) at lines 11-13.
- The **review** mode exists only in `CONFIG_MODES` and cannot be used as a runtime intensity level.
- Users can switch modes via slash commands (`/ponytail`), the `PONYTAIL_DEFAULT_MODE` environment variable, or the `~/.config/ponytail/config.json` file.

## Frequently Asked Questions

### What is the default mode intensity level in Ponytail?

The default intensity level is **full**. This is hardcoded in [`__init__.py`](https://github.com/DietrichGebert/ponytail/blob/main/__init__.py) as `DEFAULT_MODE = "full"` and applies the complete ladder of lazy senior-dev checks unless overridden by environment variables or user commands.

### What is the difference between lite and ultra mode intensity levels?

Lite mode builds the requested feature while offering a one-line alternative for the user to choose. Ultra mode aggressively challenges requirements, prefers deleting code over adding it, and automatically selects the most minimal solution without prompting for confirmation.

### Can I use review mode as a runtime intensity level?

No. While `CONFIG_MODES` in [`__init__.py`](https://github.com/DietrichGebert/ponytail/blob/main/__init__.py) includes `"review"` alongside the standard set, this is strictly a configuration-only mode. Only **off**, **lite**, **full**, and **ultra** are valid runtime intensity levels available for live switching.

### How do I permanently set Ponytail to use lite mode?

Set the `defaultMode` key in `~/.config/ponytail/config.json` to `"lite"`, or export `PONYTAIL_DEFAULT_MODE=lite` in your shell profile. The config file approach persists across system restarts without requiring environment setup.