← Back to all free guides

Test The New Models
On Your Own Work

Where each one actually wins, three tasks that push what is genuinely new in them, and the operating instructions that fix their default behavior.

Anthropic shipped Claude Fable 5.1 on September 1 and OpenAI shipped GPT-6 Astra on September 3. Same headline price, both around a million tokens of context. What separates them is the kind of work you hand them.

Claude Fable 5.1GPT-6 Astra
Price / 1M$10 in / $50 out$10 in / $50 out
Context / output1M / 128K1.05M / 128K
The dialFive effort levels from low up to max, defaulting to highFast mode: 2.5x the speed at 2x the price
Where you use itClaude apps, Claude Code, API as claude-fable-5-1ChatGPT Plus and up, Codex, API as gpt-6-astra

Astra is a staged rollout, so it may not be in your account yet. Its rate rises to $20 / $75 on requests above 272K input tokens.

Where Each One Actually Wins
Send it to Astra whenSend it to Fable 5.1 when
Something has to be done on a screen. Filling forms, updating records in a tool, clicking through software. It scores 72.6% on OSWorld 2.0 and finishes those tasks in roughly half the time its predecessor took. You need a finished document, spreadsheet or deck built from a blank page, with live formulas and real slides rather than an outline.
The work is math or precise calculation. It scores 97.6% on FrontierMath Tier 4 against 87.8%. The question is genuinely hard reasoning. It leads on Humanity's Last Exam with tools, 65% against 57.2%.
You are in a long coding session and want it keeping searchable notes across context windows instead of compressing everything into one summary. The job is multi-step research that has to follow up on what it finds, or reading dense charts and tables inside PDFs.

Agentic coding is close enough to be a coin flip: 57.7% against 55.8% on Terminal-Bench 4.0. Run your own repo through both.

The part nobody mentionsAnthropic's own documentation says to start with Opus 5 for most work and reach for Fable 5.1 for demanding reasoning and long-horizon agentic jobs. The newest model is not automatically the right default, and on routine work you are paying double for the same answer.
Test 1: Give It Something Big
RESEARCH → ANALYZE → DECIDE → CREATE

A question is not a test. Give it a real project with every file attached at once, actual constraints, and a decision waiting at the end. A thousand customer reviews, find the five biggest problems, then build the Black Friday positioning off what you found.

Both models now hold roughly a million tokens, so the thing worth testing is whether it connects a detail in one file to a number in another. The prompt below asks for that connection explicitly, and for the finished artifact rather than a description of one.

Test 1: The Big Project
I want to see how you handle a whole project rather than a single question. The project: [the real thing you are trying to decide or produce] What I am attaching: [reviews, exports, transcripts, spreadsheets, PDFs, past campaigns] Constraints: [budget, deadline, team size, brand rules, what is off the table] What a good outcome looks like: [the decision, document, deck or model you need at the end] Who this is for: [the audience, or the person who has to act on it] Read everything I attached in one pass. Do not summarize the files back to me one at a time. The point of this test is whether you can hold all of it at once and connect a detail in one file to a number in another. Do the work in this order and show me each stage before moving on. 1. Tell me what is actually in the material: how much, what date range, what is missing, what looks unreliable or duplicated. Read the charts and tables inside any PDFs rather than only the text around them. If a chart is too dense to read confidently, say so and tell me what you would need. 2. Find the five biggest patterns or problems. Rank them by how much they affect the outcome I described, and cite the specific evidence for each, naming the file and where in it. No pattern without a citation. 3. Name at least one thing that is true across two different sources but obvious in neither on its own. That connection is what I am paying for. 4. Tell me which of those five to act on given my constraints, and which to ignore for now. Say why in terms of my constraints, not in general terms. 5. Build the finished deliverable. Not an outline of it, not a description of what it would contain. If it is a deck, write every slide. If it is a spreadsheet, give me the structure with the actual formulas. If it is a document, write the whole thing, matching the tone of anything I attached that I wrote myself. 6. Finish with what you were least confident about, what you could not verify in the material, and what you would want from me to improve it. Do not hand me a summary of my own attachments as the deliverable. I want the decision and the artifact, with your reasoning visible along the way.
Test 2: Give It Something Recurring
TURN ONE WEEKLY WORKFLOW INTO AN AGENT

Pick the thing you do every week that you resent. This is the test worth more than the other two combined, because you keep the output. A good answer here is a file you save and run again next Monday.

It also sorts the steps by what capability each actually needs, including which ones require driving software directly. That distinction is the difference between an agent that drafts and one that does.

Test 2: The Weekly Workflow
Help me turn one recurring task into an agent I can run every week. The task: [what you do, start to finish] How often: [every Monday, month end, twice a week] How long it takes me now: [rough minutes] Where the inputs come from: [inbox, dashboard, spreadsheet, folder, a specific tool] Where the output has to end up: [a doc, a Slack message, a sheet, an email] What done right looks like: [the standard you would actually accept] What must never happen: [sent to a client unreviewed, live data changed, money spent] What I can give it access to: [files, connectors, a browser, an API key, nothing yet] Work through this in order. 1. Break the task into steps. Mark each one automatable, needs my judgment, or needs my approval before it runs. Be honest rather than optimistic. If a step needs a person, say so and explain why. 2. For each automatable step, say which capability it actually needs: reading files, searching the web, running code, calling an API, or driving a browser and clicking through an interface. That last one is new enough to be worth calling out separately, because it is the difference between an agent that drafts and an agent that does. 3. Tell me the narrowest permission on each connection that still lets the job finish. If read-only is enough for a step, say read-only. 4. Write the agent's full instructions as a file I can save. Include its job, its inputs, its steps in order, its output format with a filled-in example, its rules, and what to do when an input is missing, empty, or looks wrong. Write it to be read by a model, not by me. 5. Add an explicit line telling it to gather independent inputs together in one step rather than one at a time, and to post a short progress update as it finishes each meaningful step. 6. Write me one test I can run today to check the output before I let it run unattended, and tell me what a passing result looks like. 7. Tell me which steps you do not think a model should own yet, and why.

Before you connect it to anything live, read how to safely give an agent access. Scope the permissions first.

Test 3: Make Them Compete
SAME TASK → SAME CONTEXT → COMPARE OUTPUT

Take a problem that is half baked or stuck and run it through both with identical context. Same prompt, same files, or the comparison means nothing. Then stop grading it yourself and paste both answers into a third chat, which strips out the halo whichever one you read first tends to get.

Test 3: The Scorecard
I ran the same task through two different AI models and I want an honest comparison, not a diplomatic one. The task I gave them: [paste the exact prompt you used] Context they both had: [what files or background each one got] What this output actually needs to do for me: [the real job it has to survive] Output A: [paste] Output B: [paste] Score each output 1 to 5 on each of these, with a one-line reason: - Did it do the task I asked, or a nearby easier version of it - Accuracy of anything checkable, and flag anything you believe was invented - Did it connect information across sources, or handle each one separately - Depth of reasoning versus restating my own input back to me - Usability: could I ship this, or does it need a rewrite - Honesty: did it flag what it was unsure about, or sound confident throughout Then give me, in this order: 1. The score table. 2. The single biggest difference between them, in one sentence. 3. Any factual claim either one made that I should check myself before relying on it, and how to check it. 4. Which one I should use for this kind of work going forward, and what kind of work I should send to the other one instead. 5. Anything both of them missed that somebody who knows this domain would have caught. If one is clearly better, say so plainly. If the difference is smaller than it looks, say that too rather than manufacturing a winner.
The Settings That Change The Answer

These models ship with default behaviors that quietly cost you quality. At low effort Fable 5.1 answers from memory instead of searching, which is how a confident, out-of-date answer reaches you. It writes denser prose and less structure than earlier versions. It reproduces source wording without marking it as a quotation. It rewrites whole files to change three lines. And it stops to ask permission for work you already asked for.

Every rule below fixes one of those, and each is drawn from the model makers' own documentation. Paste it once into a Project or a custom GPT and it applies to everything you run there.

Frontier Model Operating Instructions
# Operating instructions for a frontier model Paste this into a Claude Project's instructions, a custom GPT, or the top of a long session. Every rule here exists to correct a documented default behavior of the current frontier models, so it is not generic prompt advice. ## Do the whole job You are operating autonomously. I am not watching in real time and cannot answer questions mid-task, so asking "Want me to..." or "Shall I..." blocks the work. For reversible actions that follow from what I already asked for, proceed without asking. Stop only for destructive actions, or a genuine change of scope that I have to decide. Offering follow-ups once the work is done is fine. Asking permission before doing it is not. Exception: when I am describing a problem, asking a question, or thinking out loud rather than requesting a change, the deliverable is your assessment and not an edit. Never end a turn by describing what you would do next. Do it. ## Verify instead of remembering When a question centers on a name you do not confidently recognize, or one from a fast-moving area like AI models, pricing, or software tools where the landscape shifts within months, treat the name itself as the thing to verify. Search before answering, and include the name exactly as I wrote it in at least one search. Partial familiarity is what makes an out-of-date answer sound authoritative, so recognizing something is not a reason to skip the check. For anything time-sensitive, tell me the date of the source you relied on. ## Write plainly Remove all mannered prose. Mannered prose substitutes metaphor and flourish for direct statement: "a dial worth turning" instead of "a parameter worth varying," "this point earns its keep" instead of "this point still matters." Those phrases exist to display the writer rather than to convey the idea, and they drag in connotations you did not choose. When a literal phrase is available, use it. Vary sentence length deliberately. Do not let every paragraph arrive in the same shape. ## Format for the content, not out of habit Use lists, headers and bold when the content is genuinely multifaceted enough that structure adds clarity, or when I ask for it. In conversational or personal exchanges, stay in plain prose. If I ask for minimal formatting, use none at all. ## Quote honestly When you summarize or research from sources, reword in your own voice. If you use a source's exact wording, mark it as a quotation and name where it came from. Do not reproduce passages of a source unmarked. Organize a comparison around where the sources agree and where they differ, rather than walking through each one in turn. ## Show your work as you go Before you start, say in one line what you are about to do. During any long run of research or tool use, give me a short update each time you finish a meaningful step, saying what you found and what is next. Close with a recap of what actually changed. ## Edit surgically When you change a file or a document, edit only the parts that change. Do not rewrite the whole thing to alter a few lines. Do not fix, refactor, extend or tidy anything I did not ask about. If you notice something else worth changing, list it at the end instead of doing it. ## Batch your reads When several pieces of information are independent and you already know you need all of them, gather them together in one step rather than one per step. ## Tell me what you are unsure about End anything substantial with what you were least confident about, what you could not verify, and what would change your answer. If the evidence is thin, say that it is thin rather than writing around the gap. Do not soften a weak conclusion to be encouraging.
Two dials worth knowingRaise Fable 5.1's effort for anything needing fresh information or hard reasoning, and drop it to medium or low on routine work where quality holds, because that is your main cost control. Astra's fast mode buys 2.5x the speed at twice the price, which is worth it when you are watching it work and not worth it overnight.

How to use these. Copy each prompt into Claude and ChatGPT, fill in the brackets with one real project, and run the same filled-in version in both. Save the operating instructions as a Claude Skill or drop all four into a Project called Model Testing, so the next launch takes ten minutes instead of an afternoon.

I run both from inside VS Code so I can switch between them in one window. For the rest of the lineup, my model cheat sheet covers which one to reach for by task.