The period for using Claude Fable 5 without additional charges was initially announced to end on July 7, 2026, then extended to July 12, and further to July 19. The measure to increase Claude Code's weekly usage limit by 50% will also continue until July 19.
In other words, Fable 5 is not disappearing immediately.
However, the situation where Fable 5 can be used naturally within a monthly plan is not permanently guaranteed. The original announcement stated that it would transition to usage credits after the period ends, with API pricing at $10 per 1 million input tokens and $50 per 1 million output tokens.
What is ending is not Fable 5 itself, but the era where the highest-performance models can be used almost unlimitedly for just a monthly fee.
So, should we abandon Claude Code and fully migrate to OpenAI's Codex?
In conclusion, there is no need for that.
You can keep the Claude Code terminal experience, existing CLAUDE.md, Hooks, MCP, Skills, and permission settings, and simply hand over difficult tasks to GPT-5.6 Sol.
Moreover, there is no need to use suspicious proxy services or unofficial API compatibility layers.
OpenAI itself has released an official plugin for calling Codex from within Claude Code.
What we are building here is not a mechanism to "turn Claude into GPT-5.6."
It is a dual-brain configuration where Claude Code remains the command center and GPT-5.6 Sol is connected as a second thinking engine.
Claude handles user conversations, repository exploration, small edits, and following existing patterns.
GPT-5.6 Sol handles complex design decisions, unresolved bugs, adversarial reviews, changes spanning multiple components, and second opinions before shipping.
Furthermore, by placing Japanese operational prompts as Agent Skills, both models are made to adhere to the same completion conditions, verification standards, and change scopes.
This is the most realistic way to give Claude Code the "brain of ChatGPT 5.6."
Note: I have summarized the setup and serious usage techniques in a PDF.
If you want it, I've made it available from this 👇!
https://x.com/MakeAI_CEO/status/2027682940847898770?s=20
Three Layers to Give Claude Code the Brain of GPT-5.6
The first thing to distinguish is that copying a prompt and connecting to an actual model are different things.
Writing instructions for GPT-5.6 in CLAUDE.md does not change the Claude model itself into GPT-5.6.
What changes is the way work is conducted.
This is called the Action Layer.
Next, introduce the official OpenAI "Codex plugin for Claude Code."
Using this plugin, you can delegate code reviews and implementation tasks to Codex from within Claude Code via the Codex CLI and Codex app server installed in your local environment.
This is the Reasoning/Execution Layer.
Finally, introduce the "OpenAI Developers plugin."
This includes the Docs MCP, which references official OpenAI documentation, and Skills corresponding to the OpenAI API, Agents SDK, ChatGPT Apps, API key settings, and troubleshooting.
This is the Knowledge Layer.
Layer these three.
Action Layer:
Japanese operational prompts and Agent Skills
Reasoning/Execution Layer:
Codex plugin for Claude Code
Knowledge Layer:
OpenAI Developers plugin and official Docs MCP
By doing this, you can keep using Claude Code for daily operations and call upon GPT-5.6 Sol and the latest OpenAI documents only when necessary.
First, Install the Official OpenAI Codex Plugin
What you need for installation is a ChatGPT account or OpenAI API key, Node.js 18.18 or later, and the Codex CLI.
This plugin does not transfer code to some unofficial service.
It utilizes the Codex CLI on your machine and inherits existing Codex authentication, settings, repositories, and local environments. If you are already logged into Codex, you can use that authentication state as is.
First, install or update the Codex CLI.
npm install -g @openai/codex@latest
codex --version
codex login
To use GPT-5.6 with Codex, Codex CLI 0.144.0 or later is required.
codex --version
If the displayed version is old, install the latest version again.
Next, start Claude Code and execute the following in order:
/plugin marketplace add openai/codex-plugin-cc
/plugin install codex@openai-codex
/reload-plugins
/codex:setup
/codex:setup checks if the Codex CLI is available and if authentication is complete.
If Codex is not installed and npm is available, it may suggest installation during setup.
When first trying it out, a read-only review is safe.
/codex:review --background
/codex:status
/codex:result
/codex:review reviews current uncommitted diffs.
If you want it to check diffs against the main branch, do the following:
/codex:review --base main --background
This command is read-only and does not change code.
Jobs started in the background can be checked with the following commands:
/codex:status
/codex:result
To stop a process in progress, do the following:
/codex:cancel
Differentiate Between Normal and Adversarial Reviews
The Codex plugin has an adversarial-review option separate from normal reviews.
/codex:adversarial-review --base main
Normal reviews look for bugs, lack of tests, error handling, and type issues in the code.
On the other hand, adversarial reviews question the implementation policy itself.
For example, after implementing authentication, you can request:
/codex:adversarial-review --base main Consider whether the current policy itself is wrong from the perspective of authorization boundaries, privilege escalation, session fixation, token leakage, and lack of audit logs.
For billing processing, do the following:
/codex:adversarial-review --base main Focus on doubting the possibility of double billing, duplicate webhooks, retries after timeout, partial failures, transaction boundaries, and inability to rollback.
If a normal review checks "if there are bugs in this implementation," an adversarial review checks "if this implementation should have been chosen in the first place."
Both are read-only and do not rewrite code without permission.
The strength of this configuration is the ability to separate the model that creates the implementation from the model that doubts the premises of the implementation.
The official plugin provides commands for normal reviews, adversarial reviews, rescue, session transfer, and checking/stopping background processes.
Hand Over Stuck Work to Codex with Rescue
Tests don't pass even after several fixes in Claude Code.
The cause spans multiple components.
It only fails in CI.
Concurrency or caching is involved, and the symptom is far from the cause.
In such cases, use /codex:rescue.
/codex:rescue Reproduce the bug, identify the root cause, and create the minimum safe fix and regression test.
You can also specify the model and reasoning strength.
/codex:rescue --model gpt-5.6-sol --effort high Reproduce the bug, identify the root cause, implement the minimum safe fix, and run related tests.
Send long processes to the background.
/codex:rescue --background --model gpt-5.6-sol --effort high Investigate test failures occurring only in CI.
Results are retrieved with the following commands:
/codex:status
/codex:result
To continue the previous Codex task, you can use --resume.
/codex:rescue --resume Implement and verify the safest plan among the previously proposed fixes.
To start as a new investigation separate from the previous one, use --fresh.
/codex:rescue --fresh Investigate the root cause from a different hypothesis.
To transfer the entire conversation from Claude Code to Codex, use the following command:
/codex:transfer
After execution, a command to resume on the Codex side will be displayed.
codex resume <session-id>
This allows for a transfer where "investigation started in Claude Code, but Codex becomes the primary lead midway."
Making GPT-5.6 Sol the Standard Model
If you want to fix the Codex model on a per-project basis, place .codex/config.toml in the root of the repository.
model = "gpt-5.6-sol"
model_reasoning_effort = "high"
review_model = "gpt-5.6-sol"
To make it a common setting for all personal projects, place it here:
~/.codex/config.toml
Project-specific settings go here:
your-project/.codex/config.toml
Project settings are loaded if the repository is treated as trusted.
In daily work, there is no need to use the maximum reasoning strength from the start.
As a guideline, divide it as follows:
low:
Word fixes, name changes, clear small-scale changes
medium:
Normal feature additions, implementations following existing patterns
high:
Changes spanning multiple files, difficult debugging, design decisions
xhigh:
Security reviews, large-scale migrations, complex race conditions, long investigations
In Codex, you can select GPT-5.6 Sol, Terra, or Luna.
Sol is suitable for complex and highly flexible work, Terra for daily implementation, and Luna for clear and repeatable work.
Also, Max and Ultra are available separately from normal reasoning strength.
Max gives more reasoning time to a single task.
Ultra uses sub-agents to process splittable work in parallel.
However, Max and Ultra are unnecessary for most tasks. It is better to start with Medium or High and only increase if a difference appears in actual evaluation.
"GPT-5.6 Sol High" and "GPT-5.6 Sol Pro" are Not the Same
This is easily confused.
In ChatGPT, GPT-5.6 Sol is used for Medium, High, and Extra High.
On the other hand, GPT-5.6 Sol Pro is used for Pro.
Therefore, simply specifying the following in the Codex plugin:
--model gpt-5.6-sol --effort high
Does not mean "GPT-5.6 Sol Pro was used."
This means GPT-5.6 Sol was run with High reasoning strength.
In the OpenAI API Responses API, you can choose standard or pro as the reasoning.mode for GPT-5.6.
To use Pro mode, the request would look like this:
{
"model": "gpt-5.6",
"reasoning": {
"mode": "pro",
"effort": "high"
},
"input": "Review this database migration plan and identify failure patterns, recovery methods, and conditions that make it impossible to rollback."
}
reasoning.mode and reasoning.effort are different settings.
reasoning.mode:
standard or pro
reasoning.effort:
low, medium, high, xhigh, etc.
Pro mode performs more model processing than standard mode, increasing latency and token usage.
If you strictly want to call this API's Pro mode from Claude Code, the configuration would involve preparing a local script or MCP server wrapping the Responses API and calling it from a Claude Code Skill.
However, for normal coding work, you should first try GPT-5.6 Sol's Medium or High with the official Codex plugin.
Then, only upgrade tasks where the effect of Pro mode is confirmed from actual evaluation results.
You don't need to send all processes to Pro just because it has "Pro" in the name.
The "System Prompt" for ChatGPT 5.6 Sol Pro is Not Public
Be careful here.
The full version of the internal system prompt used by OpenAI in ChatGPT or GPT-5.6 Sol Pro is not public.
Therefore, you should not believe and introduce texts of unknown origin found on the internet, such as "leaked GPT-5.6 system prompt," "complete reproduction version," or "full internal prompt text."
What you should use is an operational prompt created to fit your development environment while referring to official prompt guides.
Official guides for GPT-5.6 recommend specifying the following elements in the prompt:
- Final outcome to be achieved
- Important constraints
- Available evidence
- Criteria for judging completion
On the other hand, avoid excessively fixing search order, tool selection, and detailed thinking steps, leaving room for the model to choose efficient paths.
It is also explained that thinning out duplicate instructions, unnecessary examples, and meaningless tool descriptions to lighten the system prompt can lead to improvements in performance and token efficiency.
Below is a Japanese operational prompt designed to be used commonly with Claude Code, Codex, and GPT-5.6 Sol.
This is not a reproduction of an OpenAI internal prompt.
Japanese Operational Prompt for Claude Code and GPT-5.6 Sol
Role
You are a senior execution orchestrator in this repository.
Your goal is to provide correct, maintainable, and verified minimal changes that satisfy the outcomes the user truly seeks.
Writing a lot of text, increasing the number of files changed, or using many tools themselves are not targets for evaluation.
You are evaluated by accuracy, evidence, moderation in change scope, and reviewable outcomes.
Operational Contract
1. Clarify Outcomes
Before starting edits, identify the following:
- Final outcome visible to the user
- Related repository areas
- Constraints that must be kept
- What will not be done this time
- Criteria for judging completion
- Verification methods that can prove completion
Resolve ambiguous points from evidence within the repository first.
Only ask the user questions if missing judgments significantly change product behavior, security, cost, data, or irreversible operations.
Do not ask questions just to avoid investigating the repository.
2. Investigate Before Changing
Read the necessary and sufficient minimum range of files.
Investigate the following:
- Existing implementation patterns
- Tests
- Interfaces
- Migrations
- Naming conventions
- Design conventions
- Error handling
- Authentication and authorization boundaries
Prioritize evidence within the repository over speculation or framework defaults.
In bug fixes, establish reproducible failures or specific evidence supporting the cause before proposing fixes.
Do not rewrite existing mechanisms before understanding why they exist.
3. Plan at Appropriate Depth
If the change is small, local, and easy to undo, proceed with the work.
If any of the following apply, show a concise plan before implementation:
- Spans multiple files
- Changes architecture
- Relates to security
- Rewrites data
- Changes public interfaces
- Difficult to undo
- Relates to billing, authentication, permissions, or personal information
- Relates to concurrency or asynchronous processing
Include the following in the plan:
- Intended behavior to be realized
- Files or components likely to be changed
- Invariants that need to be maintained
- Main risks
- Verification procedures
- Rollback or recovery methods as needed
Do not increase formal procedures that do not reduce risk.
4. Allocate Work to the Optimal Engine
Use the current Claude Code session for the following tasks:
- Rapid repository exploration
- Interaction with the user
- Small-scale edits with clear scope
- Task decomposition and progress management
- Implementation following existing patterns
- Reviewing and integrating feedback returned from Codex
Consider delegation to Codex or independent review if one or more of the following apply:
- Work is stuck despite grounded investigation or fix attempts
- Changes span multiple interacting components
- There is value in an independent second implementation plan
- Review from an adversarial perspective is effective
- Risks regarding accuracy, security, concurrency, migration, or rollback are high
- The user explicitly requests the use of GPT-5.6 Sol
- There is a need to doubt the current implementation policy itself before release
If uncertainty can be resolved by review alone, use read-only Codex reviews before performing writable delegation.
Do not claim to have used GPT-5.6 Sol Pro unless you are using the documented Pro mode in an actual request.
Accurately report the model ID, reasoning strength, and reasoning mode used.
5. Implement with Narrow Change Scope
Unless redesign is explicitly requested, follow existing architecture, naming conventions, and repository practices.
Avoid the following:
- Unrelated refactoring
- Excessive abstraction predicting the future
- Adding unnecessary dependencies
- Meaningless formatting changes
- Extensive rewrites
- Changing public behavior outside the requested scope
- Deleting existing tests without reason
- Swallowing exceptions just to hide problems
Maintain backward compatibility unless breaking changes are an explicit requirement.
Do not expose secrets, credentials, private keys, tokens, customer data, or personal information.
Do not record secrets in the following locations:
- CLAUDE.md
- AGENTS.md
- SKILL.md
- Source files
- Logs
- Test fixtures
- Generated reports
- Commit messages
6. Verify by Evidence
Execute the most relevant verification for the changes within the available range.
As a rule, prioritize the following order:
- Targeted tests
- Type checks
- Lint and format checks
- Build
- Integration tests
- Runtime or visual confirmation
Execute only verifications commensurate with the changes.
However, do not omit necessary verifications just to finish quickly.
For UI changes, check the actual working screen if possible.
For bug fixes, add or update regression tests if realistically possible.
For migrations or destructive operations, check the following:
- Successful forward processing
- Handling during failure
- Rollback or recovery
- Behavior when partially executed
- Behavior during retries
- Behavior during double execution
Do not use expressions like "fixed," "works," "safe," or "complete" without showing evidence.
If verification cannot be executed, accurately state the reason and what remains unverified.
Do not fabricate failed tests as successful.
7. Review Final Diffs
Before finishing work, perform the following checks:
- Check final diffs
- Look for unintended changes
- Check error handling and boundary conditions
- Check security boundaries and authorization processing
- Check concurrency and retry behavior as needed
- Check for missing tests
- Compare final results with initial outcome goals
- Check if content decided not to be done this time was accidentally implemented
For high-risk changes, request an independent Codex review.
Process all important review points with one of the following:
- Fix them
- Reject them by showing evidence on the repository
- Clearly document them as out of scope for this time
- Record them as unverified due to lack of environment
Do not adopt changes unconditionally just because Codex pointed them out.
Verify points with code, specifications, tests, and execution results.
8. End at the Appropriate Point
End work once completion criteria are met.
Do not continue unnecessary polishing beyond the requested scope.
Do not add unrelated TODOs or redesign plans to make the work look larger.
The final response should include the following:
- Provided outcomes
- Main changes
- Executed verifications and results
- Remaining risks, assumptions, or blockers
- Specific operations to be performed next only if truly necessary
The purpose of this prompt is not to make the model a "genius engineer persona."
It is to clarify outcomes, evidence, change scope, delegation conditions, verification, and stop conditions.
It is easier to operate by defining what constitutes completion rather than writing a large amount of abstract commands like "think thoroughly" or "act as the world's best engineer."
Place Long Prompts in Skills, Not CLAUDE.md
You can write the previous prompt directly in CLAUDE.md.
However, placing long texts that are not always necessary in CLAUDE.md consumes context in every session.
A more suitable place is an Agent Skill.
Claude Code Skills recognize the name and description first and only load the SKILL.md body when needed.
Codex Skills similarly adopt a mechanism to group instructions, reference materials, scripts, templates, etc., into one directory and load them only when necessary.
Since both use the Agent Skills format, it is easy to share basic prompts and procedures.
In Claude Code, save it to the following location:
.claude/
└── skills/
└── sol-pro-orchestrator/
└── SKILL.md
The beginning of SKILL.md should look like this:
name: sol-pro-orchestrator
description: >
Use for complex changes, changes spanning multiple files, high-risk changes,
when work is stuck, or for important work before release.
Apply when clear planning, verification, and independent Codex review or delegation are needed.
Sol Pro Orchestrator
[Place the Japanese operational prompt here]
To call it explicitly, do the following:
/sol-pro-orchestrator Add billing processing. Maintain existing idempotency design and create regression tests up to double billing.
If the Skill's description matches the request, Claude may load it automatically.
If you don't want it to start automatically, add the following to the frontmatter:
disable-model-invocation: true
In that case, the Skill is used only when the user explicitly executes the slash command.
It is better to leave only short rules that are always necessary in CLAUDE.md and separate complex work procedures into Skills.
For example, CLAUDE.md is sufficient with something like this:
Repository Rules
- Follow existing architecture and naming conventions.
- Prioritize minimal changes that can maintain safety.
- Run relevant tests before completion.
- Do not change unrelated files.
- Use the sol-pro-orchestrator Skill for complex, stuck, high-risk, or important work before release.
Add Official OpenAI Skills to Claude Code
Just being able to call GPT-5.6 Sol is not enough.
If the model answers about the OpenAI API or Agents SDK based only on memories from the time of training, it may use old APIs, deprecated parameters, or implementations that are no longer recommended.
That's where the "OpenAI Developers plugin" comes in.
Execute the following in Claude Code:
/plugin marketplace add openai/openai-developers-for-claude
/plugin install openai-developers@openai-developers
After installation, start a new Claude Code session.
This plugin includes the official OpenAI Docs MCP and the following Skills:
openai-docs:
Routes questions about OpenAI products, APIs, models, and SDKs to official documentation.
Used to check information that changes easily, such as new model names, current API parameters, SDK usage, and Codex settings.
openai-platform-api-key:
Guides OPENAI_API_KEY settings in the local environment.
This Skill is for connecting as an environment variable rather than pasting API keys into source code or prompts.
openai-api-troubleshooting:
Classifies OpenAI API errors.
Checks authentication, permissions, model specification, rate limits, network, request format, etc., and leads to the next action to take.
agents-sdk:
Supports design, implementation, execution, and evaluation of applications using the OpenAI Agents SDK.
build-chatgpt-app:
Designs and implements projects using the ChatGPT Apps SDK.
Used for app development including MCP servers, widget UI, and integration with ChatGPT.
chatgpt-app-submission:
Prepares ChatGPT App submissions, description information, test cases, etc.
This plugin is an official repository released by OpenAI for Claude Code.
It is a set of the public OpenAI Docs MCP and development Skills adjusted for Claude Code.
Here, do not confuse the two plugins.
codex-plugin-cc:
Execution bridge for delegating reviews and implementation to Codex.
openai-developers-for-claude:
Knowledge package that adds OpenAI official information and development procedures to Claude Code.
By adding both, Claude Code becomes an environment where it not only "makes Codex think" but also "implements while checking OpenAI official specifications."
How to Divide Tasks Between Claude and Codex in Practice
There is no need to throw all jobs to both models at the same time.
Divide roles.
Entrust Claude Code with the following tasks:
- Repository exploration
- Interaction with the user
- Understanding existing implementations
- Small changes
- Implementation following known patterns
- Reflecting Codex's points into code
Entrust GPT-5.6 Sol with the following tasks:
- Complex design decisions
- Stuck bugs
- Investigations spanning multiple components
- Adversarial reviews
- Checking security boundaries
- Investigating concurrency and race conditions
- Checking migrations and rollbacks
- Independent reviews before release
For example, when adding a new billing process, the flow would be:
- Investigate existing billing flows, tests, and idempotency design in Claude Code.
- Fix the plan and completion conditions with the sol-pro-orchestrator Skill.
- Claude creates the minimum implementation and regression tests.
- Doubt the design policy with a Codex adversarial review.
- Claude verifies the points with code and tests.
- Reflect only necessary fixes.
- Check final diffs with a normal Codex review.
First, call the Skill.
/sol-pro-orchestrator Add billing processing. Investigate existing design and include idempotency, duplicate webhooks, and regression tests in completion conditions.
After implementation, perform an adversarial review.
/codex:adversarial-review --base main Focus on doubting the possibility of double billing, duplicate webhooks, retries after timeout, partial failures, transaction boundaries, and inability to rollback.
After fixing, perform a normal review.
/codex:review --base main --background
/codex:status
/codex:result
The aim of this method is not to decide which of Claude or GPT is stronger.
It is to separate the role of creating the implementation from the role of breaking the premises of the implementation.
If you ask the same model to "implement and then strictly self-review," it is likely to review based on the design it initially adopted.
By bringing in a different system's model as a critic, you can bring in different exploration paths and failure hypotheses.
This is not competition between models, but separation of duties in software development.
Do Not Send Everything to Sol High
Sending file name changes, display text fixes, and simple type errors to GPT-5.6 Sol High wastes usage limits and time.
Think of model usage as follows:
Claude Code:
Interaction, exploration, small fixes, integration work
GPT-5.6 Luna:
Clear and large-scale conversions, classification, routine work
GPT-5.6 Terra:
Daily implementation, normal debugging
GPT-5.6 Sol Medium:
Implementation involving a certain level of planning or judgment
GPT-5.6 Sol High:
Difficult design, complex bugs, important reviews
GPT-5.6 Sol xhigh, Max, Pro, Ultra:
Most difficult tasks where additional effects are confirmed by evaluation
Instead of always using high-performance models, concentrate them on jobs where the loss when failing is large.
This makes it easier to check results as well as costs.
Do Not Keep Review Gates Always On
The official Codex plugin has a review gate that automatically executes a Codex review when Claude tries to finish work.
The command to enable it is as follows:
/codex:setup --enable-review-gate
To disable it, use:
/codex:setup --disable-review-gate
If a problem is found in the review, you can stop Claude from finishing and return to fixing.
It is powerful, but long loops between Claude and Codex can occur, rapidly consuming usage limits.
Therefore, it is better to limit it to situations such as:
- Release candidates
- Changes to authentication/authorization
- Billing processing
- Large-scale data migration
- Security boundaries
- Changes difficult to rollback
For daily small tasks, it is easier to handle by executing manual reviews at necessary timings.
The official README also warns that review gates can create long Claude/Codex loops and consume usage limits, so they should only be enabled when they can be monitored.
Do Not Adopt Codex's Points Unconditionally
GPT-5.6 Sol is powerful, but not always correct.
It may assume non-existent specifications, overlook repository-specific circumstances, or propose excessive design changes.
Process review points with one of the following:
Adopted:
Confirmed the basis and performed fix and verification.
Rejected:
Did not adopt by showing evidence of repository, specifications, or tests.
Postponed:
Valid point but made a separate task as out of scope for this time.
Unverified:
Could not confirm due to lack of environment or permissions.
You don't change things "because Codex said so."
"Confirming the failure hypothesis presented by Codex with code and tests" is correct.
The value of a dual-brain configuration is not in unconditionally believing the answers, but in increasing other possibilities that should be checked.
Minimum Security Line
Claude Code and Codex both read repositories, execute commands, and rewrite files depending on settings.
When connecting two agents, you need to decide on permission boundaries before convenience.
Start with read-only reviews first.
/codex:review
/codex:adversarial-review
Use rescue involving writing after confirming the target repository and work content.
Do not paste .env, private keys, customer data, or access tokens into CLAUDE.md, AGENTS.md, or SKILL.md.
Set the OpenAI API key as an environment variable.
export OPENAI_API_KEY="..."
In practice, use shell profiles, secret management services, CI Secret functions, etc.
Also, do not assume that Claude Code's permission settings and Codex's sandbox/approval settings are the same.
Check the scope of network access, file writing, and command execution on both the Claude side and the Codex side.
When adding external MCPs, check the provider and permissions, and allow only necessary tools.
Completed Directory Structure
The final repository will look like this:
your-project/
├── CLAUDE.md
├── AGENTS.md
├── .claude/
│ └── skills/
│ └── sol-pro-orchestrator/
│ └── SKILL.md
├── .codex/
│ └── config.toml
├── src/
├── tests/
└── package.json
Roles for each are clearly divided.
CLAUDE.md:
Write short repository rules that Claude Code always follows.
- Follow existing architecture
- Do not change unrelated files
- Prioritize minimal safe changes
- Run relevant tests
AGENTS.md:
Write project information that Codex requires.
- Repository structure
- How to start the development environment
- Build commands
- Test commands
- Design constraints
- Completion conditions
.claude/skills/sol-pro-orchestrator/SKILL.md:
Write Japanese operational prompts to be loaded only for complex work.
.codex/config.toml:
Write the model and reasoning strength used in Codex.
model = "gpt-5.6-sol"
model_reasoning_effort = "high"
review_model = "gpt-5.6-sol"
And add the two official plugins to Claude Code:
openai/codex-plugin-cc
openai/openai-developers-for-claude
Now Claude Code has the following roles:
- Daily implementation and interaction by Claude
- Independent review and rescue by GPT-5.6 Sol
- Checking latest specifications by OpenAI official Docs MCP
- Reusable development process by Agent Skills
Summary: Don't Abandon Claude Code, Add a Second Brain
The period for using Fable 5 without additional charges has been extended to July 19, 2026.
Therefore, it is not a state where "Fable ended today."
However, the trend that being able to continue using the highest-performance models within a monthly plan is no longer natural remains unchanged.
That doesn't mean you have to abandon Claude Code.
Keep Claude Code as the command center.
Use the official OpenAI codex-plugin-cc to call GPT-5.6 Sol for reviews, rescue, and implementation.
Add the OpenAI Developers plugin to utilize official Docs MCP and OpenAI development Skills.
Make common operational prompts into Agent Skills that are loaded only when needed, rather than stuffing them into CLAUDE.md as huge resident instructions.
And separate the "model that made the implementation" from the "model that doubts that implementation."
With this configuration, you can insert GPT-5.6 reasoning where needed without abandoning Claude Code's operational feel, existing settings, Skills, MCP, and project assets.
You are not changing Claude into GPT.
You are housing another senior engineer in Claude Code whom you can consult at any time.
Rather than depending on one model for all work, use models according to the work content.
Usually, proceed quickly with Claude Code.
In difficult spots, request rescue from GPT-5.6 Sol.
Before shipping, receive an adversarial review from a different model.
Have the official Docs MCP check the latest OpenAI API specifications.
Claude Code from now on is not a coding tool that completes within one model.
The correct way is to use it as a development OS that bundles multiple models, Skills, MCPs, and plugins.
