Claude Plans. Astra Builds. You Win.

Two subscriptions should do more than sit in separate tabs

You ask one AI to build a business tool. It makes a plan, writes the code and tells you the result is ready. The problem is that the same system may carry the same mistaken assumption through every stage.

Claudex Loop adds a second provider to challenge the plan and inspect the implementation. It coordinates the handoffs so you do not have to copy every revision between chats.

Get the free skill: github.com/chaseai-yt/claudex-loop. This is Chase AI's MIT-licensed project. You do not need to buy a course to use it. The repository contains several skills; use claudex-loop for the full workflow. claudex-route is a separate routing/recommendation skill, not the complete build loop.

This guide uses a product dashboard because a beautiful sales chart can still hide unprofitable products. You will first build from local CSV exports, then decide whether a live read-only integration is worth adding. Claudex is the development workflow, not a ready-made finance app or an automatic Shopify/advertising connector.

Choose the roles deliberately

Fable's broad reasoning strengths and Astra's software-engineering results make this a reasonable task split, not a universal ranking. Both can plan and code. The Fable announcement and Astra announcement describe the capabilities and published comparisons; they do not prove that this particular pairing produces a tenfold improvement.

The important default: starting in Claude Code normally makes Claude the builder and Codex the final inspector. To reproduce the workflow above, set the builder and all three external model choices explicitly. Choosing Fable in Claude's interface does not change Codex's model.

What you need before installing

• A computer running a supported version of macOS, Linux or Windows, with an internet connection and permission to install developer tools.
• Claude Code and Codex CLI, both installed and signed in. Ordinary browser chats alone do not provide this workflow.
• Access to Fable 5.1 in Claude Code and GPT-6 Astra in Codex on your accounts. Check entitlement and limits before purchasing anything. An active subscription does not guarantee every model.
• Python 3.10 or newer for the shared runner. No additional runtime pip packages or new API key are required by the skill itself.
• Git, for the project baseline and change review. Manual skill installation also uses Git.
• Authorized, sanitized business exports. Begin with the fictional fixture in this guide, not customer records.

Costs: the repository and skill are free. Each provider's subscription or API usage, limits and billing still apply. Review rounds consume additional usage and can take longer than a single-model run. The guide uses local files, so it does not require paid hosting or a connector subscription.

Privacy: local installation does not mean offline processing. Plans, code and eligible data may be sent to both model providers. Keep secrets, customer names, email addresses and payment details out of the project. Review your organization's data policy first.

Install and verify the two coding tools

Open Terminal on macOS/Linux or PowerShell on Windows. Commands in shell blocks go there, not into an AI chat. Install Git and Python using their official instructions for your operating system, then open a new terminal.

Install Claude Code

The following are the official native installer commands. They download and execute installer code. Read the official setup page and use an organization-approved installation method. Do not bypass managed security restrictions.

curl -fsSL https://claude.ai/install.sh | bash

irm https://claude.ai/install.ps1 | iex

Install Codex

On macOS/Linux, the official Codex repository documents this native installer:

curl -fsSL https://chatgpt.com/codex/install.sh | sh

For a Windows route without changing PowerShell execution policy, install the current supported Node.js LTS from nodejs.org, reopen PowerShell, then use the documented npm installation:

node --version
npm --version
npm install -g @openai/codex

Use a single environment throughout. If you choose WSL, install both CLIs, Python and Git inside WSL and keep the project there. Do not mix a Windows-only login with a Linux-only skill installation and assume they share configuration.

Sign in and check the prerequisites

claude auth login
codex

Complete Claude's supported sign-in flow. In Codex, select Sign in with ChatGPT and complete the browser flow. Exit Codex when finished, then run:

claude --version
claude auth status
codex --version
codex login status
git --version

On macOS/Linux, check Python with python3 --version. On Windows, use py -3 --version and check that the host can find the Python installation. It must be 3.10 or newer.

Checkpoint: both CLI commands resolve, both accounts are authenticated, and Git and Python print versions. The repository records a Windows live-test baseline of Codex 0.153.4 and Claude Code 2.1.261. These are reported working versions, not proof that every newer version or account works. Its runtime notes record an older Codex version being rejected by Astra despite exposing the required flags.

Install Claudex Loop

Recommended: Claude Code plugin

Start Claude Code with claude. Inside that interactive session, run these two commands, one at a time:

/plugin marketplace add chaseai-yt/claudex-loop
/plugin install claudex-loop@claudex-loop

Review the source before approving the plugin. Start a fresh Claude Code session after installation. The full-loop command is:

/claudex-loop:claudex-loop

You do not need to install the skill in Codex as well when Claude is coordinating and calling the Codex CLI. You do need Codex installed and authenticated. Use the manual route below if you want to start directly in Codex or avoid the Claude plugin route.

Alternative: manual installation for both hosts

Choose this instead of duplicating the plugin installation in Claude. Run from a folder where a new claudex-loop directory will not overwrite an existing project. If a skill with the same name is already installed, back it up and review the update before replacing it.

git clone https://github.com/chaseai-yt/claudex-loop.git
cd claudex-loop
mkdir -p ~/.agents/skills ~/.claude/skills
cp -R skills/. ~/.agents/skills/
cp -R skills/. ~/.claude/skills/

git clone https://github.com/chaseai-yt/claudex-loop.git
Set-Location claudex-loop
New-Item -ItemType Directory -Force "$env:USERPROFILE\.agents\skills", "$env:USERPROFILE\.claude\skills" | Out-Null
Copy-Item -Recurse -Force skills\* "$env:USERPROFILE\.agents\skills\"
Copy-Item -Recurse -Force skills\* "$env:USERPROFILE\.claude\skills\"

Copy the full skill directories, not only SKILL.md. The runner and references are required. Open a new session. Manual Claude installations use /claudex-loop; Codex uses $claudex-loop. Dollar-prefixed skill invocations go into Codex chat, not your shell.

Checkpoint: the installed host recognizes the full-loop skill. Ask it to show the loaded skill path and resolve its runner from that installation. Do not let it use a similarly named runner inside an untrusted project.

Prepare a clean project and select the exact models

Create a new private folder named product-profit-dashboard, separate from the downloaded Claudex repository. Open your terminal in that new folder. For an existing application, use a reviewed clean branch/worktree and preserve unrelated changes instead.

git init
git commit --allow-empty -m "Initial dashboard baseline"
claude --model claude-fable-5-1

The empty commit gives the workflow a baseline for reviewing changes. If Git asks for identity, configure your own name/email using Git's instructions. Do not copy someone else's identity. These commands do not push anything to a remote repository.

In the fresh Claude session, confirm that Fable 5.1 is selected. Use the prompt below to establish the role configuration before doing business work.

/claudex-loop:claudex-loop
Prepare the workflow, but do not build or launch a model handoff yet.
builder=codex
reviewer_model=gpt-6-astra
builder_model=gpt-6-astra
inspector_model=claude-fable-5-1
rounds=3
inspect=on
MAX_FIX_ROUNDS=2
MAX_INSPECTION_ROUNDS=2

Confirm that this host is Claude Code using Fable 5.1. Show the installed skill and runner paths, resolved CLI paths and versions, and the planned roles. Do not display credentials.
Keep PLAN.md and PLAN-REVIEW-LOG.md in a private sibling folder outside the build checkout. Resolve absolute paths and confirm that both CLIs can access the approved plan location. Keep CLI diagnostics outside the checkout too. Do not widen access to my entire home folder.
Check that the build checkout has a baseline commit and no unrelated changes. Do not stash, delete or commit my existing files to make a check pass.
Report requested models separately from observed models. Stop if a requested model is unavailable; do not silently substitute another model.

For a manual installation, replace only the first line with /claudex-loop. Keeping planning artifacts outside the checkout avoids making the project dirty immediately before an external build. Once the build begins, review actual logs for the observed model identities. A configuration echo alone is not proof of a successful model call.

Permissions: disable unrelated write-capable MCP integrations for this project using each host's supported controls. Codex's read-only shell sandbox does not block every external MCP action. Do not turn on permission bypass to fix an error. Keep credentials outside the repo and do not authorize production database, ad-account, payment or store changes.

Define what “profit” means before drawing a chart

The first version should show product contribution after allocated advertising. That is not the company's final net profit: salaries, rent, taxes and other overhead are excluded unless you explicitly add an allocation policy.

Net product sales = gross product sales - discounts - product refunds
Contribution before ads = net product sales + customer shipping collected
                          - net product cost - fulfillment/shipping cost - payment fees
Contribution after allocated ads = contribution before ads - allocated ad spend

Use product revenue excluding sales tax. Distinguish shipping collected from shipping paid. Product cost must reflect your agreed treatment of returned inventory. Never subtract discounts or refunds twice if an export already reports net amounts.

Download exports through the normal reporting/export controls in the systems you already use. Do not rename fields until you have preserved their original definitions. Place sanitized copies in a private input folder. Tell the models where it is and authorize only that directory. For the first build, let them use fictional fixtures instead of private exports.

When spend cannot reliably be attributed to a product, label an allocation as an estimate. Show total spend, allocated spend and unallocated spend separately. Allocated advertising is not proof that an ad caused a sale.

Prompt 1: Plan the dashboard and challenge the rules

Paste into the configured Claude Code session. Fill in the business context. Write UNKNOWN where you do not know, rather than inventing numbers.

Use Claudex Loop to PLAN and independently REVIEW a product contribution dashboard. Do not implement yet. Keep the explicit model roles and outside-checkout plan/log paths we just confirmed.

BUSINESS CONTEXT
Business/products: [describe]
Reporting currency and time zone: [values or UNKNOWN]
Available systems and sanitized export paths: [list or SAMPLE DATA ONLY]
Known cost/return/ad allocation policies: [facts or UNKNOWN]
Intended user: [owner / finance / operations]

Fable: inspect authorized sample schemas and clarify material business-rule decisions with me. Explain the recommended option and downside of guessing. Do not assume APIs or live account access exist.

Define gross sales, discounts, refunds, shipping collected, net product cost, fulfillment cost, fees, allocated advertising and unallocated advertising. Distinguish contribution from company net profit. Define source field mappings, joins, identifiers, date/currency treatment, allocation weights and rounding. Missing data is unknown, not zero. Reject unsupported currency mixing. Preserve a source row trail for every total.

Plan a local dashboard with CSV import, date and SKU filters, sortable product contribution, negative-contribution flags, a cost breakdown, input-quality warnings and exportable results. Include clear unallocated-spend and excluded-cost totals. No public hosting, telemetry or production writes.

Use the fictional CSV fixture and acceptance checks in this guide. Design a first build with fixture inputs, then a separate reviewed step to import sanitized real exports. Choose a minimal suitable stack and list its prerequisites. Write exact install, run and test commands in PLAN.md after selecting the stack; do not claim commands have passed without executing them.

Astra must review whether the data can support the calculation, whether joins double-count costs, whether ads are allocated honestly, and whether the tests would detect financial mistakes. Record each finding, evidence, response and revised decision. Revise the plan and submit it again when needed, within rounds=3.

Stop at the reviewed plan. Present APPROVED, REVISE or BLOCKED honestly, requested/observed models, unresolved questions and the proposed proof commands. A model's approval does not authorize the build. Ask me to approve the final business definitions and implementation scope.

Checkpoint: you have PLAN.md, an append-only review log and explicit answers to the financial definitions. If ad mapping, tax treatment or historical cost is unresolved, the plan must show that gap. A confident paragraph saying “looks good” is not a review record.

Give the build a test that has a known answer

Fictional test data, not a real business result. Ask the host to create this fixture during the authorized build, or save it as sample.csv in the approved external input folder. This is an already normalized row with costs and spend allocated once to the line. It does not replace the raw-export mapping tests.

order_id,line_id,sku,date,currency,gross_sales,discounts,product_refunds,shipping_collected,net_product_cost,fulfillment_cost,payment_fees,allocated_ad_spend
TEST-001,LINE-001,DESK-LAMP,2026-09-01,USD,200,20,30,10,60,15,6,25

Expected result: net product sales = $150; contribution before ads = $79; contribution after allocated ads = $54. The $60 product cost is already net of any agreed inventory recovery. Do not infer a further cost reversal from the $30 refund.

Prompt 2: Authorize Astra to build and Fable to inspect

Use this only after reading and accepting the current plan. It grants implementation permission within the new local project, not permission to deploy or modify business accounts.

I approve the current reviewed PLAN.md and its business definitions. Use Claudex Loop to implement that exact plan in this local project.
builder=codex
reviewer_model=gpt-6-astra
builder_model=gpt-6-astra
inspector_model=claude-fable-5-1
inspect=on
MAX_FIX_ROUNDS=2
MAX_INSPECTION_ROUNDS=2

Verify that approval still matches the plan's path and content hash and the intended repository. Stop if the plan changed or has unresolved material findings. Verify a clean build checkout and capture the baseline commit. Keep planning/log/diagnostic artifacts outside the checkout.

Have Astra implement the dashboard and tests using fictional fixtures first. You may create project files and perform the dependency installation agreed in the plan, subject to normal tool permissions. Do not use permission bypass, change unrelated global configuration, push code, publish the dashboard, or read or modify live business accounts.

The coordinating host must independently run the agreed proof commands and record actual stdout/errors and exit status. Then have a FRESH Fable session inspect Astra's full changes, including new files, formulas, joins, tests and UI behavior supported by available evidence. Inspectors must state what they could not check.

For accepted fixes, rerun affected tests and inspect the changed snapshot again within the budget. If the host writes code too, log authorship and require the other provider to inspect those edits. Never describe Fable's own code as independently reviewed by Fable.

Deliver: changed files and diff, actual test results, inspection findings and dispositions, unresolved issues, requested/observed models, exact local launch command, local URL if a server really started, and a short manual verification checklist. Stop honestly on a failed test, unavailable model, permission problem or exhausted budget.

Checkpoint: launch the dashboard using the command produced for the chosen stack. Open its actual local URL, import the fictional fixture, check the known-answer totals, test a filter and export the results. A screenshot or “build complete” message alone does not establish correctness.

Connect your own data without granting unnecessary access

After fixture checks pass, export a small complete period from your store, cost records and advertising reports. Remove personal information. Work on copies, not source files. Paste this into the same coordinating session:

The fixture build passed its checks. Plan a separate change to import my sanitized local CSV exports from the directory I authorize. Do not access production accounts.
Inventory each file's actual headers, period, currency, time zone and row count. Propose a field-mapping and join table. Identify whether discounts/refunds/shipping are already included in net fields. Ask me to resolve missing definitions or unreliable identifiers.
Do not silently drop rows, fill missing cost with zero, allocate the full ad budget to every SKU, or use current cost for historical sales without approval. Preserve original exports and row lineage.
Run the change through independent plan review, obtain my build approval, then implement and cross-inspect it. Reconcile totals to the source exports before marking the data usable. Show unallocated costs and spend separately. Record the exact refresh steps so I can repeat the import next week.

If you later want automatic refresh: treat each live integration as a new project change. Identify the actual store/ad platform, approved API, read-only permissions, credential storage, pagination, rate limits, refresh schedule, duplicate handling and reconciliation tests. Obtain explicit access approval. Claudex does not supply those credentials or automatically connect your subscriptions to your business data.

Keep three durable artifacts

1. PLAN.md: business definitions, data mappings, accepted scope, assumptions, proof commands and the approved version.
2. PLAN-REVIEW-LOG.md: review findings, dispositions, revisions, model identities, test evidence, inspection coverage and remaining uncertainty. Record the paths to detailed run diagnostics privately.
3. DASHBOARD-HANDOFF.md: ask the host to produce setup and launch instructions, refresh steps, field definitions, reconciliation checklist, excluded costs and known limitations. Verify the file exists before relying on it.

Keep diagnostics and business exports private. Do not commit them merely to obtain a clean build. Model review logs can contain sensitive code and data even when the dashboard itself contains only aggregate figures.

Troubleshooting

Honest limits and maintenance

This workflow does not merge two models into a new model, guarantee correct code, prove a “two best models” ranking or promise a measured 10x improvement. Its practical value is a second review, a traceable plan and actual checks before relying on a business tool.

The commands and role controls here were checked against upstream documentation. The end-to-end paid model workflow and your account entitlements have not been tested for this guide. Treat the checkpoints as requirements, not as pre-certified results. The fictional dashboard example is an implementation brief, not a claim of a dashboard already built.

For manual updates, inspect upstream changes before running git pull in the downloaded skill repository and copying the skill directories again. Back up local modifications first. For the plugin route, manage updates through Claude's plugin interface. Recheck model access and rerun the fixture tests after relevant tool or model changes. To stop a run, interrupt it in the host and inspect the diff; stopping does not automatically undo edits.

Reference snapshot: documentation checked September 17, 2026. Interfaces, model access and pricing can change.

• Claudex Loop repository, installation and MIT license
• Full workflow and model-role controls
• Runtime, supported model identifiers and permission boundaries
• Clean checkout, build authorization and independent inspection
• Repository's published validation record and limits
• Claude Code installation and CLI reference
• Codex CLI installation and authentication

What this changes

You stop asking one model to be the planner, builder and sole judge of its own work. You get a documented business definition, a challenged plan, a working implementation to verify, and a second provider's inspection. The useful outcome is a tool whose numbers you can trace back to evidence before making a business decision.