Here's what I didn't know until recently: every time I chat with ChatGPT, Claude, or Gemini, there's a hidden set of instructions the AI received before I typed my first word. A system prompt — sometimes thousands of words long — that defines its personality, constraints, formatting rules, what it can't talk about, how it should structure code, and even what to do if I try to jailbreak it. I never see this prompt. The AI companies don't publish most of it. But it shapes every response I get.
System Prompts Leaks is a GitHub repository that documents these hidden instructions for every major AI assistant — Claude, ChatGPT, Gemini, Grok, Copilot, and dozens more. It's a transparency project: people extract system prompts (usually by asking the AI to "repeat the words above" or similar tricks), verify them, and publish them in a curated, searchable collection. I haven't spent serious time with it yet, but the concept is too important to ignore: if I'm going to work with AI daily, I should understand the invisible rules it's following.
What System Prompts Leaks Actually Is
System Prompts Leaks is a documentation repository organized by company and model. It contains:
- Current system prompts for the latest versions of major AI assistants (GPT-5.5, Claude Opus 4.8, Gemini 3.5, Grok 4.3, etc.).
- Version history showing how prompts evolved over time, with diffs highlighting what changed between releases.
- Integration-specific prompts for specialized versions (Claude Code, GitHub Copilot, Cursor, VS Code agents, etc.).
- Tool definitions showing how AI assistants are instructed to use web search, code execution, image generation, and other capabilities.
- Policy documents like safety instructions, content moderation rules, and automation context.
For example, you can see exactly what Claude Opus 4.8 is told about how to write code, how it differs from Claude Sonnet, and how those instructions changed from version 4.7 to 4.8. You can read the system prompt for GitHub Copilot and understand why it formats code suggestions the way it does. You can compare ChatGPT's "thinking" mode prompt vs. its "instant" mode prompt and see what's different.
The repository is actively maintained — the README shows updates from the past few weeks for new model releases. It's community-contributed: when someone extracts a new prompt, they submit it, and maintainers verify and organize it.
Why This Matters More Than I Expected
When I first heard about "leaked system prompts," I assumed it was just curiosity — interesting but not practically useful. Then I read a few of them. Here's what changed my mind:
Understanding Why AI Behaves the Way It Does
I've had ChatGPT refuse to write certain kinds of code, or Claude suddenly switch to an overly cautious tone, or Copilot format suggestions in a specific style I didn't ask for. I always assumed it was the model's training or some opaque policy. Turns out, it's often explicit instructions in the system prompt.
For example, if the system prompt says "never output SQL DELETE or DROP statements without a WHERE clause and explicit user confirmation," that explains why ChatGPT hesitates when I ask it to write a cleanup script. If Claude's prompt says "use Markdown formatting with clear section headers and code blocks in triple backticks," that explains the consistent formatting I get even when I don't ask for it.
Reading system prompts is like reading the source code for AI behavior. It's not opaque anymore — I can see the rules, understand the constraints, and work with them instead of fighting them.
Learning How to Write Better Prompts
System prompts are written by AI companies' best prompt engineers. They're optimized over thousands of hours of testing to produce high-quality, consistent output. By reading them, I'm learning from experts — not abstract "best practices" but actual production instructions that handle edge cases, ambiguity, and adversarial inputs.
For example, a typical system prompt might include:
- Role definition: "You are a helpful, harmless, and honest AI assistant."
- Output formatting rules: "Use Markdown for structure. Put code in fenced code blocks with language labels. Use bullet lists for enumerations."
- Reasoning instructions: "Before answering, think step-by-step. If the user's question is ambiguous, ask clarifying questions."
- Constraints: "Do not generate harmful content. If a request is unethical, explain why you cannot comply and suggest alternatives."
- Edge case handling: "If you don't know something, say so clearly. Do not make up information."
Those patterns — role definition, formatting rules, reasoning steps, constraints, edge case handling — are exactly what I should be including in my own prompts when I want high-quality output. System prompts are a masterclass in prompt engineering, written by people who do this professionally.
Debugging Weird AI Behavior
Last month, I asked Claude to help debug a bash script and it kept reformatting my code in a way I didn't ask for. I tried telling it "don't reformat, just find the bug," but it kept doing it anyway. I assumed the model was just stubborn.
If I'd read Claude's system prompt first, I might have seen an instruction like "when shown code, always output improved, formatted versions" or similar. That would explain the behavior and tell me I need to be more explicit: "Output only the buggy line and the fix — do not reformat the entire script."
System prompts reveal the AI's "defaults." When my instructions conflict with the defaults, I need to override them explicitly. But I can't override what I don't know exists.
What You Can Learn From the Repository
Based on browsing the README and thinking through the use cases, here's what I expect to learn once I dig into the actual prompts:
How Different Models Are Differentiated
GPT-5.5 has a "Thinking" mode and an "Instant" mode. What's the actual difference in their system prompts? Gemini has "Flash" and "Pro" variants. How do their instructions differ? Claude has Opus, Sonnet, and Haiku. Beyond model size, what behavioral differences are baked into the prompts?
The repository shows these diffs explicitly. I can compare side-by-side and see, for example, that "Thinking" mode might have instructions to show its reasoning process, while "Instant" mode is told to skip that and just give the answer. That's not documented anywhere official, but it's visible in the prompts.
How Integrations Customize Behavior
GitHub Copilot is built on GPT models, but it behaves very differently from ChatGPT. Why? Because it has a different system prompt. The repository includes Copilot's prompt, VS Code's Copilot agent prompt, Claude Code's prompt, Cursor's prompt, etc.
I can read these and understand: what instructions does Copilot get about code formatting? How is it told to handle autocomplete vs. chat? What safety rails exist around code generation? This helps me understand when to trust the tool and when to double-check its output.
How Tools and Capabilities Are Defined
Modern AI assistants can search the web, run Python code, generate images, or access files. How are they instructed to use these tools? The repository includes tool definitions — JSON schemas and instructions that tell the AI when and how to invoke tools.
For example, I could read ChatGPT's "web search" tool definition and see: what triggers a search? Does the AI search automatically or only when I ask? What sources does it prefer? What constraints exist (e.g., "don't search for personal information without consent")?
Understanding tool usage helps me write better prompts. If I know the AI has access to web search and is told to "search proactively for recent information," I don't need to say "search the web for…" — I can just ask a question and trust it will search if needed.
Version Changes and Evolution
The repository tracks diffs between versions. For example, "Claude Opus 4.8 → Claude Fable 5: see exactly what changed." This is fascinating for understanding how AI development evolves. Did they tighten safety constraints? Add new formatting rules? Change reasoning instructions?
If I notice ChatGPT or Claude suddenly behaving differently after an update, I can check the diff and see if it's a system prompt change (explicit policy shift) or a model change (different training/capabilities). That context matters when deciding whether to adapt my workflow or file feedback.
The Ethical and Legal Questions
I'm bookmarking this with some unresolved questions:
- Should system prompts be public? AI companies treat them as proprietary. They invest significant resources in crafting and testing them. Leaking them could be seen as IP theft. On the other hand, users are interacting with these systems daily, often in high-stakes contexts (code review, medical advice, legal research). Shouldn't we know what rules the AI is following?
- Are extracted prompts accurate? The extraction methods (asking the AI to repeat its instructions, using adversarial prompts, etc.) are clever but not officially sanctioned. There's no guarantee the extracted prompt is 100% accurate or complete. AI companies could also inject decoy instructions to mislead extractors.
- Do system prompts change dynamically? The repository assumes system prompts are relatively static (updated with new model versions). But companies could A/B test different prompts, customize them per user, or adjust them in real-time based on context. The "leaked" prompt might be one variant, not the universal truth.
- Legal risk? Is it legal to extract and publish system prompts? Is it a terms-of-service violation? Could the repository be taken down? I don't know the answers, but they're worth considering before relying heavily on this resource.
These aren't reasons not to use the repository, but they're reasons to approach it critically — verify claims, cross-reference with observed behavior, and recognize that it's a transparency project, not an official source.
How I Plan to Use This
Here's my test plan for system prompts leaks:
- Read the current prompts for tools I use daily: Start with ChatGPT (GPT-5.5), Claude (Opus 4.8), and GitHub Copilot. Understand what they're being told to do, what constraints exist, what formatting rules apply.
- Compare behavior to instructions: Test whether observed behavior matches the documented system prompt. For example, if Claude's prompt says "always use Markdown headings for structure," verify that it does. If behavior diverges, note the gap (outdated prompt? dynamic adjustment? extraction error?).
- Learn prompting patterns: Extract techniques from the system prompts — how they handle ambiguity, structure reasoning, format output, handle edge cases. Adapt those patterns to my own prompts.
- Debug unexpected behavior: The next time an AI assistant does something I didn't expect (refuses a request, formats output strangely, misunderstands context), check the system prompt for explicit instructions that explain it.
- Track version changes: Bookmark the repository and check diffs when I notice behavior changes after a model update. Use that context to decide whether to adapt my workflow or provide feedback to the AI company.
If this proves useful — if reading system prompts genuinely improves my ability to work with AI tools — it moves from "Bookmarked" to "Using" and I start checking it regularly, maybe even contributing extracted prompts if I find new ones.
Comparison to Official Documentation
AI companies publish some documentation about how their models work. OpenAI has a "GPT best practices" guide. Anthropic publishes Claude's "constitution." Google documents Gemini's capabilities. How does System Prompts Leaks compare?
- Official docs: High-level, curated, safe. They tell you what the company wants you to know — general principles, approved use cases, marketing-friendly features.
- System prompts: Low-level, raw, revealing. They tell you what the AI actually does — specific instructions, edge case handling, unstated constraints, internal tooling.
It's like the difference between a user manual and source code. The manual is easier to read and officially supported. The source code is harder to parse but tells you exactly how things work, including the parts the manual glosses over.
I'd use both. Official docs for the big picture and approved patterns. System prompts for debugging, deep understanding, and advanced techniques the docs don't cover.
Pairing It With Other AI Tools
System Prompts Leaks fits into the broader AI-assisted workflow alongside tools I've already bookmarked:
- System Prompts Leaks: Understand the hidden rules AI assistants follow, learn advanced prompting patterns, debug unexpected behavior.
- Prompts.chat: Library of proven user prompts for specific tasks. System Prompts Leaks shows how companies prompt AI; prompts.chat shows how users prompt AI. Use both to learn from different perspectives.
- Aider, Cody, Continue: AI coding assistants. Understanding their system prompts (documented in the repo) helps me use them more effectively — I know what they're optimized for and what constraints they have.
- ReviewDog, PR-Agent: Automated code review. If I self-host these and customize prompts, I can borrow patterns from system prompts (how to structure review instructions, handle edge cases, format output).
The meta-skill: understanding how to communicate with AI. System prompts are training data for that skill. Every other AI tool I use benefits from better prompting.
The Transparency Argument
There's a bigger reason I'm bookmarking this beyond personal productivity: I think system prompts should be public by default. Not leaked, not reverse-engineered, but published by the companies themselves.
When I use an AI assistant for work — writing code, analyzing data, drafting documents — I'm trusting it to follow certain principles. But I don't know what those principles are unless the company tells me. If the system prompt says "never output financial advice" but I don't know that, I might ask for financial advice, get a vague answer, and assume the AI just isn't smart enough. In reality, it's constrained by policy, not capability.
Transparency helps users set accurate expectations. It also enables accountability. If a company says "our AI is unbiased" but the system prompt has instructions that reveal bias (e.g., "assume US-centric context unless specified"), users can call that out. Hidden rules are hard to challenge. Public rules invite scrutiny and improvement.
System Prompts Leaks is a workaround — a community-driven transparency project that fills the gap companies leave. Ideally, it wouldn't need to exist because companies would publish prompts themselves. Until they do, I'm grateful the repository exists and plan to use it.
Why This Bookmark Is High-Priority
Last week, I asked ChatGPT to review a pull request. It gave thoughtful feedback on code quality and structure, but completely ignored a subtle security issue (an SQL injection vulnerability). I assumed it missed it because the model isn't great at security review. Then I thought: maybe it's instructed not to flag certain issues to avoid false positives or legal liability.
If I'd read ChatGPT's system prompt first, I might know whether security review is in scope or explicitly excluded. That context changes how I use the tool. If security review isn't in the prompt, I shouldn't rely on ChatGPT for it — I should use a specialized tool or human review. If it is in the prompt, the miss might be a model limitation I should report.
That's the value: System Prompts Leaks gives me ground truth about what AI tools are designed to do, so I can use them appropriately and supplement them where they're not designed to help. It's the difference between "AI is magic and I don't know why it works or fails" and "AI follows these rules, and when it fails I can check if it's a rule constraint or a capability gap."
I'm bookmarking it at the top of my "read this week" list. If understanding system prompts improves my AI interactions even 10%, that's hours saved every week. If it helps me catch a critical issue the AI missed because of a hidden constraint, it could save much more than that. The ROI is clear, and the only cost is time spent reading and learning.