Hey, it's Daniil.
The "best model" for my work changed hands at least four times this year.
Fable 5. GPT-5.5. Opus 5.5. Fable 5.1. Plus Chinese open-weight models that cost about as much as a rounding error and handle half my tasks just fine.
I used to lose a day on every switch. New app. New chat history. New memory. Re-explain the business, the voice, the repo. Re-teach the same three mistakes.
I wasn't switching models. I was onboarding a new employee every month, and it was always their first day.
So I stopped switching apps. Now I switch frameworks and today sharing my fav one.
My context lives in one Git repo. My skills live in one folder. My tools plug in through MCP. The model is rented: Claude plans, Codex builds, a model at five cents per million input tokens does the grunt work, and Hermes answers on Telegram when I'm away from the laptop.
A new model drops? I plug it in the same afternoon. Nothing else changes.
By the end of this issue, you'll have:
a private GitHub repo that Claude, Codex, Cursor, Gemini CLI, Hermes and BB all read the same way;
3 portable skills that turn "switch models" into a one-line prompt;
a routing table that tells you which model to pay for, job by job;
a working workflow where one model builds and another reviews until it's right;
all of it as a starter kit you can copy in 5 minutes.
Bookmark this one. It's long, and you'll come back for the templates.
In today's issue:
Why work LLM-agnostic at all (and when not to)
The 5-layer stack
Context: your GitHub repo is the brain
Skills: write it once, every model can run it
Tools: MCP and integrations without lock-in
Models: subscriptions, OpenRouter and cheap inference
Orchestration: BB, workflows and Hermes
The starter kit: prompts and templates to copy
The honest catch
The difference, in one Tuesday afternoon
It's 4 pm. You're halfway through a feature with Claude. The banner appears: you've hit your 5-hour limit.
Old way: You open ChatGPT/Claude. Paste the code. Explain the project, the stack, what you already tried and why the obvious fix doesn't work. Twenty minutes later, it confidently suggests the obvious fix. You give up and wait for the reset.
New way: You type "hand this off." Claude writes HANDOFF.md: goal, current state, decisions, what failed, how to verify, next 3 steps. You open Codex in the same repo and paste one line. It reads AGENTS.md, reads the handoff, restates the task in 3 bullets, and keeps going. Two minutes.
Same task. Different model. The difference is where the context lives.
Lesson 1. Why work LLM-agnostic at all
Four reasons. In order of how much they cost me.
1. The best model changes every month
Not every year. Every month. If your workflow lives inside one vendor's app, every leaderboard shake-up is a migration project.
If it lives in your repo, it's a config change.
2. Limits are the real price
Claude Pro and Max have a 5-hour session limit plus a weekly limit, shared between Claude and Claude Code (source). ChatGPT Plus has 5-hour windows for Codex too (source).
When you hit the wall at 4 pm on a Tuesday, "just use another model" only works if the other model already knows everything the first one knew.
3. Prices differ by 100x
Claude Fable 5.1 costs $50 per million output tokens (Anthropic pricing). DeepSeek V4.1 Flash on OpenRouter costs $0.50 (OpenRouter). That's a 100x difference.
Fable is worth it for a plan. It is not worth it for renaming 400 test fixtures.
4. Vendors change the rules
Plans get repriced. Limits get cut, restored, cut again. Features move behind higher tiers. Accounts get flagged. Once, an API key we depended on ran out of credits in the middle of a job (more on that in Lesson 5).
Any single vendor is a single point of failure. That's fine for a toy. It's not fine for a business.
When NOT to bother: if you use one chat app a few times a week for emails and summaries, stay there. This setup pays off when AI does real, repeated work for you: code, content, research, operations.
Do this: List every place you'd lose work if one vendor banned you tomorrow: instructions, memory, projects, custom GPTs, connectors. That's your migration list. (Prompt 2 at the end does it for you.)
Lesson 2. The 5-layer stack
Here's the whole idea in one picture:
From the bottom up:
Context answers what's true: who you are, what you sell, what was decided and why. It lives in a Git repo as plain Markdown.
Skills answer how we do things: repeatable procedures as
SKILL.mdfolders. Every major agent now reads the same format.Tools are what agents can touch: MCP servers, CLIs, API keys. They're configured once in files any agent can read.
Models are who thinks: Claude, Codex, Gemini, open-weight models. This is the only layer you rent.
The orchestrator decides who does what, and when: BB threads and workflows, Hermes in Telegram.
The test for every piece of your setup:
If you cancelled this vendor tomorrow, would you lose it?
If yes, it's in the wrong layer. Move it down.
Chat history inside ChatGPT? Gone. Custom GPT instructions? Gone. Claude Project knowledge? Gone. A context/decisions.md file in your private GitHub repo? Still there. Every future model can read it.
Do this: Put every AI tool you pay for into one of the five layers. Anything valuable that only exists inside a model's app (layer 4) moves down this week.
Lesson 3. Context: your GitHub repo is the brain
A couple of months ago, I wrote about hiring four AI agents and becoming their middle manager. Claude knew things Codex didn't. Hermes knew things neither of them did. I was the human API between them.
The fix wasn't a smarter model. It was one shared place where the truth lives.
That place is a Git repository. Here's why, compared with the alternatives:
Every agent can read it. Claude Code, Codex, Cursor, Gemini CLI, Hermes and BB all open a folder natively. None of them can open your ChatGPT memory.
Every change has a history. When an agent "improves" your rules into corporate mush,
git diffshows it andgit revertfixes it.It works on any machine. Laptop, the Mac Mini at home, a cloud sandbox, a teammate's computer.
git pulland every agent is up to date.It's free and boring: no vector database, no embeddings pipeline. Boring is the point.
The repo structure
This is the template. Copy it, delete what you don't need. A link to a GitHub repo you can use is below.
my-ai-workspace/
├── AGENTS.md # the router every agent reads first
├── CLAUDE.md # one line: @AGENTS.md
├── context/
│ ├── about.md # business, audience, rules for deciding
│ ├── examples/ # your best past work: style comes from evidence
│ ├── decisions.md # dated, append-only: what we chose and why
│ ├── lessons.md # corrections that became rules
│ └── models.md # routing table: which model for which job
├── skills/ # the ONE real skills folder
│ ├── write-back/
│ ├── model-handoff/
│ └── skillify/
├── projects/
│ └── newsletter/
│ ├── AGENTS.md # project rules (closest file wins)
│ ├── CLAUDE.md # one line: @AGENTS.md (see below)
│ └── HANDOFF.md # current state, written by model-handoff
├── .bb/workflows/ # multi-model workflows (Lesson 7)
├── .mcp.json # tools, secrets as ${ENV_VARS}
├── .env.example # key NAMES only; .env is gitignored
└── scripts/link-skills.sh # symlinks skills/ into every agentThree design choices matter more than the rest.
1. AGENTS.md is the router, not the encyclopedia.
AGENTS.md is now an open standard stewarded by the Agentic AI Foundation under the Linux Foundation. Codex, Cursor, Gemini CLI, GitHub Copilot, Zed, Warp, Devin, Amp, Jules and others read it natively. The site says it's used by over 60,000 open-source projects.
"A README for agents." One file name that every tool agreed on.
As of v2.1.277, Claude Code reads it too, but only when there's no CLAUDE.md in the folder or above it (docs). That's why the template has a one-line CLAUDE.md that says @AGENTS.md. Older versions follow it, and there's still a place for Claude-only notes.
Keep it short. Its job is to tell the agent where to look, not to contain everything.
2. Nested files: the closest one wins.
Put an AGENTS.md inside projects/newsletter/ and every agent working in that folder gets the project rules on top of the global ones. Codex walks from the repo root down to your current folder and merges the files root-first, so the closer file wins (docs). Claude Code loads a subfolder's AGENTS.md only when no CLAUDE.md takes precedence (docs). Since the root has a CLAUDE.md, give each project folder the same one-liner: a CLAUDE.md that says @AGENTS.md. Or set Project instructions to claude-md-and-agents-md in /config.
3. Decisions and lessons are append-only, with dates.
This is the part everybody skips, and it's the part that compounds. Every time you correct an agent, the correction either goes into lessons.md or it's lost when the session ends.
Rule of thumb: if you've corrected an agent twice, it's a lesson.
"Wait. Isn't this context bloat?"
Every 6 months, delete your Claude MD. Delete your skills. Delete your hooks.
Boris Cherny, guy who created Claude Code
He's right about the bloat. And he isn't contradicting this post.
The instructions Claude reads every time should fit in about 200 words. There's no about-me file.
That's exactly the shape I'm recommending:
A tiny router.
AGENTS.mdpoints to files instead of containing them.Evidence instead of descriptions. Your best past work goes in
examples/. Don't write a paragraph about how you write.Rules from edits.
lessons.mdgrows from real corrections, not from guesses about what the model needs.
So do the 6-month cleanup too. Delete every rule that today's models follow without being told.
The AGENTS.md template
# AGENTS.md
## Who you are working for
[One paragraph. Who you are, what the business does, who the customer is.]
## Where the truth lives
Read only what the task needs:
| Need | File |
|-------------------------------|-----------------------------|
| Business, audience, offer | context/about.md |
| How we write (real examples) | context/examples/ |
| Past decisions and why | context/decisions.md |
| Corrections that became rules | context/lessons.md |
| Which model for which job | context/models.md |
| Project-specific rules | projects/<name>/AGENTS.md |
If two files disagree, the newer dated entry in decisions.md wins.
If you still can't tell, stop and ask. Don't pick one quietly.
## How we work
- Plan first for anything over ~15 minutes.
- Small, reviewable changes. One concern per commit.
- Prove it works: run the check, show the output.
"Should work" doesn't count.
- Never invent numbers, quotes or results. Mark gaps as [TK: ...].
## Hard rules
- Secrets live in .env (gitignored). Never in code, docs or commits.
- No sending, publishing, spending or deleting without approval.
- Read-only access is the default for new integrations.
## Before you finish
Run the write-back skill if you learned something future agents need.The decision log format
## 2026-10-29 · Images go through our own MCP server
- **Decision:** All image generation goes through cai-img MCP.
- **Why:** Same styles for every agent. Backend can change
without touching the agents.
- **Rejected:** Separate generators per app. The styles drifted.
- **Revisit if:** the provider chain fails twice in one week.That "Rejected" line is gold. It's what stops Codex from confidently proposing the exact thing Claude tried and abandoned last week.
Do this: Create a private repo with just two files: a short AGENTS.md and an empty context/lessons.md. The next time you correct an agent twice, write the lesson down. Add everything else only when you need it.
Keep your mailbox updated with practical knowledge & key news from the AI industry!
Lesson 4. Skills: write it once, every model can run i
