I’ve been working on a project by passing it back and forth between Claude and Codex on two $20 plans.

One would run out of usage, and I’d pick up with the other. At one point, my prompt was literally:

You ran out of usage and Codex picked up, then also ran out of usage. Continue from here.

Both tools contributed substantial work, and the feature eventually got merged. But keeping them caught up became its own task—and eventually involved scheduling an overnight shift.

Keeping the handoff straight

I kept the work on a feature branch, committed progress along the way, and had the agents maintain a handoff document: what changed, what passed, what remained, and what needed my approval.

That let the next session get started without me explaining the whole project again. It also helped separate “the code is written” from “someone checked that it works.”

There were still gaps to fill. Once, an interrupted conversation was missing its last output, so I copied that over to explain what the previous agent had already started.

I’m still learning how I like working with coding agents. This gave me plenty of practice at one particular skill: making sure the next agent knows where the last one actually stopped.

Asking Astra to keep going

During one handoff, I tried a more direct prompt with Astra in Codex:

Read the handoff and finish the remaining steps. Give me your plan, then start implementing it without waiting for another approval.

Keep updates minimal. Only ask before dangerous changes. Use smaller-model subagents for focused work where practical.

I wanted fewer routine stopping points and more room for implementation.

I’d define “dangerous changes” more precisely next time. In this case, the handoff already set boundaries around production changes, deletion, and merging.

Astra picked up the remaining fixes, delegated focused work to three subagents, and continued into verification.

One small example stuck with me. It made a layout adjustment to keep action text on one line, then checked enlarged text and revised the fix so the text could wrap without clipping. The verification found a tradeoff and improved the change.

The broader pass covered responsive layouts at six screen widths, accessibility audits, and the actual interface available to a restricted editor account. I supplied the signed-in session for that last check.

For scale, the responsive pass covered 192 page/layout/viewport combinations. Those were checks for specific things like overflow and layout behavior—not 192 independent tests of application correctness. The unit-test command found no test files, so its successful exit doesn’t count as coverage.

It pushed the fixes, updated the pull request, and got a successful preview deployment. When the usage limit interrupted it, the build and accessibility stages had passed. Lighthouse was the final CI stage still running.

Scheduling the next shift

There was another wrinkle in all this switching.

Claude offered to automatically continue when its usage allowance reset. Normally, that would have been convenient. But Astra had already continued the work, so letting Claude resume its old conversation would mean picking up with an outdated picture of the project.

I wanted Claude to start fresh, read the latest handoff, and continue from there.

So I scheduled a routine.

That was my first time actually writing a cron expression. I’d been peripherally familiar with cron jobs through my full-time job, but coordinating two AI subscriptions was what finally got me to use one.

And here’s the fun part: the routine setup wouldn’t let me make it a one-time run. The closest I could get was a yearly schedule, which meant I also had to remember to turn it off afterward.

My overnight handoff now had an anniversary.

The screenshot still showed it active, ready to return to this feature next September. A surprisingly durable commitment to finishing a ticket.

The scheduled handoff did its job. Claude picked the work back up and later completed the merge with my approval after checks passed.

What I’m taking from this

This wasn’t an entire feature built in one prompt. It was work accumulated across both tools and several sessions, with a particularly productive finishing pass from Astra.

The result was concrete: an editor could manage the intended content with restricted access, the interface had been checked across screen sizes, and the changes were merged after CI passed. Public launch remained a separate step.

I haven’t proved that asking for less narration saved usage. Astra still gave progress updates. I also changed several things at once—the instructions, the handoff, and the tool—and the project was further along by that point.

What I did learn is which workflow I prefer.

Codex felt more efficient for me. I liked giving it a defined chunk of work and watching it carry that through implementation and verification. Some of the interaction habits I associate with Opus 5 frustrate me, and that affects how much attention I have left for the project itself.

Claude made meaningful contributions, including the final merge. My preference for Codex doesn’t erase those.

I’ll probably end up budgeting $100 a month for Codex. I want more room in the tool I prefer, fewer interruptions, and fewer handoffs to coordinate.

The two-plan arrangement kept me moving. It also taught me to count my own attention alongside subscription usage. By the time I was scheduling an annual routine for a one-night handoff, that cost was pretty visible.

I’m sharing this while I’m still refining the process. If you’re building this way too, what has actually helped you finish more work? Better handoffs, tighter tasks, a larger plan—or something I haven’t tried yet?