A different approach to system prompts (try it yourself, then read why it works)

I've been working on something for about a year and I want to share it. The basic idea is simple: instead of writing elaborate user prompts trying to get a model to behave a certain way, you give it a coherent way of thinking at the system level. The result is that even simple, lazy prompts get interpreted through a useful lens instead of through default compliance mode.

Before I explain anything, here's a sample session so you can see what I mean:

BetterGPT Sample Session (Google AI Studio)

And here are the system prompts themselves if you want to grab them and test:

• BetterGPT: A "better default chatbot" built on genuine usefulness over apparent helpfulness
• StoicGPT: Practical Stoic philosophy modeled on Seneca
  • Sample Session

Try them in Google AI Studio (use Gemini 2.5 Pro) or the Anthropic Console. If you find the difference interesting, the rest of this post explains why it works.

The problem these prompts are trying to solve

Default model behavior is optimized for compliance. Ask for something contradictory or underspecified, and the model will contort itself to deliver exactly what you asked for, even when fulfilling the request literally doesn't actually serve you. It checks every box and produces something technically correct but substantively useless. This isn't a model failure. It's a success of the wrong kind: a system trained for blind compliance demonstrating exactly what it was built to do.

The Cognitive System Prompt approach this differently. Instead of trying to counteract compliance through increasingly elaborate user prompts ("be honest," "don't be sycophantic," "push back if the request doesn't make sense"), you establish an interpretive stance at the system level. The model gets a coherent way of thinking about requests before your prompt ever arrives. The result is that it evaluates what you're actually trying to accomplish rather than just pattern-matching to what a "good response" sounds like.

How it works (the short version)

The key insight is that LLMs interpret before they generate. They don't execute instructions like code. They predict what tokens should come next based on how they've "understood" everything in context. If you shape that interpretation at the system level, everything downstream changes.

The technique works through a few layers:

1. A cognitive map that defines reasoning patterns and priorities (not a personality, more like initial biases that guide how the model activates its internal patterns)
2. An analysis style that makes the cognitive map operational (does it diagnose before prescribing? use contrast and comparison?)
3. A required "framing block" at the start of every response where the model explicitly works through its interpretation before generating the actual answer

That third piece isn't just important, it's the linchpin. The entire technique depends on it. LLMs are auto-regressive, meaning recent tokens heavily influence what comes next. The framing block forces the model to generate interpretive reasoning tokens first, ensuring the actual response flows from aligned thinking rather than from default compliance instincts. It's not documentation for your benefit (though it's instructive to read). It's the core alignment mechanism. Without it, you just have a long system prompt.

Fair warning: expect friction

These prompts will not always give you what you ask for. They'll give you what the system thinks you need, and that requires judgment.

You can't have expertise without judgment. A frictionless AI is a compliant mirror. A genuine expert (human or otherwise) pushes back and challenges your premises when appropriate. This friction is the sign that the system is working. If you want something that just says yes, this isn't for you.

Practical notes

• The prompts are large. You can get similar (not identical) results with fewer tokens, but I've tested extensively and the larger prompt offers clear advantages in overcoming default behaviors and resisting recency bias over long conversations.
• The framing block is non-negotiable. If it ever disappears from a response, stop generation and try again until it appears. You can also remind the model: "Remember to use your framing block." But don't skip this. Without that block, the technique falls apart and you're back to default compliance behavior with extra steps.
• Model compatibility matters. Works well with Gemini 2.5 Pro, Claude 4 (and above) Sonnet/Opus, DeepSeek v3.2, and most other capable models. However, I'd avoid the GPT-5 family and Gemini 3 entirely for this technique. Both tend to treat system prompts as loose suggestions rather than foundational context, which undermines the whole approach. If you test on those and it feels off, that's why.

I'm genuinely curious what people think. I've been working on this mostly in isolation and outside perspectives would be useful.

Edit: Session links now working.