# How to Integrate Ponytail with AI Coding Platforms: Complete Setup Guide

> Integrate Ponytail with AI coding platforms using plugins or rule files. Enhance LLM prompts with six core skills. Configure via config.json for lite, full, or ultra modes. Complete setup guide available.

- Repository: [DietrichGebert/ponytail](https://github.com/DietrichGebert/ponytail)
- Tags: how-to-guide
- Published: 2026-09-03

---

**Ponytail integrates with AI coding platforms through platform-specific plugins or rule files that inject its six core skills into LLM prompts, configurable via `~/.config/ponytail/config.json` in lite, full, or ultra modes.**

Ponytail is a "lazy senior dev" engine developed in the `DietrichGebert/ponytail` repository that enhances AI-assisted coding environments with structured review and guidance capabilities. The integration architecture centers on six distinct skills located in the `skills/` directory—`ponytail`, `ponytail-review`, `ponytail-audit`, `ponytail-debt`, `ponytail-gain`, and `ponytail-help`—which platforms load through adapters documented in [`docs/agent-portability.md`](https://github.com/DietrichGebert/ponytail/blob/main/docs/agent-portability.md).

## Core Integration Architecture

Every Ponytail integration follows a consistent three-phase pattern regardless of the target platform.

### The Three Integration Steps

1. **Install the plugin or copy rule files** – Platforms with marketplace support use [`plugin.json`](https://github.com/DietrichGebert/ponytail/blob/main/plugin.json), [`plugin.yaml`](https://github.com/DietrichGebert/ponytail/blob/main/plugin.yaml), or [`marketplace.json`](https://github.com/DietrichGebert/ponytail/blob/main/marketplace.json) manifests to fetch the six skills. Others require manually copying `.md` or `.mdc` rule files into project-specific directories.
2. **Configure the operating mode** – Set `lite`, `full`, or `ultra` mode in `~/.config/ponytail/config.json` or the platform-specific configuration location. Switch modes at runtime using the `/ponytail` slash command.
3. **Invoke skills** – Type `/ponytail` (or `/ponytail-review`, `/ponytail-audit`, etc.) in the chat interface, or allow the platform to automatically inject the ruleset into every LLM request through hooks.

## Platform-Specific Integration Guides

### Grok Build

Grok Build uses a native plugin system that references the `skills/` directory directly without additional adapter code.

Install via the Grok CLI:

```bash
grok plugin install DietrichGebert/ponytail --trust
grok plugin enable ponytail

```

After enabling, the `/ponytail` command becomes available in Grok's coding-task skill interface. The marketplace entry is defined in [`plugin.json`](https://github.com/DietrichGebert/ponytail/blob/main/plugin.json) (or [`.grok-plugin/marketplace.json`](https://github.com/DietrichGebert/ponytail/blob/main/.grok-plugin/marketplace.json)).


### OpenCode

OpenCode requires an ECMAScript module plugin placed in `.opencode/plugins/ponytail.mjs` and command registration in `.opencode/command/`.

Integration steps:

```bash

# Inside your OpenCode project directory

npm install ponytail

# Restart the server to load the experimental.chat.system.transform hook

```

The server restart activates the `experimental.chat.system.transform` hook, which injects the Ponytail ruleset into every chat turn. The `/ponytail` switch persists across sessions according to [`docs/agent-portability.md`](https://github.com/DietrichGebert/ponytail/blob/main/docs/agent-portability.md).


### pi (Python Extension)

The pi platform uses a Python-based extension mechanism with entry points in `pi-extension/`.

Installation command:

```bash
pip install ponytail-pi

```

The extension automatically registers a per-turn instruction builder. Invoke Ponytail by typing `/ponytail` in any pi session.


### Hermes Agent

Hermes employs a YAML-based plugin manifest ([`plugin.yaml`](https://github.com/DietrichGebert/ponytail/blob/main/plugin.yaml)) alongside Python initialization code ([`__init__.py`](https://github.com/DietrichGebert/ponytail/blob/main/__init__.py)).

Setup commands:

```bash
hermes plugin add ponytail
hermes plugin enable ponytail

```

The plugin rewrites gateway commands (`/ponytail-*`) into LLM prompts and registers all six skills with the Hermes gateway.


### Cursor

Cursor utilizes rule files that reside in the `.cursor/rules/` directory.

Steps:

1. Copy `ponytail.mdc` to `.cursor/rules/ponytail.mdc` in your project root.
2. Restart Cursor.

The rule operates in always-on mode; type `/ponytail` in the prompt to switch between operating modes.


### Windsurf and Cline

Both Windsurf and Cline use Markdown-based rule files placed in specific configuration directories.

File locations:

- **Windsurf**: [`.windsurf/rules/ponytail.md`](https://github.com/DietrichGebert/ponytail/blob/main/.windsurf/rules/ponytail.md)
- **Cline**: [`.clinerules/ponytail.md`](https://github.com/DietrichGebert/ponytail/blob/main/.clinerules/ponytail.md)

Copy the appropriate rule file into the respective directory and reload the IDE to activate the integration.


### GitHub Copilot CLI

Copilot CLI uses a plugin directory structure at `.github/plugin/` and falls back to [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) for instruction-tier guidance.

Installation:

```bash
copilot plugin marketplace add DietrichGebert/ponytail
copilot plugin install ponytail@ponytail

```

The plugin injects the complete ruleset into Copilot CLI sessions. The fallback instruction mode also functions when [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) is present in the repository root.


### Swival

Swival manages skills through a dedicated directory structure at `.swival/skills/`.

Installation command:

```bash
swival skills add https://github.com/DietrichGebert/ponytail

# Optional: Add --global to install library-wide

```

Swival reads [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) for global fallback instructions when specific skills are not explicitly invoked.


### VS Code with Codex Extension

The VS Code Codex extension automatically detects instruction files at the repository root.

No plugin installation is required. Simply ensure [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) exists in your repository root; the Codex extension reads this file automatically on startup.


### Kiro

Kiro implements "steering" rules placed in a dedicated configuration directory.

Steps:

1. Copy [`ponytail.md`](https://github.com/DietrichGebert/ponytail/blob/main/ponytail.md) to [`.kiro/steering/ponytail.md`](https://github.com/DietrichGebert/ponytail/blob/main/.kiro/steering/ponytail.md) in your project (or global Kiro configuration directory).
2. The steering rule becomes active immediately.


### Qoder

Qoder uses a JSON plugin manifest ([`.qoder-plugin/plugin.json`](https://github.com/DietrichGebert/ponytail/blob/main/.qoder-plugin/plugin.json)) with separate hook definitions in [`hooks/qoder-hooks.json`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/qoder-hooks.json).

Installation:

```bash
qoder plugin install ponytail

```

The plugin automatically registers [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) and the six-skill set. Commands `/ponytail`, `/ponytail-review`, `/ponytail-audit`, `/ponytail-debt`, `/ponytail-gain`, and `/ponytail-help` become available immediately after installation.


## Code Implementation Examples

The following snippets demonstrate the technical implementation for three representative platforms. All paths are relative to the repository root.

### OpenCode Server Plugin

Create `.opencode/plugins/ponytail.mjs` to inject rules on every turn:

```javascript
import { createServer } from "http";
import { experimental } from "opencode";

experimental.chat.system.transform = async (msg) => {
  // Inject Ponytail ruleset on each turn
  const ponytail = await import("./.opencode/plugins/ponytail.mjs");
  return ponytail.injectRules(msg);
};

createServer((req, res) => {
  // Normal request handling
}).listen(3000);

```

This hook ensures every LLM request includes the Ponytail instruction set regardless of user input.


### GitHub Copilot CLI Configuration

Define the plugin and commands in [`copilot.toml`](https://github.com/DietrichGebert/ponytail/blob/main/copilot.toml):

```toml
[plugins]
pony = { source = "github.com/DietrichGebert/ponytail", version = "latest" }

[commands]
ponytail = "run /ponytail"
ponytail-review = "run /ponytail-review"
ponytail-audit = "run /ponytail-audit"
ponytail-debt = "run /ponytail-debt"
ponytail-gain = "run /ponytail-gain"
ponytail-help = "run /ponytail-help"

```

This configuration maps slash commands to the six core skills defined in [`skills/ponytail/SKILL.md`](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail/SKILL.md) and related files.


### Qoder Hook Definitions

Configure automatic injection in [`hooks/qoder-hooks.json`](https://github.com/DietrichGebert/ponytail/blob/main/hooks/qoder-hooks.json):

```json
{
  "UserPromptSubmit": [
    { "action": "injectPonytailRules", "target": "prompt" }
  ],
  "PreToolUse": [
    { "matcher": "task|Task", "action": "activatePonytailSkill" }
  ]
}

```

These hooks automatically prepend the Ponytail ruleset before each LLM call and activate skills when specific tool patterns are detected.


## Summary

- **Integration follows three steps**: Install the plugin or copy rule files, configure the mode in `~/.config/ponytail/config.json`, and invoke via `/ponytail` commands or automatic injection.
- **Six core skills**: `ponytail`, `ponytail-review`, `ponytail-audit`, `ponytail-debt`, `ponytail-gain`, and `ponytail-help` reside in the `skills/` directory and provide the complete "lazy senior dev" functionality.
- **Three operating modes**: Switch between **lite**, **full**, and **ultra** modes at runtime to control instruction verbosity and analysis depth.
- **Universal fallback**: The [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) file at the repository root provides instruction-tier integration for platforms like VS Code Codex, Swival, and GitHub Copilot CLI that support automatic markdown ingestion.
- **Platform-specific paths**: Each platform uses distinct configuration locations—from `.cursor/rules/ponytail.mdc` to [`.kiro/steering/ponytail.md`](https://github.com/DietrichGebert/ponytail/blob/main/.kiro/steering/ponytail.md)—as documented in [`docs/agent-portability.md`](https://github.com/DietrichGebert/ponytail/blob/main/docs/agent-portability.md).


## Frequently Asked Questions

### What are the three Ponytail operating modes and how do they differ?

The three modes—**lite**, **full**, and **ultra**—control the depth of analysis and instruction injection. Lite mode provides minimal context for quick queries, full mode enables the complete ruleset with all six skills, and ultra mode adds verbose logging and step-by-step reasoning chains. Configure the default in `~/.config/ponytail/config.json` and switch at runtime using `/ponytail`.


### Which file serves as the universal fallback for platforms without native plugin support?

**[`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md)** at the repository root functions as the instruction-tier fallback. Platforms including VS Code with Codex, Swival, and GitHub Copilot CLI automatically read this file to load Ponytail instructions when no plugin architecture is available.


### Can I use Ponytail simultaneously across multiple AI coding platforms on the same project?

Yes. Because Ponytail stores configuration in `~/.config/ponytail/config.json` and uses project-specific rule files (like `.cursor/rules/ponytail.mdc` or [`.clinerules/ponytail.md`](https://github.com/DietrichGebert/ponytail/blob/main/.clinerules/ponytail.md)), you can enable it in Cursor, Windsurf, and GitHub Copilot CLI simultaneously without conflicts. The shared [`AGENTS.md`](https://github.com/DietrichGebert/ponytail/blob/main/AGENTS.md) file ensures consistent behavior across all platforms.


### How do I install Ponytail on a platform that lacks a marketplace or package manager?

For platforms without marketplace support (such as Cursor, Windsurf, or Kiro), manually copy the appropriate rule file from the repository into the platform's designated configuration directory. For example, copy `ponytail.mdc` to `.cursor/rules/` or [`ponytail.md`](https://github.com/DietrichGebert/ponytail/blob/main/ponytail.md) to `.windsurf/rules/`, then restart the IDE. These rule files are available in the `DietrichGebert/ponytail` repository under their respective paths.