The system prompt, taken from Claude Fable 5 — and which prompting techniques you can adopt from Anthropic
On 9 June 2026, Anthropic opened public access to Claude Fable 5 — a model that stands another notch above the already strong Opus 4.8. Fable 5 has a twin, Claude Mythos 5: technically the same model, the difference lies solely in the safeguarding. Mythos 5 has some protective limits removed, which is why it is available only to approved organizations. Fable 5 is the public variant with built-in protective “classifiers”: on sensitive requests — on cybersecurity, say — the model does not answer directly but hands the answer to a weaker model (at launch that was Claude Opus 4.8).
The protection did not hold long. Researchers at Amazon showed that Fable 5 can still be brought to search for vulnerabilities in code — it is enough to give it a codebase and ask it to “fix errors.” The US government learned of this and imposed export controls on Fable 5 and Mythos 5 on 12 June and blocked access for all persons outside the US. Separating the two models individually did not succeed for Anthropic — so at the time of this text (19 June 2026) they were shut down for everyone.
Shortly before the lockdown, the complete system prompt was pulled from Claude Fable 5. Officially the company publishes only a shortened version; here is a document of around 17,000 words, with detailed instructions on how the model should behave in various situations. This is interesting for two reasons. First, it is fundamentally worth understanding what a system prompt does and how it shapes a model’s answers. Second, it lets you read off how one of the best AI firms in the world writes prompts — and these techniques transfer to working with any AI model.
The complete leaked system prompt of Claude Fable 5 (≈ 17,000 words) is available as a GitHub gist: gist.github.com/Kuberwastaken/bfcf1419… It is an unofficial leak, not confirmed by Anthropic.
What place the system prompt takes in a model’s “structure”
Roughly sketched, the training of an AI model runs like this. First the model goes through pre-training, the phase in which the “raw” content is loaded in. After it follows post-training: a large, costly step in which the model learns, on many examples, to answer as precisely as possible. Here the behavior is tuned at a deep level. The problem: such retraining is slow and expensive, so it is not done constantly.
Only after training does one write the system prompt for the model: a text instruction the model reads at the beginning of every dialogue with a user. In it stand the style and format of the answers, instructions for typical situations, descriptions of the available tools, additional safety limits and so on.
Slow & expensive; redone only rarely.
Changeable by the developers at any time.
After the system prompt, the user-side part begins. If you have deposited your own, permanent user prompt, the model reads it next. If the chat-based memory is active, the list of facts the model gathered about you from earlier conversations follows. If you work within a project, it reads the project description including the attached documents instead. And only after that does the AI read the prompt from the current dialogue.
That means: at the very start of every conversation the model gets a large wall of text with partly contradictory instructions and has to decide which of them takes precedence. Safety limits it sensibly takes from the system prompt. But if a friendly character stands there, and you ask the AI to be cynical, it should orient itself by your request. And if the cynical model gets on your nerves mid-dialogue and you ask it to become factual again, it has to take this new instruction into account and discard the two previous ones.
Connected to this is the problem of context rot, the creeping deterioration of the context. The longer a dialogue runs, the more data and instructions accumulate and the harder it gets for the model to classify everything correctly. In AI agents this can be countered with compaction; in chatbots the effective solution has so far been plainer: create a summary of the chat and start a new dialogue.
A fundamental theme with the system prompt is that the user cannot edit it. Only the developers may change it. Shortened versions of the Claude prompts do stand online, but tracking every change is laborious. To the user, such adjustments end up looking like style changes that seemingly come out of nowhere.
Even if you cannot influence the system prompt, there are a few levers with which you improve the model’s work:
Into the permanent user prompt belongs only what the model should always know about you: name, role, preferred answer style. Do not make it a heap of behavior rules.
Do not tune the model’s “personality” by hand if you can help it. It is appealing at first but harmful in the long run: set the model as a joker, get into a difficult situation, come with a question — and reap an inappropriate joke. If you do want to experiment, some AI products have several predefined characters in the settings. There the switch happens at the level of the system prompt and leads to a cleaner result.
If the chat-based memory is active, make it a rule to look into the settings every few weeks and check what the model remembered about you. Not seldom an AI holds on to old entries — that you are still in your probation period, say, though it has long passed.
How far can a model’s answers be steered at all?
Simplified, the instructions to a model can be sorted into three categories.
The first are limits a user usually cannot lift. But they do not all lie directly in the system prompt: part sits in training, part in the system instructions, part in external classifiers, access rights and the tools themselves. Usually Claude is not forbidden to discuss a sensitive topic at all. The line runs between explanation and practical help that noticeably eases the doing of harm. Also, a technical limit is more reliable than a textual one: if an agent has no right to delete a file or send an email, no user prompt grants it that right.
The second category are soft presets. That is the default behavior: in which style the model answers, how deeply it searches the web, whether it asks follow-ups. The model sticks to what stands in the system prompt — exactly up to the moment you explicitly ask for something else.
The third category are gaps. That is everything no general instruction can know: what you need the result for, who will read it, which decision it should support, what is more important — speed, completeness or precision —, which sources you consider reliable. The system prompt was not written for you and certainly not for today’s task. These gaps no one closes for you.
From this follows: a good request has to do exactly two things. First, switch the soft presets where necessary. Second, fill the gaps and give the model the information it needs for the task.
What Fable 5’s system prompt consists of
Back to the leaked file. It is around 17,000 words, split into dozens of sections, and Anthropic has not officially confirmed it. So let us treat it not as an official guide but as a snapshot of how the steering of such a product can be built.
A considerable part of the file revolves not around Claude’s character but around the product’s structure: search, connected services, file creation, storage, skills and the tools’ schemas. The central rules on tone and communication, by contrast, stand comparatively far forward. So before us lies not just the “model’s personality” but an assembled operating manual for the entire assistant.
The sections are built as named blocks: “how to refuse,” “how to format the answer,” “when to search,” “copyright,” plus descriptions of the connected tools. A mechanic of its own is formed by the skills: before the model builds you a document, a spreadsheet or a presentation, it first reads a separate guide for exactly this kind of work.
By the way, the document is not error-free. There are repetitions, mutually contradictory rules and places where older Claude versions are mentioned.
Peculiarities of Claude worth knowing
Let us look at how Anthropic set its models. I deliberately write “models” in the plural: even though the system prompt is written for Fable 5, the behavior rules described in it lie close to what I see in working with Claude Opus 4.8. The most interesting points follow.
Claude is built for goodwill. It is to meet its counterpart warmly, not consider it stupid and disagree gently. Mostly that is pleasant, but the criticism mode you have to activate yourself. If you need hardness, write it directly: “Don’t sugarcoat the assessment out of politeness; finding all the weaknesses matters more to me than keeping a pleasant impression.”
Claude does not like superfluous formatting. In the prompt it explicitly states to answer in connected text where possible and not dump everything into lists. So if you do want a table or a short list of conclusions at the start, ask for it separately — otherwise you get clean paragraphs.
Claude tries not to make a follow-up into an interrogation. By default it first tries to answer and asks no more than one question at a time. For a simple task that is handy. But if you have something complex planned — a selection, an interview, a draft —, allow it to ask upfront: “Ask all the necessary questions first in one message and do not begin before I have answered.”
Claude estimates how quickly a piece of information ages. Changeable things — current prices, present positions, news — it rather checks on the internet; stable facts it takes from memory. A good habit, but not a full fact-check: a found link shows where the words come from but does not prove the source is right. Which check depth you need, you set yourself — a technique of its own on that shortly.
As a bonus, a curious setting: Claude is forbidden to swear until the user explicitly asks for it or starts it themselves. And even then the model stays measured; if the user overdoes it further, Claude has permission to end the conversation.
A short note for ChatGPT users at the end of this section: OpenAI’s models of course have their own system prompt with different instructions than Claude. ChatGPT’s strength is the detailed personalization settings that change the system prompt on the fly. You can regulate the warmth of the answers and set how often the model uses tables, lists and emoji. In most cases these settings suffice to tailor the model “to yourself.”
Eight techniques you should learn from the pros
Now to the techniques Anthropic builds into its models in one form or another. This chapter is a condensation from the system prompt and the company’s open guides — so the techniques should be used by everyone working with Claude too. Whoever uses other models, all the more.
1. Explain what the result is for
Anthropic explicitly advises giving the model not just the task but also its purpose: who the work is for and what the result should enable. Then the model selects what fits instead of guessing your intent.
Compare: “Analyze these reviews” — and you get an overview in general. “I’m deciding which three product flaws I fix in the next update; group the recurring complaints and estimate which ones most strongly deter people from buying” — and the same AI delivers exactly what you need for the decision. That is not “superfluous context” but the criterion by which the model sorts out the important.
2. Build a source map
Remember the habit of estimating what is outdated? Carry it through yourself. Instead of a vague “check the facts,” you set out where what comes from: “Treat the report in the attachment as the main source; check current prices and positions on the internet; for important conclusions take the primary source or two independent confirmations; do not fill gaps from memory.”
And keep the essential in mind: a link shows where the words come from but does not prove the source is right. Which check depth suffices for you, you alone decide.
3. Separate analysis and action
Decide in advance what you need — an analysis or a finished result — and say it. In the chat: “Assess the document and create a list of changes, leave the file itself untouched for now.” Then you check the list by hand, choose the points you agree with, and give the model the task of changing the document.
4. Say when to ask and when to assume
By default the model sometimes asks a superfluous question, sometimes falls silent and waits. Set the rule yourself: “If a detail does not change the result, make a sensible assumption and name it out loud; ask only when something depends on the result.” And for a task where a conversation is needed first: “Gather all the questions necessary for the work and put them in one message; begin the actual work after my answers.”
5. Describe what “done” means
The most common cause of a mediocre answer is that the model does not know by which features the work is complete. Not “check the answer,” but win conditions: “The work is done when all numbers are reconciled with the sources, the unconfirmed is marked, found contradictions are shown separately, the text has been reviewed for repetitions and a final version is present — no plan for further steps.”
6. Create your own skill for recurring work
If you do one and the same task regularly, do not write a huge prompt from scratch every time. Take one or several successful results, give the model the task of assembling the workflow that led to this result, check it yourself and then ask it to turn it into a skill — and save it.
If the model next time hits a similar task, it loads the skill itself and works through it. But remember that a skill wants maintaining. If the model made a mistake and you corrected it, give it the task of analyzing that and improving the skill so the error does not recur.
7. Have the result confirmed, not the intent
After every action that changes an external object, the model should check its state anew. It should report no success just because it called a tool. Before the final answer it should reconcile every statement about completed work with the result of the tool, a test or rereading the file. If the check does not pass, it should say so directly.
8. Self-check on clean context
This technique was surfaced by another model only during the final proofreading of this text. It does not stand in the system prompt but in Anthropic’s recommendations — yet it is as simple as it is effective.
For important work, do not limit yourself to the command “check yourself.” Open a new dialogue and hand over to it only the original task, the finished result and the important refinements that came up in the course of the work. Such a checker does not inherit the author’s whole train of thought and notices systematic errors more often.
Cheat sheet at the end
The longer I work with a model’s prompts, the more the impression solidifies: a single right solution or a fixed rule set does not exist. The “perfect prompt” depends on the model’s developer, on its concrete version, on the task and even on your form of the day. The universally valid advice is: work with AI as much as possible and try to understand how a model is “built.” Try different approaches and observe what actually influences and improves the answers.
From this consideration I recommend the following prompt template:
What for: who the work is for and which decision the result should support. Material and sources: what counts as the basis, what is to be checked and how current it must be. Task: what exactly is to be done. Action limits: analysis only or a finished action; what is allowed independently and what only with confirmation. Uncertainties: when to make an assumption, when to show variants and when asking is mandatory. Doneness: what must be done and checked before the work counts as complete. Form of the result: in which form it can most conveniently be reused afterwards.
That is a detailed list — you can take out only the necessary points or add your own for the concrete task.
And as a bonus one small piece of advice. Every time a new model version appears (when Opus 4.7 is replaced by Opus 4.8, say), I do a simple thing: I turn off all my own settings for at least a few hours — user prompt, style settings, chat-based memory, skills — and run the model with prompts that just barely suffice for the task (“Write a message for such-and-such an audience, minimum length this much, maximum length this much, headline at most 120 characters, source links after the main text”). That way you can tell which style and format the developers put into the new model — and whether it is worth tweaking with your own settings.