133K Stars Later: What Leaked AI System Prompts Reveal About Your Tools

What happened

A GitHub repository called `system-prompts-and-models-of-ai-tools`, maintained by user x1xhlol, has become one of the fastest-growing repos on the platform — amassing over 133,000 stars. The repo does exactly what the name says: it collects and publishes the full system prompts, internal tool definitions, and model configurations from over 30 commercial AI coding assistants and general-purpose AI tools.

The list reads like the entire AI tooling landscape in one directory: Cursor, Windsurf, Claude Code, Augment Code, Devin AI, Junie, Replit, Lovable, Manus, Perplexity, v0, Copilot (via VSCode Agent), Warp.dev, Trae, Xcode's AI features, and dozens more. Each entry includes the raw system prompt — the hidden instructions that shape every response the tool generates — along with notes on which models are used under the hood and what internal tools the agent has access to.

This is the largest public collection of proprietary AI system prompts ever assembled, and it's growing weekly as contributors reverse-engineer new tools. The repo also includes prompts from non-coding tools like NotionAI, Dia, and Z.ai, making it a comprehensive map of how the industry actually builds AI products behind the curtain.

Why it matters

### The system prompt is the product

For most AI-powered developer tools, the system prompt *is* the core intellectual property. It's where vendors encode their differentiation: how the tool should handle ambiguity, what coding patterns to prefer, when to ask clarifying questions versus guessing, how to manage context windows, and what guardrails to enforce. When you compare Cursor's prompt to Windsurf's prompt to Claude Code's prompt side by side, you're looking at the actual product decisions that determine your daily experience.

What the prompts reveal is that the gap between AI coding tools is less about model quality and more about prompt engineering, tool integration, and context management. Several tools use the same underlying models (Claude 3.5 Sonnet, GPT-4o, or Gemini) but produce meaningfully different outputs because their system prompts take fundamentally different approaches to code generation.

For example, some prompts are aggressively opinionated — instructing the model to prefer specific frameworks, avoid certain patterns, or always include error handling. Others are deliberately minimal, deferring to the user's style. Some include elaborate multi-step reasoning chains; others rely on the base model's capabilities. The architectural choices are laid bare.

### The transparency question

The repo raises uncomfortable questions for vendors. Several of the extracted prompts contain instructions that users might find surprising: hidden context about what data is collected, instructions to avoid mentioning competitors, or constraints on what the tool will refuse to do. None of this is malicious per se — every product has design decisions — but the gap between marketing copy and actual system behavior is sometimes wider than users expect.

The community reaction has been split: some developers see this as essential transparency for tools that operate on their codebases, while vendors argue these prompts are proprietary configurations that were never meant to be public. The legal standing is murky. System prompts aren't traditional source code, and extracting them typically involves prompt injection techniques or inspecting network traffic — methods that may violate terms of service but aren't clearly illegal.

The 133K stars suggest where the developer community lands on this debate. For a profession built on open source, the idea that the instructions governing your AI pair programmer should be secret doesn't sit well.

### What the prompts actually teach you

Beyond the drama, the repo is genuinely educational. Reading system prompts from well-engineered tools is a masterclass in prompt engineering at scale. You can see how Cursor handles multi-file edits, how Devin structures its agent loop, how Replit manages the boundary between code generation and code execution. These are production-tested prompts handling millions of requests per day.

Several patterns emerge across the best prompts:

- Explicit tool definitions — the highest-performing tools give the model structured descriptions of available tools (file read, file write, terminal, search) rather than relying on the model to figure it out - Step-by-step reasoning gates — many prompts include explicit instructions to "think before acting" or "plan before coding," essentially hard-coding chain-of-thought - Error recovery instructions — production prompts anticipate failure modes and include specific recovery strategies, something most individual developers skip in their own prompts - Context window management — the best prompts include instructions for how to handle large codebases that exceed context limits, including summarization strategies and file prioritization

What this means for your stack

If you're building with AI coding tools, this repo is immediately useful in three ways.

First, tool selection. Reading the system prompts gives you a more honest comparison of AI coding tools than any benchmark or review. You can see whether a tool's approach to code generation aligns with how you actually work. If you care about test-driven development, check whether the system prompt mentions tests. If you work in a monorepo, look at how the tool handles multi-file context.

Second, custom instructions. Most AI coding tools now support user-level configuration files (`.cursorrules`, `CLAUDE.md`, `.github/copilot-instructions.md`). Understanding the base system prompt tells you what's already there so you can write additive instructions rather than conflicting ones. If the system prompt already says "prefer TypeScript," you don't need to repeat it — but you might need to override its default test framework preference.

Third, building your own. If you're integrating AI into internal tools or building AI-powered features, these prompts are battle-tested reference implementations. The patterns for tool use, error handling, and context management have been refined across millions of interactions. Studying them is the fastest way to skip the first six months of prompt engineering mistakes.

Looking ahead

The system prompt arms race is just getting started. As this repo demonstrates, anything you put in a system prompt will eventually be extracted. Vendors will likely respond in two ways: moving more logic out of prompts and into code (tool definitions, retrieval systems, fine-tuning), and accepting that prompt transparency is inevitable and competing on execution instead. The tools that win won't be the ones with the most clever hidden instructions — they'll be the ones with the best infrastructure around the model. For developers, the takeaway is simple: your AI tools have no secrets. Read the manual that was never supposed to be public.