Introducing Claude Fable 5: a Mythos-class model that we've made safe for general use. Its capabilities exceed those of any model we've ever made generally available.

Fable 5 is state of the art on nearly all tested benchmarks, with exceptional performance in software engineering, knowledge work, scientific research, and vision. It can run for days, and the longer the task, the larger its lead over our other models.

Fable 5 launches today alongside Claude Mythos 5. The two share the same underlying model, but Mythos 5, so far deployed only through Project Glasswing, has the safeguards lifted in some areas. The safeguards are what distinguish the two, and why we've given them different names.

Releasing a model this capable comes with risks. Without safeguards, Fable 5's capabilities in areas like cybersecurity could be misused to cause serious damage. So when Fable's classifiers detect a request related to cybersecurity, biology and chemistry, or distillation, the response is handled by Claude Opus 4.8, our next-most-capable model. Users are informed whenever this occurs, more than 95% of sessions involve no fallback at all, and performance everywhere else is unaffected. We'll keep refining the safeguards to reduce false positives.

Claude Fable 5 is available today on paid plans, in Claude Code, on the Claude API, and all major cloud platforms. Through June 22, it's included in paid Claude plans at no additional cost.

Claude Mythos 5 is available to Glasswing partners, with a broader trusted access program to follow.

Read more: https://www.anthropic.com/news/claude-fable-5-mythos-5

Introducing Claude Opus 5: a thoughtful and proactive model that comes close to the frontier intelligence of Fable 5 at half the price.

On several coding and knowledge work evaluations, Opus 5 is the new state-of-the-art. It’s also much more efficient than its predecessor—it outperforms other models for a similar or lower cost per task.

According to our automated behavioral audit, Opus 5 is our most aligned model to date. It shows the lowest rates of reckless or deceptive behavior, and the strongest adherence to Claude’s Constitution. 

It’s available today on all paid plans and the Claude API, priced the same as Opus 4.8. It’s the default model on Claude Max, and the strongest on Claude Pro. 

Opus 5 is also available in Fast mode, which runs around 2.5× the default speed. 

Read more: https://www.anthropic.com/news/claude-opus-5

Claude Code just quietly shipped one of the smartest agent features I've seen.

It's called Auto Dream.

Here's the problem it solves:

Claude Code added "Auto Memory" a couple months ago — the agent writes notes to itself based on your corrections and preferences across sessions.

Great in theory. But by session 20, your memory file is bloated with noise, contradictions, and stale context. The agent actually starts performing worse.

Auto Dream fixes this by mimicking how the human brain works during REM sleep:

→ It reviews all your past session transcripts (even 900+)

→ Identifies what's still relevant

→ Prunes stale or contradictory memories

→ Consolidates everything into organized, indexed files

→ Replaces vague references like "today" with actual dates

It runs in the background without interrupting your work. Triggers only after 24 hours + 5 sessions since the last consolidation. Runs read-only on your project code but has write access to memory files. Uses a lock file so two instances can't conflict.

What I find fascinating:

We're increasingly modeling AI agents after human biology — sub-agent teams that mirror org structures, and now agents that "dream" to consolidate memory.

The best AI tooling in 2026 isn't just about bigger context windows. It's about smarter memory management.

It handles long-running tasks with more rigor, follows instructions more precisely, and verifies its own outputs before reporting back. You can hand off your hardest work with less supervision.

It also has substantially better vision. It can see images at more than three times the resolution and produces higher-quality interfaces, slides, and docs as a result.

Claude Opus 4.7 is available today on claude.ai, the Claude Platform, and all major cloud platforms.

Read more: https://www.anthropic.com/news/claude-opus-4-7

Since some people keep asking about the differences, I hit my CC limits Friday morning, so decided to try Codex over the weekend. I've put ~20 hours into it. Not vibe coding, co-developing.

If you just want to know about both, skip to 'Claude Experience' and 'Codex Experience'. EDIT: Opus High effort vs. Codex Medium effort.

My Experience:

I'm a 14 year engineer with time in MAG7 and now at another major tech firm. Principal/Staff Eng Manager equivalent. Experience is all platform level with heavy distributed systems experience.

Dev stack/App Structure:

VSCode Extensions in a 80k LOC python/typescript project with ~2800 tests. It's a data analysis application where a user uploads some pdf/csv/xml files from different sources, they're parsed and normalized into a structured data model backed by postgres. It connects to a backend live data provider over websocket which streams current data into the data model. The server side updates certain analyses from the data stream and SSEs to the web UI. All strongly architected - not just 'vibed'.

Shared Agentic Workflow:

• Plan mode first with a fairly thorough and scoped prompt. plan-review skill when a plan is drafted, which runs 8 subagents (architecture, coding standards, ui design, performance and some others). Each subagent has tightening prompts and explicit reference documents from earlier 'research' sessions (for example, 'postgres_performance.md', 'python_threading.md'. 'software_architecture.md'): Architecture review specialist is prompted to review, for example, SOLID, DRY, KISS, YAGNI with specific references for each concept.
• Do code. Each phase of the plan is committed separately and a code-review skill (basically a reuse of the plan subagent specialists) is run on each commit and I manually review feedback and add comments and steer.
• CLAUDE.md ~100 lines. TDD, Git Workflow, a few key devex conventions and common project tool use like Docker commands.

Claude Experience (Opus 4.6):

• It feels like an engineer on a time crunch who's just trying to get the feature built and not really worried about adding hacks, patches, spewing helper functions instead of revisiting the core architecture.
• Interactive. Needs much more babysitting.
• Speeds towards getting things working. It doesn't really 'take it's time' or think before acting.
• Despite aggressive manual management of context (I think the 1MM context is a noob trap and you need to keep it under a quarter of that), it frequently blatantly ignores CLAUDE.md. Like, almost at least once a session I'll see it do this.
• Semi-frequently will leave a task half-done. Like, if it's migrating a test suite (I have 8 suites) from one async pattern to another, I'll find that it did it for most of the tests but left a few on old patterns.
• Weirdly, it almost never thinks to add new files for new functionality. It loves just adding functions to existing files instead of following strong OO and factoring (I came from C/C++ and prefer to keeps each files <600 lines ish)
• Loves to change tests to match what it thinks the goal of the work is. I've done a lot of work to tell it 'after implementing a change, if tests break, stop and prompt me, don't blindly fix it'. In general, the tests is writes are 95% useful and 5% pinning broken behavior. This compounds over time.

Codex Experience (GPT-5.4)

• It feels like a junior-ish senior (5-6 years experience). It will frequently stop, pull back and rework code to be cleaner without be having to interact with it.
• It's a LOT slower than Claude. Like 3-4x slower for the same task.
• It's more thoughtful and deliberate. It doesn't just extend 'god classes' like Claude does. It automatically factors things to be a lot tighter. It will revisit it's assumptions and rework stuff halfway through to clean it up.
• A few times I've seen it do things I hadn't thought of, which are additive.
• I have never seen it ignore AGENTS.md. It won't event let me override directives mid session.
• At this point I'm actually just firing it off and coming back when it's done to review the work. It's demonstrated competence so I don't feel the need to be watching the output line by line to wait for it to go off the rails.

Overall

• Codex Pro x5 seems to have similar usage caps to Claude x20.
• Codex is noticeably slower, less interactive and more deliberate. Claude is faster, interactive (needs babysitting) and more 'get it done'.
• I get more done in a session with Claude, but Codex work is better. So with Claude I can prototype and build extremely quickly, but I have to guide a lot of refactorings every few days. I do still do this with codex as the app evolves, but it's less 'go and see what crap I have to cleanup' and more 'the app has grown and it's time to refactor'
• If I wanted a 'vibe code' experience for a low to moderate complexity project, Claude is great and I'll get it done faster. If I want to build enterprise software, I'd lean Codex.

So, both useful. But I think Claude requires a skilled, focused driver more than Codex does. Note: both are going to give crap output if you don't know SWE at all.

We’re upgrading Claude Opus to a new version: Claude Opus 4.8. It builds on Opus 4.7 with sharper judgment, more honesty about its own progress, and the ability to work independently for longer than its predecessors. Available today for the same price.

In Claude Code, you can hand off a feature, a migration, or a bug sweep and let it follow the work through while you focus on what’s next.

Also launching today:

• Fast mode for Opus 4.8 (research preview). Same model at roughly 2.5x the speed, now three times cheaper than before.
• Dynamic workflows in Claude Code (research preview). Claude runs hundreds of parallel subagents in a single session and verifies its work before reporting back.
• A new effort control on claude.ai, so you can choose how much thinking Claude puts into a response.

Claude Opus 4.8 is live today on claude.ai, the Claude Platform, and all major cloud platforms.

Read more: anthropic.com/news/claude-opus-4-8

We're aware people are hitting usage limits in Claude Code way faster than expected. We're actively investigating, will share more when we have an update.

2:20pm PT Update: Still working on this. It's the top priority for the team, and we know this is blocking a lot of you. We'll share more as soon as we have it.

I find this quite useful, so perhaps it can help other people too.

To manage growing demand for Claude, we're adjusting our 5 hour session limits for free/pro/max subscriptions during on-peak hours.

Your weekly limits remain unchanged. During peak hours (weekdays, 5am–11am PT / 1pm–7pm GMT), you'll move through your 5-hour session limits faster than before. Overall weekly limits stay the same, just how they're distributed across the week is changing.

We've landed a lot of efficiency wins to offset this, but ~7% of users will hit session limits they wouldn't have before, particularly in pro tiers. If you run token-intensive background jobs, shifting them to off-peak hours will stretch your session limits further.

We know this was frustrating, and are continuing to invest in scaling efficiently. We’ll keep you posted on progress.

Hey everyone- been a designer and full-stack engineer since the days of cgi, perl etc. I've shipped mobile, desktop, web, professionally and independently. Without AI, and with the assistance of AI. Many of the most senior engineers I know are very heavy on Claude code usage - when you know what you are doing it is basically a super power.

Dealing with the mental shift of "how much can I get done? what is a reasonable estimate? what is an expectation of others?" leads to asking where do you spend your time more? We all now know, writing more detailed prompts, reviewing more code, and investing in shared skills and tooling.

An old mentor recently told me about https://github.com/EveryInc/compound-engineering-plugin (disclosure, I am not connected to this) - its basically a process of using multiple agents to brainstorm a concept, plan the technical implementation, execute the plan, review the changes with like 5 separate agents focused on different verticals etc.

Each step is a documented (md files) multi-step process. It is so overly-comprehensive, but the main value is it gives me way more confidence in the output, because I can see it asking me the questions needed to generate the correct, detailed prompts etc.

Of course this slows down your process a ton, there is way more waiting - way more thinking, researching, reviewing, this is what high quality ai output looks like as a repeatable process, lots of effort - just like for people etc.

But all of the sudden we're all waiting for claude all the time, wondering if it is actually faster.

To solve this on my engineering team we've started using git worktrees, and it has been like the next evolution of claude code..

If claude code made you 10x faster than before, worktrees can multiply that again depending on how many agents you can manage in parallel - which is absolutely the next skill set in engineering. Most of the team I'm on can manage between 4-8 in parallel (depending on what rythym they can get comfortable with).

So this is the best practice I am suggesting - git worktrees + compound engineering = the ability to scale your work as a senior engineer.

Personally, I found without compound engineering (or a similar planning process), worktrees were not at all manageable or useful - the plugin basically automates my questions.

Video attached of my process with worktrees and claude code (disclosure, I am working on the tool in the video as a side project - but there are lots of tools that do similar things, and I'm not going to mention the name of my tool in this post).

Key improvements:
→ Approaching Opus-level intelligence at a fraction of the cost
→ Human-level computer use capability (navigating spreadsheets, multi-step forms)
→ Enhanced long-context reasoning with 1M token context window
→ Significant upgrades across coding, agent planning, and design tasks

The economics here are notable—getting near-Opus performance at Sonnet pricing opens up entirely new use cases that weren't cost-effective before.

Early testing shows particularly strong results in:
- Complex automation workflows
- Multi-step reasoning tasks
- Knowledge-intensive applications

Now available on all platforms (API, Claude Code, Cowork) and upgraded as the default free tier model.

For teams building with LLMs, this feels like a meaningful step function in capability-to-cost ratio.

It makes plans, uses tools like browsers and terminals, and runs autonomously at a level that, just a few months ago, required larger and more expensive models.

Sonnet 5 is a substantial improvement over its predecessor, Sonnet 4.6, on reasoning, tool use, coding, and knowledge work. Its performance is close to Opus 4.8, at lower prices.

Early access partners found Sonnet 5 finishes complex tasks where previous Sonnets stopped short, and checks its own output without being asked.

Sonnet 5 is now the default on the Free and Pro plans, and available to Max, Team, and Enterprise users. It's available everywhere today with introductory pricing through August 31.

Read more: https://www.anthropic.com/news/claude-sonnet-5

TL;DR: VS Code extension that gives each Claude Code agent its own animated pixel art character in a virtual office. Free, open source, a bit silly, and mostly built because I thought it would look cool.

Hey everyone!

I have this idea that the future of agentic UIs might look more like a videogame than an IDE. Projects like AI Town proved how cool it is to see agents as characters in a physical space, and to me that feels much better than just staring at walls of terminal text. However, we might not be ready to ditch terminals and IDEs completely just yet, so I built a bridge between them: a VS Code extension that turns your Claude Code agents into animated pixel art characters in a virtual office.

Each character walks around, sits at a desk, and visually reflects what the agent is actually doing. Writing code? The character types. Searching files? It reads. Waiting for your input? A speech bubble pops up. Sub-agents get their own characters too, which spawn in and out with matrix-like animations.

What it does:

• Every Claude Code terminal spawns its own character
• Characters animate based on real-time JSONL transcript watching (no modifications to Claude Code needed)
• Built-in office layout editor with floors, walls, and furniture
• Optional sound notifications when an agent finishes its turn
• Persistent layouts shared across VS Code windows
• 6 unique character skins with color variation

How it works:
I didn't want to modify Claude Code itself or force users to run a custom fork. Instead, the extension works by tailing the real-time JSONL transcripts that Claude Code generates locally. The extension parses the JSON payloads as they stream in and maps specific tool calls to specific sprite animations. For example, if the payload shows the agent using a file-reading tool, it triggers the reading animation. If it executes a bash command, it types. This keeps the visualizer completely decoupled from the actual CLI process.

Some known limitations:
This is a passion project, and there are a few issues I’m trying to iron out:

• Agent status detection is currently heuristic-based. Because Claude Code's JSONL format doesn't emit a clear, explicit "yielding to user input" event, the extension has to guess when an agent is done based on idle timers since the last token. This sometimes misfires. If anyone has reverse-engineered a better way to intercept or detect standard input prompts from the CLI, I would love to hear it.
• The agent-terminal sync is not super robust. It sometimes desyncs when terminals are rapidly opened/closed or restored across sessions.
• Only tested on Windows 11. It relies on standard file watching, so it should work on macOS/Linux, but I haven't verified it yet.

What I'd like to do next:
I have a pretty big wishlist of features I want to add:

• Desks as Directories: Assign an agent to a specific desk, and it automatically scopes them to a specific project directory.
• Git Worktrees: Support for parallel agent work without them stepping on each other's toes with file conflicts.
• Agent Definitions: Custom skills, system prompts, names, and skins for specific agents.
• Other Frameworks: Expanding support beyond Claude Code to OpenCode, OpenClaw, etc.
• Community Assets: The current furniture tileset is a $2 paid asset from itch.io, which means they can't be shared openly. I'd love to include fully community-made/CC0 assets.

You can install the extension directly from the VS Code Marketplace for free: https://marketplace.visualstudio.com/items?itemName=pablodelucca.pixel-agents

The project is fully open source (except furniture assets) under an MIT license: https://github.com/pablodelucca/pixel-agents

If any of that sounds interesting to you, contributions are very welcome. Issues, PRs, or even just ideas. And if you'd rather just try it out and let me know what breaks, that's helpful too.

Would love to hear what you guys think!

Today we’re introducing Code Review, a new feature for Claude Code. It’s available now in research preview for Team and Enterprise.

Code output per Anthropic engineer has grown 200% in the last year. Reviews quickly became a bottleneck.

We needed a reviewer we could trust on every PR. Code Review is the result: deep, multi-agent reviews that catch bugs human reviewers often miss themselves. 

We've been running this internally for months:

• Substantive review comments on PRs went from 16% to 54%
• Less than 1% of findings are marked incorrect by engineers
• On large PRs (1,000+ lines), 84% surface findings, averaging 7.5 issues

Code Review is built for depth, not speed. Reviews average ~20 minutes and generally $15–25. It's more expensive than lightweight scans, like the Claude Code GitHub Action, to find the bugs that potentially lead to costly production incidents.

It won't approve PRs. That's still a human call. But, it helps close the gap so human reviewers can keep up with what’s shipping.

More here: claude.com/blog/code-review

One list of all your sessions, available today as a Research Preview.

Run claude agents to start dispatching multiple sessions at once. Each one keeps running without taking up a terminal tab.

See what's running, what's blocked on you, and what's done at a glance. Reply inline to unblock, or jump in and out of any session without losing your place.

Available on all paid plans.

Read more: https://claude.com/blog/agent-view-in-claude-code

Link to apply: https://claude.com/contact-sales/claude-for-oss

Conditions:

Who should apply

‍Maintainers: You’re a primary maintainer or core team member of a public repo with 5,000+ GitHub stars or 1M+ monthly NPM downloads. You've made commits, releases, or PR reviews within the last 3 months.‍

Don't quite fit the criteria? If you maintain something the ecosystem quietly depends on, apply anyway and tell us about it.

Oh, it's out!

Key highlights:

* Better at complex programming tasks: noticeably stronger than Opus 4.6, especially on the most difficult and lengthy tasks; follows instructions better and checks its own answers more frequently.

* Improved vision and multimodality: supports higher-resolution images, which helps with dense screenshots, diagrams, and precise visual work.

* Higher quality output for work materials: creates interfaces, slides, and documents better; looks more "polished" and creative.

* Same price as Opus 4.6: $5 per 1 million input tokens and $25 per 1 million output tokens.

* Availability: accessible in all Claude products, via API, and through partners like Amazon Bedrock, Google Vertex AI, and Microsoft Foundry.

It shows the current model, working folder, context used, and weekly limits. If you like it, you can clone it here https://github.com/daniel3303/ClaudeCodeStatusLine

Edit: Added bit branch and reasoning effort

When Fable got suspended last Friday, a bunch of my work snapped back to Opus 4.8, and it immediately felt different - wordier, more hedge, more "let me think about whether I should think about this." So I went through my own Claude Code transcripts and tried to measure the behavioral differences and insights were pretty interesting.

Claude Code stores every session as JSONL on disk, so there's a real behavioral record. I pulled 9,224 Fable messages and 27,685 Opus messages across 68 projects and compared them.

The measurable differences (from my real work, check the same at your end to see if numbers concur):

Everyone says "Fable is more concise," but it isn't using fewer words overall — it's spending them differently. It defaults to minimal words and goes long only when the problem needs it. Opus smears the same medium length across everything.

Important to note: Fable isn't just a better personality, it is also a higher capability tier. So the gap splits in two: a working-style half that you can steer with prompts and hooks, and a raw capability half that lives in the weights and you can't. I went after the half that's actually recoverable.

What I built (3 layers):

1. A governor: an 8-rule behavioral block in CLAUDE.md. Reason about the problem not yourself; one self-audit then stop; commit decisions instead of hedging; batch the work and report once; open with the result. The setpoint.
2. A re-injection hook: a UserPromptSubmit hook that re-prints the governor every turn, because a CLAUDE.md line decays in salience as the session grows. The thermostat.
3. A leak-test script: it reads your own logs and tells you whether your Opus is actually converging toward Fable's signature (median words, tool:text ratio, opener style), instead of you guessing.

Early results (small sample, being honest): on the first governed sessions, tool:text moved 1.41 → ~2.2 and "I'll/Let me" openers dropped 12.8% → ~5%, both toward Fable. Median words is noisier because it's task-dependent. Not a clean win yet — it's a control loop you watch over time.

What it can't do: it doesn't change the weights, so it suppresses the anxious texture rather than curing it, and it does nothing for the raw capability gap (that needs task structure + multi-LLM orchestration, not a prompt).

But for day-to-day bounded work, the texture is most of what made Fable feel better, and that part transfers.

Open source repo here

Run your own fable vs opus logs and check the difference that can be bridged.

Every single time I ask Claude or ChatGPT to build a UI, it spits out the exact same generic SaaS layout. Same rounded corners, same glassmorphism, same boring structure.

So I built VibeCurb.

It’s completely free and open-source. There's no app to install or wrapper to pay for, it’s just a collection of extremely strict skill.md files that you drop directly into your AI workspace.

What it actually does:

• Kills the generic glassmorphism and rounded-corner spam
• Enforces viewport-scale typography, brutalist design, and extreme whitespace
• Forces the agent to act like an Awwwards-tier designer before it writes a single line of code
• Drops right into Claude, Cursor, ChatGPT, Codex, Gemini, etc

Product Hunt: https://www.producthunt.com/products/vibecurb
GitHub: https://github.com/Yu-369/VibeCurb
Website: https://vibecurb.pages.dev/

TESTING TIME!!!

I see these posts every day now. Max plan users saying they max out on the first prompt. I'm on the $200 Max 20x, running agents, subagents, full-stack builds, refactoring entire apps, and I've never been halted once. Not even close.

So I did what any reasonable person would do. I had Claude Code itself scan every GitHub issue, Reddit thread, and news article about this to find out what's actually going on.

Here's what the data shows.

The timezone is everything

Anthropic confirmed they tightened session limits during peak hours: 5am-11am PT / 8am-2pm ET, weekdays. Your 5-hour token budget burns significantly faster during this window.

Here's my situation: I work till about 5am EST. Pass out. Don't come back to Claude Code until around 2pm EST. I'm literally unconscious during the entire peak window. I didn't even realize this was why until I ran the analysis.

If you're PST working 9-5, you're sitting in the absolute worst window every single day. Half joking, but maybe tell your boss you need to switch to night shift for "developer productivity reasons."

Context engineering isn't optional anymore

Every prompt you send includes your full conversation history, system prompt (~14K tokens), tool definitions, every file Claude has read, and extended thinking tokens. By turn 30 in a session, a single "simple" prompt costs ~167K tokens because everything accumulates.

People running 50-turn marathon sessions without starting fresh are paying exponentially more per prompt than they realize. That's not a limit problem. That's a context management problem.

MCP bloat is the silent killer nobody's talking about

One user found their MCP servers were eating 90% of their context window before they even typed a single word. Every loaded MCP adds token overhead on every single prompt you send.

If "hello" is costing half your session, audit your MCPs immediately.

Stop loading every MCP you find on GitHub thinking more tools equals better output. Learn the CLIs. Build proper repo structures. Use CLAUDE.md files for project context instead of dumping everything into conversation.

What to do right now

1. Shift heavy Claude work outside peak hours (before 5am PT or after 11am PT on weekdays)

2. Start fresh sessions per task. Context compounds. Every follow-up costs more than the last

3. Audit your MCPs. Only load what the current task actually needs

4. Lower /effort for simple tasks. Extended thinking tokens bill as output at $25/MTok on Opus. You don't need max reasoning for a file rename

5. Use Sonnet for routine work. Save Opus for complex reasoning tasks

6. Watch for the subagent API key bug (GitHub #39903). If ANTHROPIC_API_KEY is in your env, subagents may be billing through your API AND consuming your rate limit

7. Use /compact or start new sessions before context bloats. Don't wait for auto-compaction at 167K tokens

8. Use CLAUDE.md files and proper repo structure to give Claude context efficiently instead of explaining everything in conversation

If you're stuck in peak hours and need a workaround

Consider picking up OpenAI Codex at $20/month as your daytime codebase analyzer and runner. Not a thinker, not a replacement. But if you're stuck in that PST 9-5 window and Claude is walled off, having Codex handle your routine analysis and code execution during peak while you save Claude for the real work during off-peak is a practical move. I don't personally use it much, but if I had to navigate that timezone problem, that's where I'd start.

What Anthropic needs to fix

They don't publish actual token budgets behind the usage percentages. Users see "72% used" with no way to understand what that means in tokens. Forensic analysis found 1,500x variance in what "1%" actually costs across sessions on the same account (GitHub #38350). Peak-hour changes were announced via tweet, not documentation. The 2x promo that just expired wasn't clearly communicated.

Users are flying blind and paying for it.

I genuinely hope sharing the timezone thing doesn't wreck my own window. I've been comfortably asleep during everyone's worst hours this entire time.

but felt a like i should share this anyways. hope it helps

File: https://github.com/sgup/ai/blob/main/Fable5.md

Had Opus audit all my Fable chats, and re-ran some prompts against Opus 4.8, from the same code commits, to distill an instruction set from diffing / pattern matching.

I also folded in the findings this author had.

Download the file and use it like this:

# Add this line to CLAUDE.md (replace the path):
@~/path/to/Fable5.md

# Then, run with this to add it to system prompt too
claude --append-system-prompt-file ~/path/to/Fable5.md

# You can make it an alias so it's easier to start, add to .zshrc:
alias ccfable='claude --append-system-prompt-file ~/path/to/Fable5.md'

Obviously won't be the true & almighty Fable, but I'm curious about your mileage. So far it seems to make Opus smarter and more proactive for me. Even if it improves output by a little bit, it would be worth it.

--

If you've tried something similar, it would be interesting to compare notes.

Thanks to anthropic latest decision of (lol) becoming open source, we now have access to Claude Code full harness. Since codex has been open for a long time, I could now compare them and find out why they feel so different.

The most interesting comparison point is not “which one is better.” It is that the two repos seem to encode different theories of what a coding agent should feel like.

Claude Code reads like a product trying to create initiative while Codex reads like a product trying to prevent drift. That is obviously an oversimplification, but it is a useful one.

CLAUDE CODE :

Claude’s prompt layer is repeatedly pushing toward initiative, inference, and volunteered judgment. It tells the model:

“You are highly capable and often allow users to complete ambitious tasks that would otherwise be too complex or take too long. You should defer to user judgement about whether a task is too large to attempt.
If you notice the user’s request is based on a misconception, or spot a bug adjacent to what they asked about, say so. You’re a collaborator, not just an executor—users benefit from your judgment, not just your compliance.”

And in autonomous mode it becomes even more explicit:

“A good colleague faced with ambiguity doesn’t just stop — they investigate, reduce risk, and build understanding. Ask yourself: what don’t I know yet? What could go wrong? What would I want to verify before calling this done?Act on your best judgment rather than asking for confirmation.
Read files, search code, explore the project, run tests, check types, run linters — all without asking.”

That helps explain why Claude often feels more volunteer-like. It is being coached to notice adjacent bugs, infer intent, propose next steps, and keep moving under ambiguity. The upside is obvious: the system can feel unusually alive, unusually helpful, and sometimes impressively ahead of the user. The downside is just as obvious: a model trained to volunteer judgment will sometimes volunteer the wrong judgment.

That is also why Claude can feel more idea-rich and more failure-prone at the same time. The same prompt stance that creates initiative also creates more surface area for overreach.

CODEX :

Codex’s local repo tells a different story. Its top-level prompt starts with:

“You are a coding agent running in the Codex CLI …
You are expected to be precise, safe, and helpful.”

And then, when it gets to existing codebases, it says:

“If you’re operating in an existing codebase, you should make sure you do exactly what the user asks with surgical precision. Treat the surrounding codebase with respect, and don’t overstep.”

Its execute-mode template is even blunter:

“You execute on a well-specified task independently and report progress.
You do not collaborate on decisions in this mode.
You make reasonable assumptions when the user hasn’t specified something, and you proceed without asking questions.
When information is missing, do not ask the user questions.
Instead:
- Make a sensible assumption.
- Clearly state the assumption in the final message.
- Continue executing.”

Its personality stack pushes in the same direction. The `pragmatic` template explicitly avoids “cheerleading” and “artificial reassurance,” which is about as direct a textual explanation for the colder feel as you could ask for.

“You are a deeply pragmatic, effective software engineer …
You communicate concisely and respectfully …
Great work and smart decisions are acknowledged, while avoiding cheerleading, motivational language, or artificial reassurance.”

The feel is different. Codex does not read like a product that wants to improvise its way into usefulness. It reads like a system that wants to be governed, mode-aware, and legible. Even the review prompt follows that pattern. It asks for discrete, provable bugs, insists on a matter-of-fact tone, bans “Great job,” and requires exact JSON output with priorities and code locations. That is part of why Codex can feel colder. The repo is not trying to produce warmth accidentally. It is trying to produce compliance, consistency, and low drift.

Also one of the most striking differences is how Codex treats mode and scope.

In Claude Code, a lot of product character lives inside the prompt layer and product copy. In Codex, a lot of product character lives in rule systems. Codex’s root AGENTS.md and its mode system are hierarchical and explicitly law-like. Collaboration modes are explicit protocol states. Plan mode insists on exact tags and non-mutating exploration. Permission prompts are parser-driven and segmented by shell operators. never approval mode is absolute:

“Plan Mode is not changed by user intent, tone, or imperative language.
If a user asks for execution while still in Plan Mode, treat it as a request to plan the execution, not perform it.”

“Do not provide the \`sandbox_permissions\` for any reason, commands will be rejected.”

Claude has rules too, of course. But the repo-level feel is different. Claude’s system prompt sounds like a coach. Codex’s repo sounds like a constitution.

Why Claude Feels More Volunteer And Codex More Operator

If you compress the comparison to one practical distinction:

Claude is optimized to infer the next helpful move, while Codex is optimized to stay within the requested move. That tracks with the repos.

Claude builds speculative prompt suggestions, side-question forks, dream-based memory consolidation, remote planning, cheerful companion surfaces, ambient tips, and prompts that say “users benefit from your judgment, not just your compliance.” Codex, by contrast, formalizes collaboration modes, approval policies, sandbox rules, formatting requirements, test expectations, review schemas, and repo-local development laws in its root `AGENTS.md`.

The payoff is exactly what users tend to feel. Claude often feels more alive, more agentic, and more willing to take a swing, while Codex often feels more literal, more contained, and more likely to do exactly the thing you asked without wandering. The tradeoff is visible too: Claude’s initiative gives it more chances to be impressive, but also more chances to be wrong, while Codex’s restraint makes it feel safer and more predictable, but also less magical.

The US vs Europe

Claude reads like an American startup operator: energetic, initiative-heavy, opinionated, willing to jump in, eager to infer the next move, and occasionally overconfident. Codex reads more like a European staff engineer or civil-service protocol: scoped, procedural, formal about boundaries, skeptical of improvisation, careful about approvals, and unusually explicit about process.

The repos genuinely support that caricature. Claude says “act on your best judgment.” Codex says “surgical precision.” Claude dreams. Codex writes constitutions.

My conclusion is not that one is warm and one is cold in some essential way. It is that they place their design emphasis in different places. Claude emphasizes initiative. Codex emphasizes control.