How I use my $600 of Claude and Codex Plans to Build Software

i've been in software engineering for more than 10 years. here's how i setup my infrastructure to take advantage of my $600 2x claude max and 1x codex max plans.

and don't worry, i'm not a vibingbro

(warning, this is a long post, bookmark for reference, but i suggest you give this to your agent and ask what you should steal from me, to make your life easier)

i don't think i have to tell anyone at this point, that nobody writes code by themselves anymore.

it's all about how you design the system around it, so that it carries itself as far as possible, without your involvement.

my main setup is now a big beefy baremetal server at Hetzner (they're pretty cheap: $90/month for a ryzen 7 with 64gb ram and nvme ssds, when you get it at their auction)

i've configured it with nixos and am running a vm inside which hosts a @t3dotcodes server.

being able to remotely connect to your workspace, means all your work is shared across your devices. i can dispatch long running investigations and refactors over night, and check them in the morning on my phone (ask your agent to do a preview build of the t3code app, until they release it themselves)

if you want the same setup, ask your agent to steal this: https://github.com/NicolaiSchmid/agent-infra

buy a server manually from hetzner or wherever, and then use computer use (or npx browse if you're on a headless machine), to configure ssh and setup the nixos vm setup.

now, enough setup!

the building part is actually quite straight forward. since i have the always on infra in the background. whenever i have an idea i just launch a new agent/thread. to figure it out.

right now, it's split between t3code, my hermes agent (also part of the infra repo above), and my custom nicool.ai agent.

i hope that in the future everything moves from hermes to nicool.ai (i'm building into a professional agents platform) and it will integrate nicely with t3code (or whatever i'll be using next month)

for big features, refactors or product changes. i first get an investigation going, by asking gpt56 to send of subagents to investigate the idea. (just one week ago it was fable, not gpt56, so i might switch to 2 codex plans and 1 claude)
i usually prompt this in one sentence, plus a few architectural thoughts, if i have them already. at the very least, i add a few constraints of what i don't want

this usually takes a while to figure out in the background. and with a little bit of sparing back and forth we turn this into a solid plan.

then, the main orchestrator breaks this plan into smaller implementation parts (on these modern models, that happens directly, i don't need to prompt it), and ask to dispatch subagents to validate all assumptions in this plan.

what helps is to actually ask the agents to run code. to test out apis and libraries, so we're not based on reading the docs, but have actual empirical data on what will work and what won't

once we have a solid plan, we dispatch subagents to encode some of our requirements into tests. this will give the implementation agents something concrete to work against, which provides feedback and is not just 1d text.

after that, we dispatch more sub agents to implement. this is usually a codex subagent for the main work (when i still was using claude for orchestration, i asked it to run codex cli through bash). for ui and frontend stuff, i'm still very much relying on opus/fable models. gpt still sucks quite hard at making things look good!

each of these implementation agents is also asked (via agentsmd) to validate their work via typchecking, linting, running full builds, and finally running codex review via bash in a loop until everything is green.

there's no point in reading the code before you've thrown enough tokens at it, to fix it themselves.

sometimes the subagent will get stuck in a review loop. where on every turn, new issues are found and then addressed and it doesn't end.

this is almost always an issue of architecture. it helps to then dispatch 2 agents for investigation into design flaws. one with the history of reviews, and one clean one. if they converge on the same design, we have a path forward.

once all these fan outs and loops wrap up, we assemble everything into distinct PRs and commits (i prefer separate refactoring PRs and then a clean feature PR).

my nicoo.ai (and before that hermes) agent has a PR watchdog, which comments @codex review, so that the reviews get reliably triggered (the codex auto trigger is broken sometimes, for some reason)

since we've done a lot of review before then, it usually comes back green.

then, just for good measure, we launch another few investigation agents across codex and claude to validate that all this makes sense, and now it's finally time for human review!

i read the code, leave normal github PR feedback. then back on the main orchestration thread, i ask it to pick up, and use the same infrastructure (subagents) to investigate, address and fix it!

that's my current worksetup! it's changing a lot and keeps improving (kaizen for the win!) but i really love what we're capable of doing now.

a few days ago, i used this to create a new documentation from scratch for a chatbot product i maintain. it ran for 8h (with a little steering in between from me, and a few followup). but it basically one-shotted a 7/10 product documentation including screenshots, interactivity and keeping it up to date.

we live in crazy times my friends! use this at your own risk, and have fun with it!!

PS: codex bar is super helpful to keep an eye on all my usage limits!