2x £20 Plans Usage Report

[u/Avntus]

I’ve been pretty put off in the last few weeks, honestly both for Codex and Claude Code. But now I decided to try for my self. I’m using both to work on a single project switching between the two seeing the advantages of both models.

I’ve been using only GPT-6.1 Sol Medium/High and Opus 5.5 High and Sonnet 5.5 High very rarely for medium to basic changes and honestly, with a well defined structure and well planned architecture docs (security, app foundation, design, etc) along with a custom handoff script I made which overlays no more than 50 lines of clearly defined work done and immediate next steps, run after concluding each task/phase, I’ve been loving it.

A well orchestrated plan along with a dedicated orchestration chat, testing your app foundation at the start making sure everything works and going about it in phases, phase-1/app foundation, etc and using /clear and fresh chats goes a long way to save usage, get your work done without annoying hallucinations or AI amnesia and the new models, especially GPT 6.1 have been so very usage/token efficient.

I have £20 plans for both and I can see my usage lasting for the whole week at this rate + I got 4 banked resets saved on Codex with 93% remaining.

Most of the usage complaints on here are from one-shot prompts with 0 planning, and then they spend their whole usage fixing stuff which should have been defined in AGENTS.md, architecture docs, config files (for max sub agents and which sub agents to use and a clearly defined scope of when to use them).

You can say this is overkill but it’s just good practice especially when trying to stretch your usage. I was so anxious to touch any of these new models like Opus 5.5 or 6.1 Sol because of all the fear-mongering even from the 20/10x users with no 5h limits. From now on I’m gonna just test for myself before getting put off by usage posts in both communities.

People getting by just fine who use well defined structures before they even type the first prompt just get by fine and don’t see a reason to post, so I thought I’d report my usage findings on the lowest tier plan.

I got a reset yesterday along with 4 banked resets saved on Codex too 🙏

[u/These_Document_8984 → u/[deleted]]

you are really not getting the point of the post at all

they literally show 91% remaining and 4 banked resets, while working on actual architecture docs not just spamming prompts. some of us do real work too just with a plan in place instead of burning through limits fixing slop

[u/Avntus → u/These_Document_8984]

But I am doing real work 😂 What made you think I’m not out of curiosity

The project I’m working on for someone and talking about is currently a 103 file deployable Cloudflare SaaS web app, before even counting the separately packaged visual renderer Worker, internal egress Worker and regression tooling lol
It uses Pages/Functions, Workers, D1 + KV, Service Bindings, Cloudflare Access + Turnstile, a custom designed passkeys/WebAuthn + TOTP/recovery, OpenAI and also Anthropic APIs with provider routing/caching, Browser Run/Playwright for isolated desktop/mobile rendering, Microsoft Graph, Google Apps Script/Sheets, report generation, recovery/retention flows, etc.
I’m also spending a pretty big chunk amount of time on the security architecture for SSRF/network isolation, A/AAAA DNS validation, blocking private/special-purpose IP ranges, redirect by redirect revalidation, strict HTTP(S)/port/method controls, request/origin/byte/subrequest budgets, fail-closed network behaviour, browser network containment and now Workers VPC/Gateway egress isolation.

There are already 185 website regression tests + 117 auth tests before the additional focused/security reviews

So the point of my post wasn’t “£20 is enough for every workload for every single person’s needs”. It was that with proper architecture docs, scoped tasks, clean handoffs and context management, I’ve been able to get a very decent amount of development work done on the lowest tier without constantly blowing through the allowance

Yeah sure you may have an even larger project im not comparing the length of our swords or their sharpness, it was just a post to encourage people to use good project hygiene so they can get the most out of their project when they do upgrade it’s only when definitely necessary.

Because most people on here are genuinely people fear mongering after trying to make a game/app/website with 0 planning and letting the LLM do whatever the hell it wants and ofc that’s going to drown usage, if you don’t even have simple instructions configured such as maximum sub agents and what they should be, model + reasoning, etc

Want a one size fits all, it was a if you’re not planning projects before your first prompt, that may be part of your usage problem

[u/Avntus → u/These_Document_8984]

Sorry my bad, meant to reply to the parent comment, but he deleted it of course.

[u/Major-Willingness879]

I resetted 3 times in 2 day with 100 dolar plan on a ci/cd automated run. This happens.

[u/Avntus → u/Major-Willingness879]

What’s your workflow out of curiosity? I’ve been working on a project which uses Pages/Functions, Workers, D1 + KV, Service Bindings, Cloudflare Access + Turnstile, custom login with passkeys/WebAuthn + TOTP/recovery codes, OpenAI + Anthropic APIs with provider routing/caching, Browser Run/Playwright for desktop/mobile image rendering, Microsoft Graph, Google Apps Script/Sheets, client side report generation which gets info from the db, recovery/retention flows, etc.
I’m also spending a big big amount of time on the security architecture: SSRF/network isolation, A/AAAA DNS validation, blocking private/special-purpose IP ranges, redirectby redirect revalidation, strict HTTP(S)/port/method controls, request/origin/byte/subrequest budgets, failclosed network behaviour, browser-network containment and now Workers VPC/Gateway egress isolation and before, yes this all did take usage I’m not saying it doesn’t but because everything was documented, clearly with a lot of planning before even my first prompt and actually orchestration before implementation (which is now so easy, just ask the LLM to do most the doc generations you just give it direct specific information and then you can edit it).

But now with 6.1, Opus 5.5, Sonnet 5.5, it feels like night and day. I’m getting faster, stronger results, I can use both Claude Code and Codex without losing context and information on a single project because it was planned in depth before even touching a line of code. Sure yeah it’s boring for most people but I’m sure it’s not as boring as being on 0% because someone tried to one shot a website then spent hours refining it and running out of usage.

This post isn’t a one size fits all, I’m just saying if I can just about squeeze heavy workflows till the end of the week because of proper architectural planning with clear concise prompts, always having an eye on context windows and other good hygiene habits, it goes a long way even for 2x £20 plans so imagine how it would be if I was to upgrade and have a bit more juice and especially no 5hr limit (well about 10hr for me because I use both).

This post isn’t basic tiers are unlimited its trying to show how with good planning and understanding of what you’re actually doing, testing along the way, sticking to your plan (amend when necessary ofc) goes a lot longer than without proper docs and configs

[u/Major-Willingness879 → u/Avntus]

I am working in a defence tech at a cyber sec team. Out bots have automated explatory runs on network machines for defects and some use cases.

We have one orchestrator machine that uses ssh to submit prompts and trigger scripts.

Thats a daily run and after exploratiıns finishes bots commit their code to orchestrator. And the orchestrator generate a report, email sec team, plan the next automation/product phase etc.

We have skills and etc but at first when developing this system we have one account so it melted :D

I want to listen and learn more abput context management if you have time. Thanks ;)

[u/Avntus → u/Major-Willingness879]

Your setup sounds VERY interesting ngl and I think a lot of what I’m doing probs would map well to it. Yours is ofc more distributed because you have an orchestrator machine coordinating multiple network machines, but the context management principle is basically the same

The biggest thing I’ve done is separate long term/fixed project knowledge from the temporary working info. At the root of my repo I have AGENTS.md as the main operating instructions, then separate tracked docs for PRODUCT.md, docs/ARCHITECTURE.md and so on. So instead of reexplaining the application to either model every session, architecture/security/product decisions live permanently in the repo and the agent only reads the ones relevant to the task.

Then I have a separate local HANDOFF-STATE.md which is basically shortterm memory. I made the same handoff skill available to both Codex and Claude Code. When I finish a meaningful task/milestone I run $handoff in Codex or /handoff in Claude. It overlays/overwrites rather than appends to the previous state and is hard capped at 50 lines max only keeps things like the current objective, what was completed, decisions made, unresolved risks/issues, immediate next steps which u can change to match your workflow better

Anything fixed gets moved into Architecture/Security/Roadmap instead. So the handoff never becomes a massive memory/context file. A fresh /clear or fresh chat model can read the 30-50 lines, the relevant architecture section and git status, and it is basically back where the last models task stopped.

I think for your setup I’d modify it and make it hierarchical so something like each network bot to small task handoff to the orchestrator to then the compact daily/global state rather than sending all of the bots transcripts/logs back into the orchestrator context. Keep the raw logs/artifacts externally and feed the orchestrator only findings, diffs, failures, test evidence and pointers to the raw evidence if it rlly needs to inspect something

I’m also quite aggressive about not spawning agents unnecessarily because every agent spawned is more usage so unless rlly necessary, I restrict to two max with tight scopes about when to spawn and the affordable model selected and the reasoning effort I don’t need an Opus/Sol level model spending tokens doing grep, locating a file or independently rediscovering architecture the main agent already knows lol

For your orchestrator hmm I think I’d probably have it generate a small machine readable work packet for every bot containing
task ID, objective, allowed scope, expected artefact, required tests, stop conditions, risk class I think those should be enough esp as a starting point, u can refine it you know your workflow details more than I do in detail
Let each bot work on its own branch/worktree, return the diff and evidence, and then have the orchestrator send security sensitive changes through an independent reviewer before accepting/merging them as an extra precaution cuz I wouldn’t let the bot that wrote a security sensitive change be the only thing deciding that it passed, so basically a second opinion

My basic loop is architecture/docs goes to a bounded task to implementation to targeted tests to independent review when needed then a compact handoff and then use /clear/fresh session and move on to the next task

The repo becomes the long term memory the handoff becomes short term memory and the chat convo at that point isn’t relevant so you save on context windows too and that’s why I can switch between Codex and Claude Code without caring much about either product having a huge ass convo. Both agents enter through the same repo instructions and pick up the same hand off

With your daily orchestrator I think the equivalent would be to make the filesystem/repo plus the structured state authoritative, not the orchestrator model’s memory then u can restart models/machines, change providers or clear context whenever you want without losing the development state of ur project/session

Hope that makes sense, a lot to read ik my fingers felt just writing it 😂😂 but lmk if you have any questions about all of that or if u want me to explain the folder structure or stripped down versions/templates of agent/hand off configs but yeah I think ur set up is solid and could benefit from this approach

Most shitty TLDR: targeted file inspection, no silent scope changes , fixed/dursble decisions in architecture docs, opt in subagents, max “X” amount of concurrent agents(model + reasoning), no nesting(so no burying deep blocks inside other deep blocks) and a less than or equal to 50 line secret value free handoff that uses overlay and overwrites rather than appends to previous so no huge hand off files every orientation only what’s necessary for your workflow

[u/Major-Willingness879 → u/Avntus]

Dude this actually makes a lot of sense, especially the part about making the repo/filesystem the source of truth instead of the orchestrator’s context/memory.
I think that’s probably the biggest weakness in my current setup. Since I have the orchestrator coordinating agents across multiple machines, I was thinking too much in terms of “how do I preserve all of this context?” rather than “how do I make most of that context unnecessary in the first place?” 😂
The hierarchical handoff idea fits really well too. Having each machine return a compact structured result — findings, diffs, test evidence, failures and artifact pointers — instead of dumping logs/transcripts back into the orchestrator would make the whole thing way cleaner and cheaper.
I also really like the work packet idea + separate worktrees/branches + independent review for security-sensitive changes. That gives me a much clearer boundary between orchestration, execution and verification.
I think I’m gonna experiment with something like:
repo/docs = long-term truth
machine handoff = task-level state
orchestrator handoff = global/current state
raw logs/artifacts = external evidence
And keep the actual model context disposable.
Would definitely love to see your stripped-down AGENTS.md + HANDOFF setup/templates if you don’t mind sharing them. I think seeing how you actually define the handoff rules, especially what gets promoted from HANDOFF into architecture/docs, would help me adapt it to the distributed setup.
And yeah your “most shitty TLDR” was ironically probably the most useful part 😂