# Complete Guide to Ponytail Slash Commands: Available Commands and Usage

> Explore the six Ponytail slash commands: /ponytail, /ponytail-review, /ponytail-audit, /ponytail-gain, /ponytail-debt, and /ponytail-help. Learn their usage and functionality for efficient workflow.

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

---

**Ponytail exposes six primary slash commands—`/ponytail`, `/ponytail-review`, `/ponytail-audit`, `/ponytail-gain`, `/ponytail-debt`, and `/ponytail-help`—registered programmatically in [`pi-extension/index.js`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/index.js) and defined declaratively via TOML configuration files in the `commands/` directory.**

The DietrichGebert/ponytail repository provides a modular AI assistant framework that surfaces functionality through standardized **Ponytail slash commands**. These commands operate through the Pi extension API and as file-based definitions consumed by Claude and Gemini adapters, enabling users to toggle analysis intensity levels and invoke specialized code review skills directly from chat interfaces.

## Available Ponytail Slash Commands

Ponytail ships with six distinct slash commands that provide both system control and skill invocation capabilities. According to the source code in [`pi-extension/index.js`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/index.js) (lines 14-71), the following commands are registered via `pi.registerCommand`:

- **`/ponytail`** — The primary control command that switches Ponytail intensity levels (`lite`, `full`, `ultra`, `off`) or queries current status. Registered at lines 14-47.

- **`/ponytail-review`** — Invokes the *ponytail-review* skill for code analysis. Registered at lines 49-52.

- **`/ponytail-audit`** — Triggers the *ponytail-audit* skill for security and quality auditing. Registered at lines 54-57.

- **`/ponytail-gain`** — Executes the *ponytail-gain* skill. Registered at lines 59-62.

- **`/ponytail-debt`** — Runs the *ponytail-debt* skill for technical debt assessment. Registered at lines 64-67.

- **`/ponytail-help`** — Displays help documentation via the *ponytail-help* skill. Registered at lines 69-72.

Each skill-specific command utilizes the `sendAlias` helper function (defined at lines 1-12) to forward messages to their corresponding skills using the format `/skill:ponytail-review`.

## How Commands Are Registered

The command registration logic resides in [`pi-extension/index.js`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/index.js), where the Pi extension API exposes the `registerCommand` method to bind handlers to command strings.

The implementation distinguishes between the primary toggle command and skill aliases:

```javascript
// Primary command with argument handling (lines 14-47)
pi.registerCommand('ponytail', {
  description: 'Switch Ponytail mode or query status',
  handler: async (args, ctx) => {
    // Handles 'lite', 'full', 'ultra', 'off', 'status'
  }
});

// Skill aliases using sendAlias helper (lines 49-52)
pi.registerCommand('ponytail-review', {
  description: 'Run the ponytail-review skill',
  handler: sendAlias('/skill:ponytail-review')
});

```

The `sendAlias` helper generates a handler that emits the skill invocation message to the underlying AI system, allowing seamless integration with the Pi message bus.

## File-Based Command Definitions

In addition to programmatic registration, Ponytail slash commands are defined declaratively through TOML files in the `commands/` directory. These definitions provide adapter-specific metadata for Claude, Gemini, and other file-based command consumers:

- [`commands/ponytail.toml`](https://github.com/DietrichGebert/ponytail/blob/main/commands/ponytail.toml) — Base command description and prompt templates
- [`commands/ponytail-review.toml`](https://github.com/DietrichGebert/ponytail/blob/main/commands/ponytail-review.toml) — Review skill parameters
- [`commands/ponytail-audit.toml`](https://github.com/DietrichGebert/ponytail/blob/main/commands/ponytail-audit.toml) — Audit skill configuration
- [`commands/ponytail-gain.toml`](https://github.com/DietrichGebert/ponytail/blob/main/commands/ponytail-gain.toml) — Gain skill definition
- [`commands/ponytail-debt.toml`](https://github.com/DietrichGebert/ponytail/blob/main/commands/ponytail-debt.toml) — Debt analysis prompts
- [`commands/ponytail-help.toml`](https://github.com/DietrichGebert/ponytail/blob/main/commands/ponytail-help.toml) — Help system content

This dual-layer approach ensures commands are accessible both through the JavaScript API and static configuration files parsed by adapter implementations.

## Working with Ponytail Slash Commands

### Switching Intensity Modes

Control Ponytail analysis depth programmatically using the Pi API:

```javascript
// Enable maximum analysis depth
await pi.runCommand('ponytail', 'ultra');

// Check current configuration
await pi.runCommand('ponytail', 'status');

```

Valid mode parameters include `lite` (minimal overhead), `full` (standard analysis), `ultra` (comprehensive inspection), and `off` (disabled).

### Invoking Skill Commands

Trigger specific analysis workflows directly:

```javascript
// Execute code review skill
await pi.runCommand('ponytail-review');

// Run security audit
await pi.runCommand('ponytail-audit');

```

These calls route through the `sendAlias` mechanism, translating the command into `/skill:ponytail-review` messages processed by the AI backend.

### Building Custom Integrations

Query Ponytail status within custom extensions:

```javascript
pi.registerCommand('my-tool', {
  description: 'Show current Ponytail mode',
  handler: async (_, ctx) => {
    const result = await pi.runCommand('ponytail', 'status');
    ctx?.ui?.notify(result);
  },
});

```

## Extending the Command Set

To add new **Ponytail slash commands** compatible with file-based adapters, create a TOML file in the `commands/` directory:

```toml

# commands/ponytail-custom.toml

description = "Run custom Ponytail analysis"
prompt = "Execute custom workflow with arguments: {{args}}"

```

After creating the definition, register the corresponding handler in [`pi-extension/index.js`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/index.js) using the `pi.registerCommand` API to enable runtime execution.

## Summary

- Ponytail provides six built-in slash commands: `/ponytail`, `/ponytail-review`, `/ponytail-audit`, `/ponytail-gain`, `/ponytail-debt`, and `/ponytail-help`.
- Command handlers are registered in [`pi-extension/index.js`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/index.js) (lines 14-71) using the Pi extension API.
- The primary `/ponytail` command controls intensity modes (`lite`, `full`, `ultra`, `off`) while other commands trigger specific skills via the `sendAlias` helper.
- Declarative command definitions reside in TOML files under the `commands/` directory for adapter compatibility.
- New commands require both a TOML definition and JavaScript registration in the extension index.

## Frequently Asked Questions

### What is the difference between `/ponytail` and the skill-specific commands?

The **`/ponytail`** command serves as the primary control interface for managing Ponytail's operational mode and intensity level, accepting arguments like `ultra` or `status`. In contrast, **skill-specific commands** such as `/ponytail-review` or `/ponytail-audit` are aliases that immediately trigger their respective analysis workflows without mode switching, routing directly to skills via the `sendAlias` mechanism in [`pi-extension/index.js`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/index.js).

### How do I check the current Ponytail mode programmatically?

Invoke the status query through the Pi API by passing the `status` argument to the primary command: `await pi.runCommand('ponytail', 'status')`. This returns the current intensity configuration (lite, full, ultra, or off) as implemented in the handler at lines 14-47 of [`pi-extension/index.js`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/index.js).

### Can I add custom slash commands to Ponytail?

Yes. Create a new TOML file in the `commands/` directory with your command definition, then register a corresponding handler in [`pi-extension/index.js`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/index.js) using `pi.registerCommand()`. This dual-definition approach ensures compatibility with both the Pi extension API and file-based adapters like Claude and Gemini.

### Which adapters support these slash commands?

Ponytail slash commands are supported by the **Pi extension API** (JavaScript runtime) and **file-based adapters** that parse TOML definitions, specifically including the Claude and Gemini adapters. The TOML files in `commands/` provide the metadata required for these adapters to expose commands in their respective chat interfaces.