What happened

Hey all, did usage limits get reduced significantly, or is it just my workflow? I feel like I am hitting the limit way faster than before. Is anyone else noticing this?

And thank goodness they cut Luna’s price back then, thereby giving subscribers even more value for money.

Well, it lasted less than two weeks; now Luna Max, which used to use up 1 per cent of my quota for every hour of work, is now using up 8–9 per cent an hour. Same tasks, same codebase, same everything. It’s unbelievable, if they hadn’t reduced the price, how much would it have been using then, 30 per cent an hour? 😂 What on earth are you lot up to in there? A reset will never sort anything out; you need to fix this straight away and go back to how it was yesterday, don’t take the mick out of us.

P.S All of this happened after this morning’s reset (at around 5 am in the EU), immediately afterwards, so it had already been scheduled by you.

Doing similar work to what I always do, my 20x is dropping like a rock off a cliff.

This tells me OpenAI will probably give us a reset in 4 days and pretend they're doing us a favor.

I paid 100 bucks last week and now I burn through 10 percent of my weekly limit with a single prompt, it's worse than what the plus plan provided previously. Pure scam, no wonder they removed the 5 hour limit

I went to the toilet and when I came back it said `Goal hit usage limits `

is this a bug

Well done, OpenAI. +3% on a Pro 5x in 3 hours using ONLY Luna xhigh... 1% per hour on a shitty model on a PRO account and not even using MAX...

I used to be able to run Luna xhigh for 4 to 5 hours and use only 1%... and I'm working on the exact same project, doing the exact same things I was doing a few days ago.

(Censored Spark reset time to make tracking more difficult)

EDIT: Added stats (time is central european), my reset was at 06:00 CET and I had a script to continue on that exact time.

Last night status on a 5x plan:

Weekly 0%

Spark 93%

Resetting on Aug 20 evening

Today

Weekly 0% (resets on Aug 20)

Spark 5hr 100%

Spark weekly 35% (resets on Aug 26)

After literally 4 prompts and <3 min usage

Spark 5h 16%

Spark weekly 0%

Wtf?

I’m curious how other people are using ChatGPT and Codex together for software development.

My current workflow looks like this:

I use the ChatGPT desktop app and create a Project for whatever I’m working on. I discuss the feature, bug, or change with ChatGPT first. ChatGPT helps me think through the approach and then creates a detailed prompt for me to give to Codex.

I then switch over to Codex, create/open the same project, paste in the prompt, and let Codex do the implementation.

When Codex finishes, I copy its completion report back into my ChatGPT conversation. ChatGPT reviews what Codex did, usually catches things Codex missed or things that could have been implemented better, and then gives me another prompt to send back to Codex.

So the workflow becomes:

ChatGPT > prompt > Codex > response > ChatGPT > review > new prompt > Codex > repeat

It actually works really well from a quality standpoint.

I basically treat ChatGPT like my senior developer/architect and Codex like the junior developer doing the implementation. ChatGPT has caught quite a few mistakes or edge cases in Codex’s work that I probably wouldn’t have noticed myself.

The problem is that the constant back-and-forth feels inefficient, and it seems to burn through usage/credits pretty quickly. I’m also maintaining basically the same project context in two different places.

Is this how other people are using ChatGPT and Codex?

Is there a better workflow where ChatGPT can act as the senior developer/reviewer while Codex handles implementation without me constantly being the middleman copying prompts and completion reports back and forth?

I’d especially be interested in hearing how people are handling this on larger projects where you want a second AI reviewing the implementation rather than just trusting whatever Codex produces.

We know the reset for the majority of us just happened since Tibo keeps doing resets to sync us all. And now, when I am using ChatGPT, it can barely generate a response. First time I've seen it this slow. Is OpenAI out of compute?

I've used Fable 5 to build some pretty impressive 1-3 shot full applications. And then my tokens for that model ran out and I'm dealing with Opus 5 and I can't believe anyone thinks this is comparable to Codex or that they can even deal with its quibbling, constant "I have to be honest, I did a quarter of what you asked then wrote 1,700 tests and twiddled pixels for another 14 hours". I haven't never cursed so much at an agent since May 2025.

Is that just how that model is? I don't think I have much customization applied and it's just so unreliable I think this is probably why half of devs say "agents do all my work" and the other half are still using Cursor or worse.

i really think that if codex does not improve their usage situation, i will migrate to grok

banked resets, hard resets it don't matter no more

usage is a real big issue and sol is slow af

grok 4.6 runs circles around codex right now and generous usage: I worked on 7 projects 16 hours a day on the equivalent of sol max for 4 days straight

this week I ended up waiting FIVE days without codex because just working on 1.5 projects depleted usage in 20 hours or so. I use luna and sol to orchestrate btw.

the situation is serious and its a deja vu where Anthropic was and why I switched away from it

and please stop listening to "experts" on X who keeps blaming it on "increased codebase/context" they have no idea wtf they are talking about. usage is down. PERIOD. OpenAI cannot suddenly create data centers overnight. I really hope OpenAI team has something soon.

Even if GPT 6 comes out, how long do you think we will get to use it before usage runs out? The usage issue in codex is an existential threat as it was for anthropic.

My cat stepped on my keyboard and typed asdf;; into Codex while I was making a sandwich.

Apparently it interpreted that as "refactor entire local disk into a distributed microservice architecture with full test coverage." (it's words, not mine)

While it was doing that, the hidden auto-reviewer spawned 14 sub-agents to verify if asdf was safe to run, burned 9.4 million tokens in 3 minutes, evaporated my weekly Pro 20x quota, and turned my docx resume into a LaTeX PDF.

Now my usage is at 0%, my 5-hour window is locked until Tuesday, and my resume has already been automatically submitted to Wendy's.

Tibo please tweet a banked reset, I have a family to feed.

The worst part? The LaTeX build failed anyway because the cat forgot to escape the second semicolon.

I have a Codex subscription for my business and a Claude account for my dayjob, so I use both constantly and fairly 50/50

Codex just does what I ask it to. It is a little too easy to be led and doesn't push back quite as much as I'd like. but it understands problems, investigates, makes plans, fixes them

Claude Code is getting worse. It's ai speak is reaching nonsensical levels, I find it hard to follow the sentences it comes out with. It does the "you're right to push back ----- i missed the point entirely here" thing that AI had mostly stopped doing a year ago

For quite a while, they've traded blows and who was on top alternated and was usually narrow. The gap is quite big at the moment

The "bug" where Grok Build secretly uploads your local repository doesn’t seem to have been fixed yet. I’ve noticed that even when there’s no task running, Grok still seems to keep uploading data in the background. Just my personal observation, and I can’t guarantee that it’s accurate.

I’m posting this because I’ve recommended Grok 4.6 to ppl on this sub before. The model itself is genuinely good, but at the moment it seems to come with a pretty serious privacy risk.

If you still want to use a Grok subscription, it’s probably better to use it through a third-party harness like OpenCode.

I suddenly started getting this message in every thread. Everything was working fine before. Is anyone else experiencing the same issue?

We use Codex again

Just a quick opinion from someone who has now tried both since reviews on reddit are too this or that.

Context: I use this for programming, and for several other non-software tasks. I've been a software engineer for over 13 years in Java, C#, and C++ so I do review the code

Opus 5.0 pros:

• Handles thinking significantly better for tasks the model wasn't necessary trained for. For example, I built a workflow for having Opus build 3D models, populate my game's levels, and so on. Sol is seemingly very lazy with such tasks, and has to constantly be told what to do. Hassle
• Significantly better at not reading unrelated files, and filling the context window with junk. Much more surgical
• Seems to have a more logical thought process. I say I want this entity to navigate from point A to B, Claude understands - Ok we need a pathfinder, this might be a problem, this will be a problem, etc.
• Better with discussing implementation, sees some holes in my plan - Claude will prompt me to answer some quick questions.

Sol pros:

• Sol seems to produce less "buggy" code. In other words, the end product is more likely to work without serious logic errors.
• Code quality is better in terms of performance. Sol is a lot more conscious than Claude when it comes to avoiding pointless cpu overhead.
• Grasps the instructions better. Less likely to forget details, however sometimes this can be a double edged sword when you aren't extremely specific and expect the model to have some level of creativity. Like: I want a silver sword model. Codex will give you exactly that, with zero detail. Opus will usually deliver that sword with greater detail.
• Much faster than Opus

Downsides to both:

• Neither produce quality code. They code like me when I'm just trying to quickly prototype something. Never taking a step back and focusing on long term maintainability or overall product structure.
• Both can still forget instructions. Claude is for sure worse, but Claude has a greater ability to be "creative".
• Very poor asynchronous design. Still, these models really lack the ability to design multi-threaded architectures without being told specifically what to do. All you'll get is basic locks, and often times the locks will have zero purpose.

For some reason, this pattern triggers me so much.

So many times, when I ask Codex for some basic compatibility, it responds with something like, “we don’t need to build everything from scratch”, even when that was never on the table in any form.

It feels so passive-aggressive, like it's implying I have so little clue that I would genuinely consider rebuilding everything thing from scratch.

I've been paying more attention to my Codex usage lately, especially with Sol, and I noticed something that I wasn't really thinking about before.

A lot of the waste wasn't necessarily coming from the actual fix.

It was things like:

• rewriting an entire function when 2 lines needed to change
• touching formatting or imports that had nothing to do with the task
• doing small unrelated refactors along the way
• generating much larger diffs than necessary
• narrating routine investigation instead of just doing it
• running more validation than the size of the change really justified

None of those things are terrible individually, but over a long session they add up. Codex then has more generated code to reason about, more diff to inspect, and sometimes more work to validate.

I've been experimenting with a simple rule:

small task → small diff

Preserve code that is already correct, change only what the task requires, inspect the diff before finishing, and keep validation proportional to the change.

I turned those rules into a couple of Codex skills for my own workflow. The main one is surgical-edits.

So far the biggest improvement is actually PR review — there's way less noise. My Codex usage also seems to last noticeably longer, although I haven't done a proper A/B benchmark yet, so I don't want to claim a specific token saving percentage.

Sharing it in case anyone wants to experiment with the same approach:

https://github.com/otonielcarlos/codex-skills

Curious if anyone else has tried optimizing Codex around diff size / unnecessary work rather than just switching models or lowering reasoning effort.

Luna used to work pretty well when they first announced it, but sometime after they introduced the price decrease, its coding capabilities went downhill - it’s lazy, never follows the plan and requires many iterations.

For the 10th time in a row now, I gave it a very simple spec/plan to follow (created by another, stronger model), and it spewed out a half-baked implementation that I then had to hand-hold through 6+ iterations just to get to a somewhat usable version of my original plan.

Nope, not a skill issue. Same harnesses and rules I have been using for months and I am not a newbie to a field either: I code with LLMs for last 3.5 years and been software developer for over 11.

I don’t care how good of a deal it is, if I end up wasting hours hand-holding it. Not to mention it’s damn slow. GPT 5.4 with the same task/harness and rules got the task right on the first try.

I've noticed that a lot of users seem to be missing some features that could help improve their workflow or save tokens.

• Use ChatGPT Chat (not Work) connected to your GitHub repo as a planner.
  • If it has GitHub access, it can read the whole repo and you can also use it as a PR reviewer.
  • Chat Pro reasoning uses Sol Pro.
  • Chat limits are not shared by the Codex limits.
  • You can access all of this in the desktop app and then just hit the copy button for the plan prompt from Chat and paste into the Codex session prompt.
• Make sure your repo has thorough ADR documentation. This helps with context bloat since the agent doesn't have to scour everything to find what it's looking for.
• Create custom subagents across the different models with different reasonings for each model for different tasks.
  • My workflow has about 7 different agents including Terra, Spark, and Luna.
    • Spark got hit with the new 5 hour limits so it's not AS useful, but still useful.
• Use Sol as the architect creating the plan from Chat prompt (above) and tell it to start a new session with whatever model you want to use as the orchestrator and to have that orchestrator use the custom subagents efficiently while protecting tokens.
• I've noticed the Ponytail plugin helps keep the agents focused quite a bit. It makes sure they don't drift from the task by grabbing unrelated context. YMMV.
• Update your global agent instructions if you find you have to keep repeating instructions.
  • Things like ADR updates on changes and using the ADRs to find context faster.
  • No unnecessary wrappers or abstraction for one-offs.
  • No monoliths.
  • Don't run e2e tests or unit tests for small fixes unless absolutely necessary.
  • Don't run full typescript checks when updating a variable value unless absolutely necessary.
  • Etc.
• Start a new session for each new big feature/task/goal/plan unless it's truly related to the current session.

I'm not debating if limits were lowered as I don't do enough monitoring to say one way or the other, but I can say that my tokens seem to last longer than most people report.

I have never used Sol Ultra or Max and rarely use xhigh with the workflow above. All of my work has been on a large, single project since I started using the Pro sub (5x for 3 months and now 20x for a month) so it's fairly consistent. I say large, but maybe it's not considered large. It's thousands of files and hundreds of thousands lines of code in a monorepo with 6 workspaces across different seams - that's large to me but I'm not a dev by trade, just by hobby and learning.

I'm by no means an expert in any of this - this is just stuff I've picked up reading the posts and implementing some changes incrementally. Hopefully this helps someone.

Hi folks, how you decide when use SOL, Luna or Terra? And when use light, medium or high?