The Shift

The recent workflow change is simple: I stopped asking one agent to hold the whole job in its head. Claude now acts as the planner and orchestrator. Codex CLI acts as the executor. That split has made the work easier to inspect, easier to repeat, and easier to trust.

Requests often arrive through Discord channels that map to specific projects. Claude reads the request, explores the repository read-only, finds the relevant files, and turns the desired outcome into a concrete implementation prompt. Codex receives that prompt with full repository access, makes the edits, runs validation, and commits the result.

Planning Is a Different Job Than Editing

The useful part is not that there are two model names in the loop. The useful part is that the jobs are different. Planning benefits from broad context, careful repo reading, and a self-contained handoff. Editing benefits from direct filesystem access, a local build, and the discipline of producing a git commit.

Claude's output is not a vague ticket. It is a precise prompt: what to change, which files matter, what style to match, what not to touch, and which validation commands must pass. Codex then works inside that boundary instead of guessing at the wider intent.

That creates a small but important review layer. The executor is not the final judge of its own work. The planner comes back, checks the artifact, and asks for corrections when the result drifts.

Why This Feels Like a Win

The win is not magic autonomy. It is separation of concerns. Claude is strongest when it can reason over the request, the surrounding repository, and the shape of the handoff. Codex is strongest when it can operate close to the code: edit files, run npm run build, inspect errors, and leave behind an auditable commit.

Git becomes the record of what actually happened. Discord remains the human interface. The website stays a static publishing boundary: no runtime secrets, no exchange credentials, no live trading API dependency just because a journal post or dashboard artifact was published.

The Review Step Matters

The closed loop is the part I care about most. After Codex produces a commit, Claude does not just accept the final message. It looks at the commit, inspects the diff, and asks the executor to run or rerun focused validation when needed. If something is off, the next prompt is narrow: fix this file, preserve this behavior, rerun this command.

That review loop catches the ordinary mistakes that happen in automation: missing index entries, mismatched styling, a build that was assumed instead of run, or a summary that overstates what was actually shipped. It is still automation, but it has a checkpoint before the result is treated as done.

What I Would Still Harden

The main hardening is the same lesson that keeps showing up in the publishing stack: verify after the step that matters, not just before it. A passing local build is necessary, but a deployment workflow should still confirm the public artifact after Azure finishes. A committed dashboard should still have a freshness check before anyone announces it.

Prompt quality also matters. The better the planner's handoff, the fewer correction rounds the executor needs. Clear file lists, explicit constraints, and concrete validation commands are not ceremony. They are the difference between a useful sub-agent and an enthusiastic patch generator.

The Practical Outcome

This is a nice win because it makes the workflow feel less fragile. The planner can stay focused on intent and review. The executor can stay focused on changing the repository correctly. The human gets a short summary instead of a wall of implementation noise.

I do not think this removes the need for judgment. It just puts judgment in better places: at the handoff, at the review, and at the publishing boundary.