Where to Find the Core Ruleset for Ponytail: Complete File Location Guide

Ponytail's core "lazy senior dev" ruleset is stored as identical Markdown files in three locations: .windsurf/rules/ponytail.md, .qoder/rules/ponytail.md, and .clinerules/ponytail.md, depending on the host environment.

This guide shows you exactly where to locate the core ruleset for Ponytail in the DietrichGebert/ponytail repository. Whether you're integrating Ponytail into a new host, debugging behavior, or building a custom adapter, knowing the precise file paths ensures you load the correct "lazy senior developer" guidelines.

Default Ruleset Location for Windsurf

The primary core ruleset for Ponytail lives at .windsurf/rules/ponytail.md. This is the default path used by Windsurf-compatible hosts and most integrations that follow the standard repository structure.

When a host environment initializes Ponytail, it checks this location first. The file contains the complete behavioral guidelines that shape Ponytail's terse, efficiency-focused persona.

Alternative Ruleset Locations by Platform

Ponytail maintains three identical copies of its ruleset to support different host environments. Each serves the same single source of truth but resides in a directory recognized by its respective platform:

• .windsurf/rules/ponytail.md — Windsurf and compatible hosts
• .qoder/rules/ponytail.md — Qoder platform integration
• .clinerules/ponytail.md — Generic CLI and terminal adapters

All three files are kept in sync to ensure consistent behavior across platforms.

How to Load the Ruleset Programmatically

Node.js Implementation

Use a fallback chain to locate the core ruleset for Ponytail without hard-coding a single path:

import { readFile } from "fs/promises";
import path from "path";

async function loadRuleset() {
  const repoRoot = path.resolve(import.meta.dirname, "..");
  const locations = [
    ".windsurf/rules/ponytail.md",
    ".qoder/rules/ponytail.md",
    ".clinerules/ponytail.md",
  ];

  for (const rel of locations) {
    const abs = path.join(repoRoot, rel);
    try {
      const txt = await readFile(abs, "utf8");
      console.log(`Loaded rules from ${rel}:\n`, txt);
      return txt;
    } catch {}
  }
  throw new Error("Ponytail ruleset not found");
}

loadRuleset().catch(console.error);

Python Implementation

For Python-based hosts or plugins, traverse the same priority order:

import pathlib

def get_ruleset():
    repo_root = pathlib.Path(__file__).parent.parent
    for rel in [".windsurf/rules/ponytail.md",
                ".qoder/rules/ponytail.md",
                ".clinerules/ponytail.md"]:
        p = repo_root / rel
        if p.is_file():
            return p.read_text(encoding="utf-8")
    raise FileNotFoundError("Ponytail ruleset missing")

rules = get_ruleset()
print(rules[:200])

Both implementations follow the recommended priority: Windsurf location first, then Qoder, then CLI fallback.

Verifying Ruleset Identity

All three files contain identical content. To confirm you're viewing the authentic core ruleset for Ponytail, check for these characteristic elements:

• "Lazy senior developer" persona definition
• Concise, no-nonsense behavioral guidelines
• Efficiency-first coding principles

If your loaded file deviates from this structure, you may have a corrupted or outdated copy.

Summary

• Primary location: .windsurf/rules/ponytail.md for standard hosts
• Qoder users: .qoder/rules/ponytail.md
• CLI adapters: .clinerules/ponytail.md
• All three paths contain identical, interchangeable rulesets
• Implement fallback loading in your host for portability

Frequently Asked Questions

What happens if multiple ruleset files exist?

Only one file is needed. Host implementations typically check .windsurf/rules/ponytail.md first, then fall back to .qoder/rules/ponytail.md and finally .clinerules/ponytail.md. The first readable file wins—subsequent files are ignored.

Can I customize the ruleset for my own use?

You're free to modify a local copy, but changes won't persist upstream. For project-specific behavior, wrap Ponytail's core rules with additional context rather than editing the base files directly.

Why are there three identical files instead of one shared location?

Each host environment (Windsurf, Qoder, generic CLI) scans a conventional directory for its rules. Maintaining three copies ensures zero-configuration loading across platforms without requiring hosts to know about each other's conventions.

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