The Loop Outlives the Model.

The day one of them ran out

I was all in on Claude. Work introduced me to it, and I liked that Anthropic built for developers first. I started using it for my personal projects.

The cheapest plan was enough at first. Then the projects grew, and the cheapest plan stopped being enough. The next step up was a bigger usage window, not a better model; it was more than I needed and more than I wanted to pay. Claude kept running out on the smallest plan, but I do a lot. I build things, run projects, grade and research.

So I tried Codex. I had heard good things, and it had a free month. I started using it when Claude ran out. The first time it happened mid-task, I opened Codex, checked out the same branch, and finished the work without changing a single instruction. That should have felt like freedom. Instead it exposed the problem: moving between providers mid-project is not smooth unless something holds the state. That was the day I stopped thinking of the model as the thing I was buying.

They were good at different things, so I started picking between them per project. Then I was jumping between them whenever one ran out. I needed a way to switch without losing the thread. That is how this started.

DeepSeek Harness came later. The price was the first thing anyone mentioned, and I was hesitant because it is Chinese. Then both Claude and Codex ran out with days to go before the refill. I jumped in. It fit.

I have three devices, two subscriptions, one usage account, and a private repo for my AI settings. That is the most 2026 sentence I have written, and two years ago it would have embarrassed me. Now it is the most honest description of how I work. I still get the top model on the entry plans. What I am buying is usage, not access. The usage is the cheap part. The loop is the expensive part, and I built it myself.

This is not a review of Claude, Codex or DeepSeek. It is a report from the room where they meet. It is also one person's setup, offered as a suggestion. The loop does not care which model is underneath; Gemini or a local model would fit the same shape.

The loop was the thing I had not written down

I already wrote the long version of the loop across repositories: I Was Shipping Faster Than I Could Understand It. That note carries a correction. Three weeks after I published it, I found that the doctor had run once in 165 sessions, because the script could not find its own program from any directory except the one beside it. It announced itself unavailable and exited quietly. I left the claim and the correction in public because the gap is the useful part. A loop that is remembered is not a loop. It has to be checked.

The public standards are the contract I wrote for myself; the private repo is the wiring. The link is not a copy. That distinction is the whole note.

If you build a loop, write your own standards. Mine are a draft, not a product.

What the loop actually is

A plan is a markdown file. The board is a window on those files, not a database. Mine is PANTRY, the orchestrator I built: it reads the plans, shows what is ready, and lets a session claim a plan and put it back. It writes nothing back.

PANTRY is not required for the loop. A plans folder is enough; it is just what I use.

A session starts by reading the repo and the plan. The doctor runs first: it reads the repo and puts what is due in front of me. A run leaves a report with the checks it actually ran. A change you can see leaves a short walkthrough. A person who did not write the change checks it. The human lands it.

The loop is five pieces: one instruction file, one plan, one checklist, one report, and a human gate. The setup guide has the terminal output and the steps. This note is why I keep it.

The loop: a plan, a session with the checklist first, a report, a second reader, and the human who lands it. The front door is the rules around all of it. Then the next plan.

The old note has the long version. The standards are public if you want the rules rather than my account of them.

Three harnesses, one standard

The harness was the next gap. Every rule in the loop standards assumes something is running the hooks, and for a long time I did not say what. Then I started moving between harnesses.

The loop had to prove it was not the harness.

The word harness has two meanings, and I have used both. In Everybody Wants the Agent it meant the scaffolding around a model: what it sees, what it may touch, who checks the result. Here I mean the program that runs the session: Claude Code, Codex, DeepSeek Harness. The loop sits above both. When I say the harness changed, I mean the program, not the shape of the work.

I use all three. The first two get the loop through a settings file; DeepSeek gets it through a small plugin. The rules did not change. The guide has the adapter table and the setup.

One public canon, one private wiring, three machines.

I use three machines: a personal laptop, a personal PC and a work laptop. The work laptop gets the same standard and the same config repo because I want one way to code. Work projects stay there; the personal machines never hold them. The private repo is agent config, not content. Each machine gets its own settings and its own path to the board. The public standards are one source. The private repo points at them.

The model is a routing decision

The loop is portable. The model is the part I rent. I had to unlearn the idea that I was buying a model.

The entry plan on Claude and Codex is the one I want. The plan is not the model; it is the size of the window. The entry window is enough. Two entry plans plus the cheap DeepSeek meter are cheaper and more effective for me than the big plan on one.

I max the allowance out on purpose, so I do not feel like I am wasting money. A fixed window is predictable, and it forces me to choose the work. An open-ended token meter makes me hesitate, and hesitation is a tax. DeepSeek is cheap enough that I can meter it, which is why some projects start there.

I am not going to quote the numbers. The shape is what matters.

The routing is simple. Claude Opus 5.5 on Low for the shape, Medium when the problem earns it. GPT Sol on Low or Medium for the long build. DeepSeek when the allowances are out, or the experiment is cheap. A subagent for a wide read with a small answer. The model is a routing decision, not an identity. The Low and Medium labels are how much thinking budget I give the model, not different models. The access is the same.

The model changes with the work. The loop does not.

I choose an owner model per project. The owner is the one I reach for first, not a lock. I have pushed one too hard, hit the five-hour or weekly window, and moved the same project to the other model. The loop is what makes that safe: the work is committed, the main branch is clean, the work sits on its own branch, and the handoff says what the work is and where it stops. The next model opens the same repo, not a different project.

That is the part I did not expect. The model switch is not a crisis. It is a Tuesday. The project does not care which model is typing, as long as the loop is holding the state.

A week with one to five projects

Outside work I run one to five projects at a time. The big one is the next course platform. Last semester's native course platform was the proof that the shape works. This one is the proper hosted platform, and it is the project I would not have started without the loop. I also keep the portfolio current, revisit old work, and teach as a part-time instructor at the School of Computing at Holy Angel University.

The loop is what makes that many threads possible without pretending I can hold them all in my head.

It is good enough that when an idea arrives, I can hand it off and go do something else. That is the part that changed my week, not the model. None of this is a flex about volume. I do a lot with AI because the loop makes the volume safe to carry.

At Career Team I use the company's Claude and Codex with the same loop, for management work and technical work. The work laptop is on company accounts. The hardcoded rules keep the work data out of the personal setup. The config is a standard, not a copy of the work.

Grading is the same split. The loop handles the mechanics; the judgment stays mine. No student data goes into the public repo, and no student data goes into a service I would not trust with it.

The line I do not cross

The privacy question is not one question. I work from home, so the work laptop sits in the same room as the personal machines. The separation is the machine and the account, not the room. On the work laptop, I use the company's Claude and Codex. Work projects stay on the work laptop and in the company accounts; they do not move to the personal machines. Personal projects stay on the personal machines; they do not go into the company accounts. The work devices have security built in that would flag or block a personal project before it got far. The private repo is agent config, not content. That separation is not a disclaimer. It is the thing that lets me use the same loop for work and for personal projects without lying about which is which.

DeepSeek is a Chinese service, so the data is under a different jurisdiction. I use it for work that is already public or disposable, and for experiments where the cost matters. I do not use it for student data, employer code, or anything private. I build in the open, so the public part is public by design. That is the trade I make, and it is not one I would make for data that is not mine to publish.

Local models: I would like one, but the math does not work yet. The token volume I would need to pay off the hardware is large, and a coding model that is worse than the paid one is not worth the desk space. I will wait for a consumer GPU that reaches the current frontier, something like Opus 5.5, hopefully in a year or two. That is a hope, not a forecast. When it happens, the loop will not care which model is underneath.

What I have not solved

The loop is finished enough for me. DeepSeek has no stop signal I can catch, so the close check fills the gap. It reads the session log, scopes the dirty paths to this session, and says whether the session can be archived. The next session's start checks the tree. The nudge is the reminder, the close is the check, and I run the end command anyway.

Each new harness needs a small adapter, and I will have to write one when the next one arrives. The private config is one point of failure: if it breaks, all three machines break. It is not three drifting copies. link-machine.sh links each machine to the same config, and the checklist catches a machine that has slipped. The drift is a failing row, not a slow surprise.

The checklist can prove the loop loaded. It cannot prove the work is good. The second reader is still the thing that catches the work.

This is one person's setup, not a study. Tool preference is not evidence. The standards name the capability, not the vendor, because the vendor will change. The test is whether the loop still runs when it does.

The sources

The people whose work this builds on are on the reading page: Addy Osmani for the loop and the comprehension-debt warning, Alfonso Graziano for writing down what I meant, and Cole Medin for the project as one artifact. The standards are public; the guide has the links.

The part I keep

The setup is its own note: Set Up the Loop With One Prompt. The story is why; the guide is how.

The plans will change. The models will change. One day the model might run on the desk. The loop is the part I keep: the plan, the gate, the evidence, the human who lands it. The model is the part I rent.

That is the whole bet. I am not loyal to a model. I am loyal to the loop that lets me switch.

The judgment is human. The typing, by design, is not.