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

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.

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, plugin.yaml, or 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:

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 (or .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:

# 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.

pi (Python Extension)

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

Installation command:

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) alongside Python initialization code (__init__.py).

Setup commands:

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
• Cline: .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 for instruction-tier guidance.

Installation:

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 is present in the repository root.

Swival

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

Installation command:

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

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

Swival reads 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 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 to .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) with separate hook definitions in hooks/qoder-hooks.json.

Installation:

qoder plugin install ponytail

The plugin automatically registers 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:

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:

[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 and related files.

Qoder Hook Definitions

Configure automatic injection in hooks/qoder-hooks.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 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—as documented in 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 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), you can enable it in Cursor, Windsurf, and GitHub Copilot CLI simultaneously without conflicts. The shared 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 to .windsurf/rules/, then restart the IDE. These rule files are available in the DietrichGebert/ponytail repository under their respective paths.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}