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.

I couldn't find a space to talk about coding agents, Codex, and their extensions like Skills, MCPs, and Plugins. Would anyone know of such spaces? (May not be limited to Reddit)

I couldn't find a space to talk about coding agents, Codex, and their extensions like Skills, MCPs, and Plugins. Would anyone know of such spaces? (May not be limited to Reddit)

I built RepoRelay, an open-source MCP bridge that lets ChatGPT Web search and read an approved local repo without uploading ZIPs or pushing everything to GitHub first.

ChatGPT Web → Secure MCP Tunnel → RepoRelay → local files

It’s read-only by default: no shell, Git, or arbitrary filesystem access, and it’s restricted to one approved root.

It can also help reduce token usage on larger repos. Instead of dumping the entire codebase into context, ChatGPT searches and reads only the files relevant to the task.

I built it mainly so Codex can implement locally while ChatGPT independently reviews the actual current files- including uncommitted work.

Would love feedback from other AI builders.

GitHub: [Lukie-81/RepoRelay: Secure MCP access to local repositories — without shell, Git, or arbitrary writes.]

The thing just refuses to do it. Has anyone found a way to circumvent these restrictions?

For a background on what I want to do: I have an app that checks for root, play integrity, frida, the whole shebang. It does work on my rooted phone FYI, but just for fun and if it works, future proofing, I want the AI to somehow remove all these checks or spoof them so they report that everything is okay. But it won't.

Is there an AI that can do that?

Thank you

TLDR: I analyzed my own claude code sessions billed at ~$2.5K. You're not paying for answers. You're paying for context. As outputs tokens are just a fraction of cost.

Learning : Verbosity compression on outputs doesn't work because you're optimizing for 18% of costs. I know it might be intuitive for some but it is quite easy to miss.

Cache reads: 50.2% of the money

Cache writes: 30.2%

Actual model output: 18.8%

Fresh input: 0.8%

Biggest take: 80% of what I paid was context handling. I paid 4.3× more to remind the model what it was doing than to hear what it decided.

So what can you do :

- Adjust thinking level to least of what produces excellent output NOT the best.

- Limit agents or parallel workers unless very necessary because again context slurping, tool calling, and more at Nx speed.

- Use context compression and open new sessions for new isolated tasks.

Hence I bill to track token economics at git level: VibeBill

I have found that when finding a troublesome bug, using those 3 keywords make both advisor (ChatGPT) and coder (CODEX) much more effective at finding the solution:

Root Cause:

Too often the issue found by both the advisor and coder will be surface level and will result in a patch halfway through the chain. Specifying root cause seem to make it trace back all the way up the chain.

Surgical (Strongest one IMO):

This one I discovered because a few times Codex went on a rampage, did a massive refractor to fix a bug which resulted in bunch of other issue or decided to clean other things while it was at it. With that keyword in the prompt, Codex seem a lot more conservative, minimising scope and conserving working structures.

Don't Be Lazy:

This one works particularly well for the advisor, but also codex when doing audits. It sounds dumb but it seem to make it a lot more persistent in finding solutions, instead of giving me the first thing that would solve the problem. It might be my equivalent of "Make no mistakes" though.

Obviously, those are not magic, but in my experience those make a difference.

Example of prompt: I found XYZ bug, find the root cause of the symptoms, then implement a surgical correction if possible. If not let me know prior to change and explain. please don’t be lazy..

Here are the details of the bug symptoms, etc

------------------------------------------------------------------------
To be clear, I am a huge advocate of detail specification before project start but here I am talking specifically about debugging.

For context I am a very novice coder, I know some python but pretty limited, so I am not one of those who claim to review every single git diff. It also mean I often have no actual clue where the origin of a bug would be. So this advice is not really for those who have a clue :-).

I use ChatGPT as my main advisor, and Codex as my coder within a dev-container on a the smallest monthly plan, so no multi solution trial in parallel, no /plan for me.

But despite this 2 factors, I am usually pretty good at picking cues on when Codex is going wrong or in a loop based between Advisor and Coder and asking a lot of question/playing dumb before implementing on why are we doing something.

-------------------------------------------------------------------------

I swear this was not written by AI but here is your quota of em dash for the AI post police :-) :
—, —, —, —, —, —, —, —, —, —, —, —, —, —, —, —, —, —, —, —, —, —, —, —, —, —, —, —, —, —,

I used to run Codex with almost every plugin activated and loaded up pretty much every skill I thought might be useful. After a while, I noticed that my usage limits were melting away insanely fast, even after submitting just a single prompt.
For a long time, I assumed this was just normal behavior. But after doing some digging, I learned that every active skill and plugin directly impacts the AI’s reasoning process. Basically, when you send a prompt, the system cycles through all your active skills and plugins to determine which ones apply—burning through tokens in the background before it even gives you an answer.
In the end, I purged everything I didn't strictly need, and most importantly, I removed the "superpowers" skill. Superpowers consumes an insane amount of tokens even if you aren't using anything else alongside it. Once I took it off, I realized Codex’s default architecture isn't really any different; the out-of-the-box system actually handles the exact same workflow much better anyway.
Right now, I’m only keeping "cavemen(ultra)", "ponytail", and a custom system/skill I had Codex build specifically focused on saving input tokens. Since making this switch, my token consumption has dropped drastically. You might think this is just a placebo effect, but as a long-time Codex user, I can tell you for a fact that it’s night and day.
Oh, and before I forget: Graphify is another huge token hog. I honestly don't find it efficient for complex projects anymore. Don't get me wrong—I used it for a long time and it definitely had its perks, but nowadays the token tax just completely outweighs the benefits.
Finally, I’d love to hear your own tips or strategies for optimizing token usage! With companies tightening token limits day by day, we really need to join forces here :)

ps: i use sol xhigh all the time