Feature Request: Restore Codex Task Completion Protection — Protecting Developer Productivity, Engineering Continuity and User Experience

I would like to share my experience as a sole founder building software products using ChatGPT, Codex and Visual Studio Code, and propose an improvement that I believe could make a significant difference to independent developers and founders.

When OpenAI first introduced Codex into my development workflow, one of the things I particularly valued was that, after receiving a usage-limit warning, Codex could continue working towards completing the task it had already started.

More recently, my experience has been different. Codex can stop in the middle of an engineering assignment when its usage allowance runs out.

I understand that computational resources are expensive and that usage limits are necessary. I am not asking OpenAI to provide unlimited Codex usage.

What I am asking is for OpenAI to protect the completion and continuity of work that has already been started.

How I use ChatGPT and Codex as a sole founder

I am building products without the luxury of having separate, fully staffed product, design, engineering, research and quality-assurance departments.

Instead, I use AI to help me perform those responsibilities.

ChatGPT acts as my product strategist, product designer, researcher, technical adviser and independent reviewer. Together, we deliberate, research, design capabilities, examine user journeys, identify blind spots and determine what should be built.

Codex acts as my engineer. It implements the agreed designs, examines the existing source code, runs tests, identifies and fixes bugs, checks for regressions, captures screenshots and produces detailed reports and downloadable evidence packages on my local computer.

I then act as the Founder and final reviewer.

I manually test the functionality, examine the interface, compare the implementation against the approved visual references and experience the product from the perspective of the people who will eventually use it.

I decide whether the work should be accepted, refined or rejected.

I also work directly in the Visual Studio Code terminal with instructions from ChatGPT, particularly when Codex is unavailable or when a smaller, controlled correction is required.

These are not isolated activities. They are interconnected responsibilities within one development operation.

The evidence produced by one department enables the next department to do its job.

What happens when Codex stops halfway through its work?

When Codex reaches its usage limit before finishing an assignment, I may not receive the screenshots, implementation reports, test results or downloadable evidence packages that I would ordinarily receive at the end of the task.

Without those screenshots, I cannot properly compare the implemented interface against what was originally designed.

Without the completed report, I cannot establish whether everything was implemented, whether something was missed, whether a regression was introduced or whether the necessary tests were completed.

Without that evidence, ChatGPT cannot necessarily provide a reliable independent assessment or determine the correct next action.

This becomes particularly important when I want to continue working directly in the Visual Studio Code terminal while waiting for my Codex allowance to reset.

ChatGPT may not have access to the latest uncommitted source changes, the isolated development environment, the screenshots or the exact implementation state at which Codex stopped.

Consequently, instead of moving forward, we may have to spend considerable time investigating the source code, examining terminal outputs, reconstructing the assignment and determining what Codex did before it stopped.

Sometimes, this investigation consumes additional AI usage simply to recover work that was already underway.

As someone who is responsible for the entire product, I find this particularly frustrating because the responsibility for restoring continuity falls back on me.

User experience is more than passing engineering tests

For me, building a successful software product is not simply about writing code or getting automated tests to pass.

It is about how the product feels, how people interact with it, whether it solves their problems, whether its functionality is intuitive and whether the experience encourages them to return.

A feature can pass its engineering tests and still fail to deliver the intended user experience.

This is why screenshots, visual comparisons, browser testing and detailed implementation evidence are essential to my workflow.

I need to be able to compare what was designed with what was actually built. I need to examine whether previously approved functionality has been preserved and whether the new implementation has introduced unexpected problems elsewhere.

When Codex stops before producing this evidence, the quality of the product can suffer.

The next assistant may understand the technical problem but miss the original design intention. Previously approved refinements may be overlooked. A correction may unintentionally introduce a regression.

Over time, the product can drift away from the carefully considered experience that the Founder originally intended.

This is not because the Founder has changed the vision. It can happen because the continuity between design, implementation, review and testing has been interrupted.

Why the previous behaviour was so valuable

When Codex could finish an existing assignment after a usage-limit warning, I could receive the completed work, reports, screenshots, test evidence and recommendations.

Even though I might have to wait several hours before starting another Codex task, I could still use that time productively.

I could continue working with ChatGPT, independently review the implementation, manually test the product, research improvements, refine the user experience and prepare the next development sprint.

I could also carry out smaller corrections directly in my Visual Studio Code terminal, using the completed engineering report as a reliable reference.

The work did not have to stop simply because one part of my AI team had temporarily reached its usage allowance.

That was an exceptionally useful way of working, particularly for someone building businesses independently.

The financial reality of independent founders

Not everyone developing ambitious software products has investors, substantial funding, an established engineering team or a business that is already generating revenue.

Some of us are building our products from scratch, investing our own money, time, energy and creativity long before we receive any financial return.

Purchasing additional Codex credits or upgrading to a more expensive subscription may provide a larger allowance, but it does not necessarily guarantee that a complex engineering assignment will reach completion before another limit is encountered.

The underlying problem therefore remains.

I believe one of the greatest opportunities AI offers is the ability for ordinary people with ambitious ideas to build businesses that previously would have required substantial capital and large professional teams.

That opportunity becomes harder to sustain when independent founders must repeatedly increase their spending or devote significant time to recovering interrupted work.

AI should help reduce the financial and operational barriers to innovation, not unintentionally introduce new ones.

My proposal: Codex Task Completion Protection

I would encourage OpenAI to consider the following improvements.

1. Allow an already-running task to reach completion

When a user reaches their usage limit during an active engineering assignment, provide a reasonable, controlled completion allowance.

This would apply to the existing authorised assignment only. New assignments could remain unavailable until the normal usage allowance resets.

2. Treat verification and evidence as part of task completion

Completion should not simply mean that Codex has finished modifying the source code.

It should also include the testing, regression checks, screenshots, visual comparisons, implementation reports, downloadable evidence packages and recommendations required by the original assignment.

These deliverables are essential to the people and AI assistants responsible for the next stage of work.

3. Provide an intelligent warning before starting substantial work

If Codex estimates that the remaining usage allowance may be insufficient for a proposed assignment, it should inform the user before beginning.

This could help developers make informed decisions about the scope of work and reduce the likelihood of interrupting critical implementation.

4. Guarantee a meaningful engineering handoff when completion is impossible

I recognise that some assignments may be unusually large, encounter unexpected technical problems or exceed a reasonable completion allowance.

In those circumstances, Codex should automatically produce an editable and downloadable recovery package containing:

  • The original assignment and approved requirements.
  • The files examined, created or modified.
  • What was implemented and what remains outstanding.
  • Tests passed, failed and not yet performed.
  • Available screenshots and browser-testing evidence.
  • Known defects, regressions and unresolved problems.
  • The exact repository, branch and implementation checkpoint.
  • Relevant terminal commands and their results.
  • Safe recovery or rollback options.
  • The exact recommended next action.

This should be saved locally where appropriate, so the Founder can provide it to ChatGPT, another authorised assistant or a human engineer.

The user should not have to reconstruct the assignment or search through extensive terminal logs merely to determine where work stopped.

5. Protect users from unexpected expenditure

This mechanism should not automatically purchase additional credits or incur charges without the user’s consent.

OpenAI could introduce reasonable fair-use protections or make this available initially to paying subscribers and users engaged in sustained software development.

The intention is not to remove usage limits but to make them less disruptive to professional work.

Clarification of the current behaviour

OpenAI’s Help Center describes circumstances in which an active Codex turn may continue after a usage limit is reached, subject to fair-use limits.

However, my recent experience has been that active engineering assignments can stop before completion.

I would appreciate clarification about whether the continuation behaviour has changed, whether different restrictions now apply or whether there is a technical issue affecting this experience.

There is also an important distinction between completing an AI model’s turn and completing the engineering assignment that the user actually authorised.

For developers and founders, it is the completion of the meaningful assignment that matters.

Why this matters beyond usage limits

I have previously raised a related feature request concerning automatic conversation handoffs in ChatGPT when long-running conversations reach their maximum length.

Both issues expose a wider challenge in AI-assisted professional work: continuity.

When ChatGPT loses the history of why a product was designed in a particular way, and Codex stops before documenting how that design was implemented, the Founder becomes responsible for reconnecting everything.

The very technology we adopted to accelerate our work can unintentionally create another administrative burden.

I want to spend my time creating, innovating, solving problems, improving the experience of my future customers and bringing my products to market.

I do not want to spend increasing amounts of time reconstructing conversations, investigating unfinished AI work, repeating established decisions or correcting regressions caused by incomplete handoffs.

These interruptions affect more than productivity. They affect creative momentum, financial planning, confidence, motivation and, ultimately, the ability of independent founders to bring their ideas to life.

I believe OpenAI has an opportunity to make ChatGPT and Codex not only powerful individual tools, but dependable professional working partners that support continuity across the entire development process.

AI should not be measured only by how much work it can start, but by how reliably it helps people finish what they have started.

I would welcome OpenAI’s product and engineering teams considering this proposal, as well as hearing from other developers and independent founders who may be experiencing similar challenges.

Thank you for reading.

I think you could have made that post a lot shorter. :slight_smile:

But in any case, I think I can solve your problem today. (If I understood it correctly - if not you gave me a great feature idea anyway)

Use Codexometer with /goal.

You set your goal as usual, but Codexometer now also lets you configure a trigger to automatically resume /goal once your quota has been exhausted and subsequently resets.

As for your other requirements, you can specify which artefacts should be maintained as part of the goal.

Happy days!

(Codexometer is open source and free)

(NB Codexometer could already do this with an abritrary prompt, I just extended it to resume goals, so a fairly quick win)

Thank you for taking the time to read my post, and particularly for extending Codexometer to address the issue. I genuinely appreciate that.

And yes, I probably could have made the post shorter! :blush: Blame the frustration — I ended up pouring my heart out because I didn’t want to leave anything unsaid!

Automatic resumption after the quota resets is certainly useful, and I would be interested in exploring it.

However, the main issue I am trying to address is what happens during those hours while waiting for the quota to reset.

Previously, when Codex could finish an active assignment, I received the screenshots, test results, engineering reports and downloadable evidence needed to continue working independently with ChatGPT and the VS Code terminal.

As a sole founder, that allowed me to remain productive even when I couldn’t start another Codex task.

Automatically resuming unfinished work addresses the recovery problem, but allowing the existing assignment to finish addresses the wider productivity and continuity problem.

Nevertheless, your solution is a valuable contribution, and I appreciate that my post inspired you to extend your tool.

Does Codexometer work directly with the Codex extension in Visual Studio Code on macOS? And can it preserve and produce a meaningful engineering handoff before the quota is exhausted?

I’d be interested in understanding how it could support my existing development workflow.

Thanks again for sharing your work and for taking the initiative to address the problem.

Yes, I understand the broader frustration.

Codexometer can communicate with available Codex sessions running on the machine, but it is at its best when used with a dedicated Codex app-server.

It deliberately doesn’t try to reimplement everything the app-server already does. Instead, it complements it: much of the actual “business” of Codex remains handled by Codex itself, while Codexometer provides an intelligent wrapper, monitoring layer, and alternative interface.

My suggestion was to use /goal and make maintaining the artefacts you care about part of the goal itself — for example roadmap.md, GitHub issues, current screenshots, documentation, or whatever else the project requires.

Codexometer exposes and builds on the existing /goal functionality rather than replacing how it works. The main addition I was referring to is the new trigger mechanism, which can automatically resume the goal after a quota reset.

Hope that makes sense.

Yes, I understand what you mean, and I appreciate the explanation. However, that alone doesn’t solve the problem of not knowing whether your remaining Codex allowance will be sufficient to complete the task it is about to undertake.

The system is already capable of telling users exactly when their usage allowance will reset. Why couldn’t it also estimate whether the remaining allowance is likely to be sufficient to complete a proposed assignment and warn the user before starting?

At present, when your allowance resets, you purchase additional credits or upgrade your subscription, you still don’t necessarily know how much meaningful engineering work that allowance will enable you to complete.

Why not give developers and users an informed choice before proceeding, in much the same way that Codex already asks about permission levels and whether certain work should be carried out locally or in the cloud?

The user could then decide whether to proceed, reduce the scope of the assignment, postpone it or transfer the work to another environment where they have greater control, such as their local terminal, another authorised development tool or even a human engineer.

This would save considerable time and help maintain momentum.

I believe OpenAI’s models are sufficiently capable of assessing the anticipated complexity of an assignment and providing a meaningful warning, even if that assessment cannot be completely precise.

More importantly, allowing the work already underway to reach completion and produce the necessary screenshots, reports, test results and supporting evidence would enable users to continue working elsewhere without guessing, starting over or spending hours recovering and reconstructing unfinished work.

For sole founders like myself, who cannot necessarily afford an entire professional team that would cost an arm and a leg before we have even acquired our first paying customer, AI provides an incredible opportunity to bring our ideas to life.

It allows us to build, refine, test and eventually launch products that could solve meaningful problems for our intended users.

When I first started using Codex, OpenAI allowed active assignments to continue towards completion after a usage-limit warning. That experience was incredibly valuable, and I would love to see that capability restored or strengthened.

In my case, I have established different working teams within ChatGPT for each project, operating much like departments in a conventional human-run organisation.

I have product strategy, design, research, engineering and independent review responsibilities distributed across my AI working environment, while I remain the Founder and the person responsible for manually testing the functionality, interface and overall user experience.

Each department depends on the evidence and output produced by another.

When a critical piece of evidence is missing, extensive investigations begin. Instead of progressing with the product, I find myself trying to reconnect the departments, recover implementation details and establish what was actually completed.

And that is usually when my creative battery starts to check out! :blush:

Ideas, creativity, design intentions and momentum should not get lost in transit between different AI systems or working departments.

Hopefully, this explains why having an agent automatically resume Codex’s work after the usage allowance resets, although valuable, does not fully address the problem I raised — at least not in the way I use ChatGPT, Codex and Visual Studio Code to build my products.

My concern is not simply whether the interrupted work will eventually resume. It is whether I can remain productive in the meantime, with sufficient evidence and confidence to continue moving my projects forward.

Nevertheless, I appreciate what you are building with Codexometer and your willingness to explore solutions to these challenges. I believe both approaches could complement each other.

Hi @HumanFirstAI, welcome to the community!

I appreciate you sharing this detailed feedback and highlighting how Codex usage limits can disrupt ongoing development tasks and workflow continuity.

I'll pass along your suggestions for task completion protection, proactive usage warnings, and structured recovery handoffs internally for consideration. While specific implementation timelines and ongoing status updates remain subject to product planning, your feedback is valuable in helping improve the Codex experience.

- Saif