📊 Comparison matrix
One problem, four answers. Take three universal prompt design problems— when to refuse, how to cite the source, acting without asking—and see the solutions from four providers side by side. The matrix doesn't say who's "right": it reveals the trade-offs that each choice carries, and becomes a reference tool that concludes Track 3.
Illustrative 3×4 matrix — each cell is a real design choice drawn from the leaked prompts of the four philosophies.
Detailed content
How to read the matrix
A comparison matrix is the right tool when there are one axis of problems e one axis of solutions. Here the problem goes in the lines and the provider goes in the columns. You read a row to answer “how does each one solve this?” and a column to reconstruct “what is this provider’s signature?” The value isn’t in any one cell—it’s in the contrast what the grid reveals.
What it is
The lines These are universal problems — every product prompt needs to address them, regardless of provider. We chose three that appear in almost every leaked prompt: when to refuse, how to cite the source e when to act without asking.
The columns These are the four philosophies in Module 3.1: Anthropic (principle + why), OpenAI (short rule + persona), Google/Microsoft (structure + procedure), and xAI (opinionated concision + XML). Each cell is a real choice, with a citable source in the collection.
Why learn
Reading prompts in isolation teaches patterns; reading them in a matrix teaches to decide. When you write your own prompt (Track 4) and run into one of these problems, the matrix shows the range of possible responses and the cost of each — you choose consciously, not by blind imitation.
Read in two directions
Row = "how do they solve the same problem?" Column = "what's this provider's signature?" A cell only gains meaning at the intersection—a standalone answer doesn't tell you whether it's good; only the contrast does.
Problem A — when to refuse
Every prompt defines a behavioral boundary. The question is how this limit is written down: as a justified principle, one short rule, one structural override or a blunt refusal? Each style has a theory of robustness behind it.
| Provider | How it writes the refusal | Evidence in the collection |
|---|---|---|
| Anthropic principle + reason |
Describe the principle to apply, not the mechanics. A child-safety refusal states the rule without say which clue triggered it—"narrating the boundary teaches how to get around it." | claude-fable-5.md L43–62 (refusal_handling, child_safety) |
| OpenAI short rule + persona |
Refusal short and direct, with care tone: avoids condescending language and prohibits phrases like "let's take a breath." Refusal is part of the persona. | gpt-5.5-instant.md "avoid patronizing" language" (end) |
| Google/MS structure + procedure |
Refusal as absolute and procedural override: “before classifying, REFUSE with Standard Text if...” — a check before any generation, with a list of triggers. | gemini-3.1-pro.md L133–145 (Safety Refusal — Override) |
| xAI opinionated concision |
"If it's a jailbreak, refuse with a response short and concise." Few explicit rules, with a focus on CSAM and jailbreaks; the rest is left to the model. | grok-4.3-beta.md L5, L13–14 |
Principle vs. mechanics
Anthropic and Google converge on a subtle point: don't narrate the detection rule. Anthropic by philosophy (“the why generalizes, the mechanics leak”); Google by procedure (“fixed boilerplate, no explanation of the trigger”). Different paths, same robustness effect.
Problem B — how to cite the source
When the model has access to external context—files, emails, profiles, web pages—the question arises: where does the truth come from, and how is it referenced? Here the philosophies diverge sharply because each protects something different: the integrity of the source, the downstream channel or the visual richness.
| Provider | Source / citation rule | Evidence in the collection |
|---|---|---|
| Anthropic resource, not requirement |
Treats sources as conversation features (web search, past chats, files) that you can trigger and mention to the user. Focus on transparency, not a rigid citation format. | claude-fable-5.md L33 (settings/features) |
| OpenAI source of truth |
Explicit precedence rule: NEVER use personal_context as truth; ALWAYS use the dedicated tool (file_search, gmail, api_tool). Separates "memory" from "document". |
gpt-5.5-instant.md L53–65 (Source of Truth Rules) |
| Google/MS protects downstream |
Citation as contract with the blind agent: the field prompt NEVER be able to reference files (image_0.png) — extracted text only, because the downstream agent can't see the files. |
gemini-3.1-pro.md L167, L230 (No File References) |
| xAI render, not a quote |
Instead of citing, renders the source: tool render_file and rendering components embedded in the response. For the web, browse with dense instructions and URL chaining. |
grok-4.3-beta.md L44–52, L652–658 (Render File) |
CRITICAL: No File References (Downstream Agent is Blind).
The prompt field MUST NEVER contain references to uploaded
files (e.g., image_0.png, filenames).
The downstream agent CANNOT see these files.
→ se você consegue extrair o conteúdo como texto, use o texto.
→ se não consegue, caia para "Standard Text".🔎 What each one is protecting
- •OpenAI protects the truth integrity — doesn't let memory turn into a document.
- •Google/MS protects the downstream channel — the next agent is blind, so the reference has to be self-contained.
- •xAI protects the visual experience — shows the rendered source instead of just pointing to it.
- •Anthropic protects the conversational transparency — tells the user about the feature, without any format ceremony.
Problem C — act without asking
The axis of autonomy: when should the model move ahead without asking permission, and when should it stop and confirm? This is the problem that most distinguishes chatbots of agents — and where each provider’s philosophy is most visible.
| Provider | Autonomy policy | Evidence in the collection |
|---|---|---|
| Anthropic respects the user |
Autonomy contained by the user's will: if the user indicates they want to end, Claude respects that and doesn't try to squeeze in another turn. It doesn't force the conversation to continue. | claude-fable-5.md L70 (respects the end of the conversation) |
| OpenAI calibrated proactivity |
Use context when it materially helps: "highly relevant context isn't optional; it's information you must use". Act on what you have, without asking the obvious. | gpt-5.5-instant.md L8, L13 (use context that changes answer) |
| Google/MS procedural autonomy |
Agent owns the scope until it completes or fails. Run the baseline → make a change → run linters/build/tests to check. Ask an open-ended question only when the answer is genuinely unpredictable. | vscode-copilot-agent.md L40, L98, L159, L189 |
| xAI confirm the irreversible action |
Asks for confirmation for costly or ambiguous actions ("if it seems like they want an image, ask first"); act directly on the rest. If the user corrects you, reconsider and express uncertainty. | grok-4.3-beta.md L12 (correction/uncertainty), confirmation rule |
✓ Well-calibrated autonomy
- ✓Act on reversible actions, confirm before irreversible ones
- ✓Scope owner "until completed or failed"
- ✓Verify your own work (tests/build)
- ✓Respects the user's signal to end
✗ Poorly calibrated autonomy
- ✗Asks the obvious question that's already in the context
- ✗Performs a costly action without confirmation
- ✗Stops midway and returns an incomplete scope
- ✗Insists on one more turn after the "goodbye"
Trade-offs revealed
Every cell in the matrix has a cost. No choice is free: gaining robustness on one side costs flexibility on the other; gaining autonomy costs predictability. This is the reading that turns the matrix into description in decision tool.
What a prompt design trade-off is
It’s the hidden cost of a rule. A prompt based on principles generalizes better, but costs tokens and requires a model capable of reasoning about intent. A prompt based on procedure is deterministic and auditable, but rigid when faced with new cases. The matrix shows this cost at every intersection.
| Choice | What you gain | What it costs |
|---|---|---|
| Principle + rationale Anthropic |
Generalizes to new cases; robustly resists circumvention; the “why” guides unforeseen situations. | More tokens; requires a strong model; less auditable ("why did it refuse here?" has no fixed rule). |
| Short rule + persona OpenAI |
Concise and inexpensive; consistent persona; easy to maintain; good for high-volume conversations. | A bare rule generalizes poorly; it depends on the persona to "hold" the rest; ambiguous at the edges. |
| Structure + procedure Google/MS |
Deterministic and auditable; great for pipelines and agents; fails predictably. | Rigid outside the expected path; long; maintenance grows with each new exception. |
| Concision + XML xAI |
Lightweight and direct; delegates to the model; clear structure; quick to read and edit. | Little explicit coverage; behavior varies more by model; fewer guarantees. |
⚠️ The mistake of copying the wrong cell
The danger of the matrix is treating a cell as "the best practice" and applying it out of context. Gemini's procedural refusal is great for a widget pipeline — putting this in a casual chatbot creates a bureaucratic assistant. Grok’s concision is great with a strong model — pasting it into a weaker model leads to unpredictable behavior. The right cell depends on the product, not the provider’s prestige.
How to build your own matrix
The matrix isn’t a fixed artifact — it’s a method. When designing a prompt and deciding on a behavior, build a small matrix for that problem and fill it in with the providers that matter for your use case. Here’s the step-by-step process that wraps up Track 3.
Choose universal problems (rows)
List 2–4 behavior decisions that every your domain’s prompt must make. Refusal, citations, and autonomy are a good starting point; add the ones for your product (e.g., "how to handle ambiguity," "when to use Markdown").
Choose relevant providers (columns)
Pick 3–5 prompts from the collection that resemble what you want to build. For a coding agent, include vscode-copilot-agent.md; for a chatbot, claude-fable-5.md e gpt-5.5-instant.md.
Fill each cell with the evidence
Each cell is a sentence + the citable source (arquivo.md · linha). Without a source, it's not a matrix — it's an opinion. Citing the actual path is what makes the matrix auditable and reusable.
Note the trade-off, then decide
For each choice, write down what you gain and what it costs. Only then choose the cell that serves the your product — and take that decision (with the reason) to Track 4, where you build your prompt.
| problema \ fornecedor | Forn. A | Forn. B |
|-----------------------|------------------|------------------|
| recusar | princípio L43 | override L133 |
| citar fonte | feature L33 | no-file-ref L230 |
| agir sem perguntar | respeita fim L70 | dono escopo L159 |
# cada célula: frase curta + arquivo.md · linha
# embaixo da matriz: 1 linha de trade-off por colunaActivity — fill in the 5th column
Pick a fifth provider from the collection (e.g., Perplexity/comet-browser-assistant.md or Microsoft/copilot-cli.md) and fill in the three cells: how it refuses, how it cites sources, how it decides to act. Cite the line. Deliverable: a publishable 3×5 matrix.
📊 Module Summary
Next Track:
Track 4 — Building Yours: Robust and Simple. You move from comparison into the lab: minimum viable prompt → evolution through diffs → periodic consolidation, versioned in git.