---
title: "The Loop Outlives the Model."
subtitle: "Three models, one loop: how I use Claude, Codex and DeepSeek at the same time with almost no friction."
author: "Tjakoen Stolk"
status: PUBLISHED
type: note
date: 2026-11-08
readingTime: "~11 min"
tags: [ai, workflow, standards, developer-tools, process]
summary: >
How I run Claude, Codex and DeepSeek on one shared loop. The public standards are the contract, and
a private agent-config repo wires them across my machines. Choosing a model is a routing decision,
not a brand loyalty. The entry plans on Claude and Codex still unlock the top model, so the only
constraint is the usage allowance, not access. A unified loop is what makes that allowance more
than enough. This is my setup, a suggestion, not a rule: the same loop fits Gemini, a local model,
or whatever comes next.
social: |
I kept running out of Claude in the middle of a task. One day I opened Codex on the same branch
and finished the work without changing a single instruction. That was the day I stopped thinking
of the model as the thing I was buying.
What I needed was a loop that could survive the switch. This piece is how I built it: the public
standards are the contract, a private agent-config repo wires them across my machines, and the
model is a route.
The entry plans still reach the top model. The only constraint is the usage allowance. The loop
is what makes that allowance enough.
socialImage: "/media/notes/one-loop-three-harnesses-social.png"
socialImageAlt: "One person running Claude Code, Codex and DeepSeek on one loop."
---
## 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](one-loop-every-repo.md). 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](/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](/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](one-loop-every-repo.md) 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](build-the-floor.md) 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.
| Work shape | What I reach for | Why |
|---|---|---|
| The shape is still moving, or the bug is hard | Claude Opus 5.5, Low, then Medium when it earns it | The plan is the hard part; a wrong one costs more later |
| The plan is clear and the build is long | GPT Sol, Low or Medium | It holds a long build |
| One allowance is exhausted, or both are, or the experiment is cheap | DeepSeek | The backup, and the cheap experiment |
| A wide read with a small answer | A subagent on any model | It reads wide; I get the short answer |
*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](/teaching).
*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](https://careerteam.com) 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](/reading):
[Addy Osmani](/reading#book-loop-engineering) for the loop and the comprehension-debt warning,
[Alfonso Graziano](/reading#book-ai-native-engineering) for writing down what I meant, and
[Cole Medin](/reading#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](loop-setup.md). 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](ten-times-zero.md). The typing, by design, is not.*