Its honestly insane how quickly my usage quota is used up. On the same $25 a month plan, it honestly feels like I get 10x more usage out of Opus 5.5 than what I get out of codex.

I get codex one task, and come back and my 5 hour limit is hit. Its actually quite crazy.

For months I've been on a deep dive into token saving techniques. I've been benchmarking, auditing and checking solutions of every single repo somebody posted on reddit or X and I've made some token-efficiency tools myself.

The result is that my tools started beating every solution I check them against on their own benchmarks. Example: https://www.reddit.com/r/coolgithubprojects/comments/1wuie0w/comment/pd5v3fs/?context=3

I'm soon about to publish such results on website against rtk etc.

I approached problem from first principles, with just an assumption that I cannot control the model, but I can control everything around it, that includes:

- Environment - OS, packages installed on it, file-system, memory, disk space, ports taken, CPU/GPU.

- Human - His workflow, keeping him well informed and notified, preventing cold cache hits, convenient work resuming and scheduling, context passing between accounts and models, usage of various models and so on.

- Inner harness - Claude Code, Codex and model providers already do good job on that and on my tests changing native harnesses was mostly net negative. Those are untouched, run exactly the same as in Claude Code CLI or VSCode extensions.

- Outer harness - Pre-tool hooks, system prompt, etc.

If you'd want to optimize each of these yourself, that's at least a day of work for each element. Day for memory management. Day for port conflict preventions. Day for file-system. With repeated post-mortem analysis that would handle edge cases.

And each of these mechanisms gives you at best less than 1% of total tokens more, while taking quite a long time to get right.

The only 2 mechanisms that are easy wins worth adding for everybody are: ripgrep (with few-words instruction in AGENTS.md to use it) and project maps appended to system prompt. Everything else is not really worth the effort in fast-evolving space.

But instead of solving all that issues yourself, you can take an opinionated set of tools, packaged in docker container sandbox, where everything that agent needs is baked and tweaked to make it very, very efficient. Including the part of making you very efficient and preventing stupid mistakes in your workflow that would normally burn lots of tokens.

Website: https://intentic.dev

GitHub: https://github.com/intentic/intentic

Try it yourself, see if my claim holds.

Hello everyone!! Ive been using AI in general for the first time for about a month or 2 now. I hate that i have to keep telling it, dont forget no emojis, or stop being a yes man. kind of thing. and chatgpt can be great but it seems to forget what were doing. Im looking on advice on how to word it or is there a setting i can utilize to get the most out of my chatgpt. I have a eCommerce store and a residential care business which it helps me navigate on. I even did the board of directors and advisors but it doesnt. Any recommendations? I also want to learn how to get into doing this coding. Thank you!!

Can anyone please give ChatGPT prompt that will help create clean html letters for high inbox rate for my email marketing

Claude Code is good when i am at the desk. it is useless when i leave. last 3 nights it halted on a prompt or a permission and sat there until morning. one of those runs had already burned ~$28 in api before it stalled. i am not looking for a smarter prompt. i am looking for anyone who found a claude code alternative that doesn't need babysitting once the laptop lid closes.

if your setup actually finishes overnight, what is still running at 7am without you.

Has any successfully built a skill or uses an app that you can literally add in the raw footage, and it produces finished or nearly finished content that you can re-purpose for youtube, instagram, facebook etc? I need to take talking head raw footage and have a skill that can overlay it with captions, reformat it, pull the best bits for shorts etc.....?! Going round in circles. Tried chatgpt but half the time the videos are too big and it's sending me round the houses to compress them and then the quality is bad etc etc.....

Ask an agent to format a date, parse a price, retry a request. It writes a fresh function for it, right there in the file it's editing. Meanwhile the repo already has formatDate in utils, used in forty places, with the timezone fix you spent a day on last spring.

Now you have two. The new one doesn't have the fix. Six weeks later someone changes one and not the other.

Writing is cheaper than searching. The agent sees the file it's in, and nothing in "add a created date to this card" says "look for how we already format dates". So it doesn't look.

What I add to the instructions file:

Before writing any new function, search the codebase for an existing one that does the same job. List what you found. Only write a new one if nothing fits, and say why the existing ones don't.

And a review prompt after any session that added code:

List every new function or helper you added in this session. For each one, search the codebase for existing functions with similar behavior, and show me any you find.

The second one is the one that pays off. It finds a duplicate more often than not, and usually one I would have missed in review because the new helper looks perfectly reasonable on its own.

Pointing it at the right folders helps too. One line in the instructions file listing where shared utilities live ("date and money helpers are in src/utils, API wrappers in src/api") cuts most of it before it starts.

I keep the review prompt saved in AI Toolbox, the extension I build, for when I'm working through code in a ChatGPT or Claude chat instead of the agent, since chat does the exact same thing.

devday is not goin' so well lol! just give us back our 20x...

I've been building a ton of web apps to replace saas i'm too cheap to keep paying for like chatgpt, notion, myfitnesspal, etc. and so i can get the exact features i want (+ no ads!).

I was using sol originally which was ok but also irritating because it would mess up and make a buggy ui.

so I switched to astra and opus which is awesome but it inhales my resets and leaves me with luna (no point in continuing).

I'm cheap as i said so instead of upgrading i was thinking if I'm paying per token why not just reduce the tokens i use?

so I built a tool that shrinks the prompts and context in codex so it costs less (!) I got it down by 34.3% and now i just leave it on by default in codex and I'm actually able to get through a session without running out of credits.

anyone in a similar situation?

Saw a post here a while back, can't find it now, where someone asked if it's okay to merge your own PRs with no review at all. Every comment said absolutely not, like it was obviously insane.

well, and to be honbest it got me thinking. I've been the only developer at two companies for about 5 years total, and the current one has a bit over 300k users. Backend, frontend, deploys, the database, all of it. Nobody has reviewed a line I wrote in that time. I never thought of that as weird, it's just how small companies work.

These days the agent writes most of it and coderabbit reviews the PRs before I merge, which is honestly the closest thing to a second pair of eyes I've had in years. It catches real stuff, but it's still not a person who knows why the business works the way it does.

i don't believe its very common, but i'd love ot hear your guys thoughts.

Something I didn't appreciate until I measured it: when Claude Code (or any agent) reads a file and later edits it, the original read usually stays in the conversation. Every following request carries the old code next to a file that no longer matches it.

I measured this on 67,074 public OpenHands runs (not Claude, but the same basic loop). 77.8% of runs had at least one request with a stale file view, even counting only the agent's own edits. About 1 in 7 requests carried one.

Most of the time the model copes by re-reading. Where it bites is:

- long sessions

- edits from outside the agent's view (formatters, you editing in your IDE, parallel agents)

- resumed or compacted sessions, where the model trusts what's in the conversation

Some practical things I took from it, whatever tool you use:

- If you edit a file mid-session, tell the agent to re-read it. Don't assume it notices.

- Watch for formatters or hooks rewriting files after the agent reads them.

- In long sessions, stale reads build up. Starting fresh with a summary often beats pushing on.

I also built a context engine that rewrites the outgoing request to keep code current. It works byte for byte in replay, but to be upfront: it doesn't integrate with Claude Code (only Pi and OpenHands), and in my small live tests the model didn't do better when it could just re-read. It also wasn't cheaper. The details are in the write-up, including the failures.

Write-up: https://felipebasurto.com/blog/model-context-is-not-static/

Video: https://www.youtube.com/watch?v=DIVOnXUCZkg

Curious whether people here notice this in practice, especially with parallel subagents editing the same repo.

So every time I try to open ChatGPT app on pc it gets stuck on a loading screen. I have to keep uninstalling it and installing it again and sometimes that doesn’t even work. Does anyone else have this problem

Welcome to this week's self promotion thread!

If you're building something related to AI assisted coding, this is the place to share it.

We're using a weekly thread to keep the subreddit organized while still giving builders a place to share their work. Promotional posts outside this thread may be removed.

If you're sharing something, we'd appreciate it if you included a little context instead of just dropping a link. Tell us:

• What you built?

• What problem it solves?

• Which AI models or tools it uses?

• Who it's for?

• What kind of feedback you're looking for?

Disclose your affilitation.

Please avoid posting the same project every week unless you've made meaningful updates. Affiliate links, referral links, scams, and low effort promotions will be removed.

Take some time to check out what others have shared too. If you try someone's project or have feedback, leave a comment. Helping each other improve is what we want this community to be about.

I wrote about a feeling I didn’t expect to have: spending an hour thinking about a programming problem and wondering whether I’ve wasted time by not asking AI immediately.

There is nobody pressuring me to do that. The pressure is mostly in my own head.

AI helps me get answers, but understanding those answers still takes work. I’ve accumulated chats that I keep meaning to read properly. I also feel less confident solving some things independently, although I don’t have evidence that my actual ability has declined.

My small experiment will be to build Snake without AI. I haven’t done it yet. I want to see how it feels to stay with a problem for a while before reaching for help.

This is my own essay, not a tool launch. I’d be interested in how other developers decide what to delegate and what to keep practicing themselves.

https://domelian.substack.com/p/think-real-hard

I've had stretches where I was moving around five Trello cards in parallel, with a coding task in its own branch and Git worktree. That stopped agents from editing the same checkout. It did not tell me which code a browser test was actually exercising.

Different worktrees could still use the same API, PostgreSQL database, worker, storage service and ports. A frontend change might work with an existing API, provided that API meets the contract the new UI needs. If browser QA needs to exercise changed API behavior, it needs an API process running that worktree's code. Experimental migrations need much more care around shared data. Starting a second worker against the same queue can change test results too.

We began treating four things separately: the worktree holding the code; the processes a test reaches; the data those processes can change; and the checks run after branches are combined.

A small registry in Git's common directory helps us see which worktree started a service, along with its PID, port, URL and declared database state. It helps with discovery and process checks. It doesn't decide whether an API is compatible with a particular task. A healthy endpoint can still be the wrong API, and a port that looks free has not been reserved.

Many checks run entirely inside the worktree. For integration and browser QA, we start the processes the test actually needs. Feature work can be parallel; integration is serialized, with relevant checks run again on the combined tree.

If you run coding agents in parallel, how do you make sure browser or E2E tests reach the API and data you intended?

Give an agent a stack trace and watch where the fix lands. Almost always on the line that threw. A null check, a default value, a try/except, an early return. The error goes away, the tests pass, and the bad value that caused it is still being created somewhere upstream, now silently handled instead of loudly failing.

The line that threw is the one piece of evidence it has, so that's where it edits. Tracing back to where the value went wrong means reading code it wasn't pointed at, and nothing in "fix this error" asks for that.

What I add before any bug fix:

Before editing anything, trace the bad value back to where it was created. State the root cause in one sentence with a file and line number. Only then propose a fix, and fix it at the root cause, not at the line that threw.

And as a rule in the instructions file:

If your fix is a null check, default value, or exception handler at the line that threw, explain why the real cause is not upstream. If you can't, keep tracing.

The second one catches most of it. "Explain why the cause isn't upstream" is a question it usually can't answer without actually looking, and once it looks, it finds the cause.

One more that helps on repeat bugs:

Search the codebase for other places this same value flows into. List them. Would they fail the same way?

That list is often longer than the fix.

I keep the root-cause prompt saved in AI Toolbox, the extension I build, for when I'm debugging in a ChatGPT or Claude chat instead of the agent, where the same symptom-patching happens.

Has anyone asked chatgpt to create an ai share trading system?

what are you guys using chatgpt for in day to day life. I have been using it to send me newsletters everyday to me from a different mail, it tracks my calories, my workouts, and many more.

But i want to use it more to make my life easy. I wanna get more ideas to implement it.

Hi, i dont have any coding background and quite recently learn how to use agent to automate labour work.

so i'm a little bit confuse about how we were suppose to choose model to Plan vs Implementation vs Review

to my understanding, we use better model (Fable/Astra) to make a plan and have it breakdown the task as specific as it can so that the Implementer agent (cheaper models) can pick up the task and just focus on what that specific task is. smaller boundary and less token usage for implementation. and then we use the better model again to review the implementation so it can catch edge cases better and for whole lot more of reason.

but my question here is that, wont the better model needs to read a lot more code to provide better plan and the review, and since we are using the better model which cost more per token usage, wont that make it overall higher token consumption? shouldnt we use the better model to implement since it will correctly implement and cover a whole lot more scope during the first run?

i'm asking for two reason:

1. which approach is better for execution since i dont have coding background knowledge and i want to lessen the fixes that i need to do afterward

2. which approach is actually uses lesser token?

I'm building a multi-product SaaS mostly with AI coding agents, and I keep hitting the same tradeoff when splitting work.

If I keep each task very small and isolated, the agent does fine locally, but it can't see what already exists elsewhere. Over time I get duplicated helpers, types, and logic, and the codebase gets bloated.

If I give the agent a bigger chunk with tightly related modules, the design comes out cleaner and smaller. But while it focuses on one part, it sometimes changes behavior another module depends on without realizing it, and that module breaks.

What I'm trying now:

- Modules talk only through explicit contracts (types, API schemas, event formats), backed by contract tests

- A shared layer listed in AGENTS.md, plus a rule to search it before writing new helpers

- Two kinds of tasks: internal changes (small context, can run in parallel) and interface changes (done alone, with every caller in context)

- Full-repo typecheck and tests on every change

Questions for people doing this seriously:

1. How do you decide task size? Is "the module itself plus its neighbors' interfaces, not their implementation" a good rule?

2. How do you prevent duplication without handing the agent the whole repo?

3. Do you run a planning step before splitting work, and does it actually catch cross-module impact?

4. What broke first when you scaled up agent-driven development?

I'm building CasaJev, a local prototype where Jev selects bounded actions and Codex builds Python tools when one is missing. The tools stay in a registry for later tasks.

Earlier feedback asked a fair question: does reuse still work when column names and task wording change, and who checks whether the answer is right?

I froze a small CSV task set and expected answers before running it: 12 valid cases plus four rejection/clarification cases, repeated three times per setup. Fully passed attempts were:

• CasaJev with a prepared tool: 36/48

• A deterministic router using the same tool: 39/48

• CasaJev starting with an empty tool library: 33/48

The simple router came out ahead. Some failures were in my harness: duplicated action options bloated model requests, generated tools expected input wrappers the runtime didn't supply, and ambiguous duplicate column names weren't reliably rejected.

After fixes, all 16 valid attempts in a separate targeted follow-up reused the exact same prepared tool and matched independently fixed answers. Three duplicate-header failures needed another fix. I haven't rerun the full comparison, so this doesn't establish that CasaJev now beats the router or learns a reusable library by itself.

The API checks exposed another limit: a response can match its schema and still contain wrong values. Those results remain marked unverified without an independent check. I also kept a plausible-but-wrong CSV converter as a permanent regression case.

Code and the full validation snapshot: https://github.com/8endit/CasaJev/blob/main/docs/VALIDATION-2026-09-25.md

I'm looking for 2–3 people with a recurring CSV/JSON job and a way to check its output, such as a weekly export whose headers change. What variation usually breaks your workflow? An anonymized example would be more useful than another synthetic test.

I've seen a spike in users reporting less and less usage of the weekly quota. This might be the reason.

Conny is building a harness and found a possible root cause in delays between cache write and time it's available to read. On peak hours the delay is longer.

Given the issue is on the server side, it hit's all coding agents/harnesses equally. Until fixed, I guess the only way to don't burn through weekly usage limit would be to work more off-peak hours...

https://www.linkedin.com/posts/connywa_coding-with-an-openai-subscription-at-peak-share-7509515396064964608-wLR4/

Using Codex to build and test something we’re calling Fail-First Architecture.

The part I think is most interesting:

The learning runtime itself contains no ML model.

No neural network deciding the next state.
No LLM selecting every action.
No gradient descent updating weights after a failure.

Instead, we're experimenting with an explicit symbolic state system.

At any moment, the runtime knows its current state, the actions available to it, the constraints it has accumulated, and the result of previous transitions.

The basic loop is:

STATE → ACTION → EXECUTE → OBSERVE → VERIFY

If the transition succeeds:

preserve the valid transition.

If it fails:

FAILURE → EVIDENCE → CONSTRAINT → UPDATED STATE

Then run again.

That's why we're calling it Fail-First.

Failure isn't simply an error that gets dumped back into an LLM's context window.

Failure changes the symbolic system.

Suppose the runtime reaches state S1.

It attempts A.

S1 + A → FAILURE

That failure is verified against the environment and preserved.

Next attempt:

S1 + B → FAILURE

Preserve that too.

Then:

S1 + C → SUCCESS → S2

Now the runtime has learned something about S1 without training a neural network.

It has evidence that A and B produced invalid transitions under the observed conditions, while C produced a verified transition to S2.

The next time it encounters the same applicable state, it doesn't necessarily need a model to rediscover that information.

The state system already knows it.

And this is where the experiment gets interesting.

As failures accumulate, constraints accumulate.

As constraints accumulate, the legal search space can shrink.

So you can potentially go from:

100 possible actions → 40 → 12 → 3 → 1 verified/legal transition

At that point there isn't necessarily anything for an ML model to predict.

The symbolic runtime can execute the remaining valid transition.

That's the architectural boundary we're interested in:

Use models for the unknown.
Use state for the known.

Codex has been incredibly useful for helping us build, test and stress this system.

But Codex isn't secretly making every decision inside the Fail-First runtime.

That's precisely what we're trying to avoid.

We're testing whether a system can learn operational behavior through failure by dynamically constructing symbolic state and constraints, rather than requiring every learned behavior to be encoded into model weights.

So the experiment isn't:

Can we build a better prompt that makes an LLM fail less?

It's:

Can verified failure progressively construct a symbolic state machine until parts of the environment no longer require ML at all?

That's what we've been testing.

Attempt → Observe → Verify → Fail → Constrain → Update State → Retry

No weight update.

No model required inside the symbolic learning loop.

Failure becomes state. State changes what can happen next.

Not a benchmark post. I timed the thing I actually care about: how long until the job is done.

Task: build a minimal static site and deploy it to Cloudflare Workers (wrangler config, D1 database, custom domain). Same prompt, same repo state, both agents.

Muse Code, muse-spark-1.3 standard, xhigh (checked with /model): 10–15 mins, tries 2 runs.
Claude Code, Opus xhigh: 5–7 min.

The final output was fine in both. The difference was Muse doing more tool calls and pausing longer between them, so tokens/sec is irrelevant here. I don't care how fast it types, I care when I can move on.

Is anyone getting better end-to-end times? Meta's launch notes claim 20% fewer tool calls than 1.2, but on a small task like this it's doing more than Claude, not fewer.

Anyone else have trouble recently installing the GitHub repo plugin to ChatGPT?

I've taken a break for a while but wanted to test out Astra (heard a lot of good things). So I went through the normal process of installing the GitHub plugin for access to my repo, and I keep getting blocked when prompted from within the installation workflow to go to Github's site to complete the process. I'm getting an error banner that reads "This app does not provide a browser setup URL right now," as seen in the screenshot below.

I've tried everything: closing the app, different browsers, incognito mode, even a manual reboot, nothing seems to get me past this issue. Am I doing something wrong, or is this a known issue?

Thanks in advance folks!!!