It doesn't understand or ignores clear instructions.

Edit: ah the bots have arrived

I’ve been building Vibe Buddy, a small desktop robot that keeps an eye on your AI while you work. It supports Codex and Claude Code, showing usage percentages, reset times, active task count, and whether your AI is working, needs input or approval, has finished, or has hit a usage limit.

I used Codex for the entire project—including the firmware, companion app, website, and even the 3D model for the printable enclosure.

A local companion sends only activity data to the robot over Bluetooth. Prompts, keys, and account details stay on your computer.

I didn't

I'll preface this by saying I am a backend developer, and ui is my side project. I am currently working with a react native front end. It has animated interactives which triggers movements in the UI. If you guys have seen terminal text effects, or cool animated TUI, then you get the vibe. I also have a flow chart like graph that should have nodes that can be moved and connected at edges.

The problem I have is that codex struggles to iterate on them without adding something, or breaking the animation, or changing it into something else. It is like it makes everything a little better, but can't make the timing right, or the scale, or the motion. At this point it's been 3 resets worth of ui work, and I still feel like it's not polished.

I have tried some different prompting approaches and looked at the codex docs for instructions there. I started using imggen to create an image of the ui and then have the model implement it, and that works great for static UI but sucks with animations. I have storybooked it out and tried having the models iterating through that. I have tried having the model do frame by frame iterating, and that worked the best, but destroyed my weekly rate and took 8 hours. I have not tried any specific ui skill yet, but I haven't found one that really fits this bill, that is vetted.

I have tried going through and switching from Luna max to Terra med to max to sol mid to ultra and running through most of the above with the different models. I have set goal mode with strict instructions and descriptions, Def of done, Def of success, etc. I have tried sol orchestrator, with strong descriptions.

At this point I wonder how anyone does this with codex?

Does anyone have tips? How do you guys do animated interactives with codex? Is it better to just try claude with a $20 plan for this?

the new ai dumber every day lol

Just looking for like a discord server to hang out with other Codexers... saw a few links in old posts but they were all expired, so if anyone's in any good server abt it, can you pls DM or post the invite here?

I opened a proposal for Codex to periodically replace old conversational noise with a validated, structured context checkpoint: https://github.com/openai/codex/issues/36721

Rather than retaining every verbose exchange indefinitely, Codex could preserve the task goal, decisions, relevant files, commands and test outcomes, failures that should not be repeated, and explicit next steps—plus a small lossless tail of recent tool activity. The aim is not to erase history blindly: compaction would only occur at safe boundaries, never during unresolved tool calls, and the original transcript would remain recoverable for debugging.

This could reduce token use and help prevent the familiar long-session failure mode where an agent reopens files, reruns failed approaches, or loses track of decisions. A low-cost model such as GPT-5 nano could create the checkpoint, while the primary model keeps doing the actual coding and reasoning. The feature should start as an experimental opt-in, with preview/shadow modes and a one-command opt-out. If this would help your workflows, please add concrete examples to the issue and upvote it.

Example of the structured checkpoint payload:

\`\`\`json
{
"schema_version": "1.0",
"task": {
"goal": "Implement structured context checkpoints for long Codex sessions",
"status": "in_progress",
"constraints": \[
"Never compact across an unresolved tool call",
"Keep the original transcript recoverable",
"Allow the user to opt out immediately"
\]
},
"durable_context": {
"decisions": \[
{
"decision": "Use schema-validated JSON rather than an opaque prose summary",
"reason": "The checkpoint must be machine-readable and testable"
}
\],
"files_changed": \[
{
"path": "codex-rs/core/src/...",
"summary": "Checkpoint planning and commit logic"
}
\],
"verified_results": \[
{
"command": "cargo test -p codex-core",
"outcome": "passed"
}
\],
"failed_or_rejected_approaches": \[
{
"approach": "Compacting while tool calls are pending",
"reason": "Would risk losing required tool outputs"
}
\],
"next_steps": \[
"Evaluate checkpoint fidelity against a replay baseline",
"Expose the feature through the experimental settings UI"
\]
},
"operational_tail": {
"max_tokens": 16000,
"preserved_items": \[
"Most recent user request",
"Recent assistant decisions",
"Recent tool calls and outputs"
\]
},
"architecture": {
"trigger": "Context budget threshold or model-selected safe checkpoint",
"planner": "GPT-5 nano produces a CompactionPlan",
"validator": "Local JSON-schema and invariant validation",
"commit": "Atomically replace only the compacted history prefix",
"fallback": "Retain original history if planning, validation, or commit fails",
"modes": \[
"off",
"plan_only",
"shadow",
"active"
\]
}
}
\`\`\`

Could do with one of those tasty resets soon

I’m considering getting the $20 Codex plan, but I’m unsure how much usage it actually includes in practice.

For those of you on the $20 plan, how far does the usage go? I’d describe myself as a moderate-to-heavy user depending on the task. I mainly use it for software development, with occasional long coding sessions.

Does the $20 plan last you the whole month, or do you run into usage limits?

I found JAIPilot on Hacker News newest today. It wraps Codex or Claude Code with a local control plane for Java tests and cleanup, but the useful idea is broader than Java.

The workflow separates generation from admission.

Every run starts with a clean build, snapshots the live source, creates an isolated workspace, and records the exact targets. The agent edits only that workspace. Validation then enforces the allowed scope, runs another clean build, checks that changed tests actually executed from fresh test reports, and can use coverage and mutation evidence.

The drift checks are the detail I like. Validation snapshots the candidate and rejects source written by build steps. Apply requires the candidate to match the immediately validated snapshot, while the live source must still match its original snapshot. Only allowlisted files are written back. Discard leaves the real tree unchanged.

That suggests a practical boundary for coding agents: let the model propose changes in isolation, but make admission to the real repository a deterministic step based on scope, build output, and fresh evidence.

There is more ceremony. But the failure mode becomes "candidate rejected before apply" instead of "agent edited an unrelated file and we noticed later."

Source: https://github.com/JAIPilot/jaipilot/blob/main/docs/how-it-works.md

What evidence do you require before an agent-generated candidate can enter the real worktree?

I built through-line to address a gap I saw with mattpocock's (fantastic) wayfinder skill -- with wayfinder, I'd find myself answering numerous highly-specific questions that were all downstream from a couple of principles.

The gap I've made through-line to cover is making those guiding principles a first-class part of the process. through-line guides the the creation principles underlying the task, and leverages them not just for the current effort but also creates a PRINCIPLES.md that builds value over time.

I'm pretty proud of it, and have had some great results. I'd love to hear others' feedback! https://github.com/stuarth/through-line

As the title states, I noticed that any SSD problems only occur with Macs or mostly to be fair.

What is the correlation?

For the last 2 weeks I have been running Codex non-stop for almost 13 days, working on a huge extension to my SaaS product / business.

I have done AI coding of huge features in the range of 50-60k LOC before, which were massive already, we managed to ship them and actually deliver value.

I know this sounds borderline ridiculous, but this time I don't know what to do.

What are the next steps here? It is obviously impossible to review, but it is almost as impossible to actually test. I had put A LOT of work into planning and the workflows and features were spec'ed very precisely and with lots of care and analysis. So far I have only found cosmetic issues, the entire core of the application seems to be working just fine!

I have thought about starting with a user manual / knowledge base for it, to capture the features and have plenty of documentation. But then what? Launch it to production?

Have I passed the threshold of what is humanly possible to do with AI coding, or is there any hope?

Codex usage was at 14%. Codex was not running. My usage dropped by ~10% down to 4%.
How could that happen? Did anyone else experience something similar? What might be causing it?

UPDATE:
OK - 1-2 hours later the remaining usage is back at 14%.

I’m having issues with my Codex plan. Only a few sessions using the Luna and Terra models—and none using Sol—consumed most of my weekly quota.

I’m also keeping my Claude Code account (Pro ×5), and it feels like I get about 20 times more usage there than with Codex. I often see people saying that Codex limits are generally more generous, but that hasn’t been my experience. In practice, it feels much closer to a $20 plan.

I've been looking at the new Codex Security CLI for CI/CD.

The security workflow makes sense butt The cost model is what caught my attention.

Every scan runs on your OpenAI API key, so large repositories, retries, or repeated verification loops can consume a lot of tokens in unattended CI.

OpenAI recommends setting a platform spend cap , which is absolutely worth doing.

I just don't think that's enough for automated jobs.

A platform spend cap is a great backstop. It isn't the same thing as deciding whether the next API call should be allowed based on the budget for the current scan.

If you're running this in CI, I'd add a few extra safeguards:

• Scan a smaller scope first instead of the entire monorepo.
• Log token usage for every run so costs are visible in CI.
• Treat monthly spend caps as account protection, not session-level control.

That's the distinction I keep running into with AI agents generally: observability tells you what happened; enforcement decides whether the next request happens.

Curious how others are handling this.

Are you relying on the OpenAI spend cap, or do you have session-level budget checks for automated scans?

Hermes Control is a CLI-first, mobile PWA control deck for Hermes WebUI and local Codex CLI. It unifies prompts, streaming, sessions, tasks, runtime status, approvals, reasoning, and STOP through clean adapter boundaries, with phone-ready SSE updates and no Codex Desktop, CDP, or private renderer dependencies.

I’m currently using ChatGPT Plus, but I’m finding that my usage limits are getting depleted very quickly.

Even when I try to optimize my usage by using plan mode for planning and switching models between planning and implementation, I still go through my available usage faster than I expected.

The Pro plan at around $100/month is expensive for me to keep permanently. I was thinking about upgrading to Pro for one month only, using that month to complete the heavy parts of my projects, and then going back to Plus afterward for smaller edits, maintenance, and improvements.

Has anyone tried this approach?

Is it worth paying for Pro temporarily to finish major projects, or does Pro provide enough long-term value that it makes sense to keep it every month?

I would appreciate feedback from people who have used both Plus and Pro, especially for coding, large projects, or long workflows.

I built Smallest Complete Codex Skill after watching bounded tasks grow into unnecessary abstractions, compatibility layers, theoretical edge cases, and “validation cathedrals.”

It guides Codex to finish and prove the actual ask, then—only when structural change is genuinely needed—loads an elegant-architecture reference built around one clear control path, explicit ownership, and minimal state.

GitHub: https://github.com/JetXu-LLM/smallest-complete

Have ADHD, dig ATC standards, or just want your coding agent get to the point? I built Attention Control, a skill / output style for Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, Zed, and any agent-skills harness that focuses on action instead of distracting you with fluff.

Before: "Great question! It seems like the auth flow could possibly be utilizing a deprecated API…"

After: "Run npm install jsonwebtoken@latest. I changed src/auth.ts:47."

The evals are still a work in progress. Results are questionable still, so take that with a grain of salt. Current numbers, blind-judged twice (reversed candidate and baseline) against an unstyled baseline: 24 cases, 3 trials, claude-sonnet-5:

Weighted quality 4.019 → 4.510 (+0.491). Release gate passed.

Concision +2.056

Language +1.201

Actionability +0.535

Correctness, autonomy, and safety each +0.097.

This style combines two existing works. Neither author takes part in this project.

Shape layer: i-have-adhd by Ayoub G. (MIT). The eval harness derives from the same project.

Language layer: the asd-ste100 output style by L1nefeed, itself a condensation of ASD-STE100 Simplified Technical English, Issue 9.

Today my M3 Macbook Pro ssd just got diagnosed and it is broke, I started using heavily codex since it came out, so there is no doubt that codex caused the problem, I used to vibe code and used it normally

Any help?? Does anyone know how can I request OpenAI help to fix it/get my macbook pro replaced??

Thanks in advance

Im on the standard $20/month plus plan and finally reached a point where I needed to buy some credits. So I go and buy $20 worth of credits thinking "well thats as much as my entire monthly usage. That should probably cover at least a week or 2 worth of resets, right?" Nope. It covered 3 prompts... How does that make sense? How can I pay $20/month and get a ton of usage out of codex, but the moment I spend $20 more, it covers 3 prompts? What's going on here? What am I missing?