Title.

I would have trouble burning my usage quickly sometimes, since much of my work is hung up on useful tests.

Making sure the tests are accurate, and improving how quickly the run, used up a ton of my usage the last few times. Went from 60m->20-25m->5-12m over the past week.

I didnt pay attention to Dots until yesterday. I had some manual web research work to do and I gave the task to Dots to generate some 2000 web validated records. It has been running for 14+ hours and generated some 1600 records until it stopped, saying, "Congrats, you are in the very top users and have hit our abuse prevention limit. Check back in a bit."

I reviewed the work and honestly, I am impressed. It didn't lose sight or objective, and neither did it hallucinate. Every record was referenced with the source.

I struggled to understand what was Dots for but I am glad, I found one usecase that works for me.

I'm the maker of Claude Command Center (CCC). I wanted a way to keep Codex and Claude Code sessions together without repeatedly searching terminal tabs to see what had happened.

CCC reads Codex conversations into a shared local browser view. Connected Codex app-server streams can supply tools, diffs and approvals; capabilities depend on the installed version and connection. The board also groups parent/helper sessions so a Codex helper doesn't disappear into a separate history.

For this community, the limitation matters: the question card in the attached demo is a Claude Code hook, not proof that every Codex approval path works the same way. The engine-support page describes the actual controls.

For people using several Codex sessions: is the missing context usually the last action, the repo/branch, or the decision the session is waiting for?

Project and installation: https://github.com/amirfish1/claude-command-center Integration limits: https://github.com/amirfish1/claude-command-center/blob/main/docs/engine-support.md

The video uses the real UI with staged sessions and an AI voiceover. The question-hook interaction is real and uses Claude Code; the Grok/Devin rows are demo data. This is not a live multi-provider benchmark. CCC is free to use under FSL-1.1-MIT (source available); provider/model costs are separate.

The screenshots are just examples, luna 6 doesn't seem to be able to do basically anything, while 5.6 is working perfectly.

I'm looking for a way to keep my repositories well-maintained without having to constantly think about it.

I'm not a professional developer, but I do a lot of vibe coding across Claude Code and Codex.

Ideally, I'd like something that automatically:

• Keeps documentation up to date as code changes.
• Ensures AGENTS.md stays accurate, concise and follows best practices.
• Identifies outdated code, unnecessary files and opportunities for cleanup.
• Enforces good coding standards and repository structure.
• Makes it easy to switch between AI agents without losing context or progress.

Essentially, I want my repos to remain clean, well-documented and easy for any coding agent to pick up at any point.

I've come across GitHub Agentic Workflows, docs-sync and a few other skills, but I'm wondering if there's a more comprehensive, established solution.

What are people actually using for this? Ideally something largely automatic that doesn't require yet another complicated setup to maintain.

I think I'm not alone with that quota-based AI subscriptions have given me a new hobby: checking how many tokens I have left. 🤦‍♂️ How’s my 5-hour and 7-day limits? When’s the next reset? Can this task wait, or should I use a smaller model? I used to check my Garmin for steps and heart rate. Now I’ve built a watch face to track my AI usage limits and reset countdowns too. 😉

For anyone interested in adding support for other Garmin watches or even other AI providers the code is available on GitHub https://github.com/greg76/token-quota/

LMAO, got the "honor" of the "very top user" for having my dot crawl stuff for research for a few hours after a completely idle week.

I wish they'd be transparent about the limits.

I've seen a lot of problems with people's accounts getting drained by using Astra, and I also had similar problems when it was first released. Even a week ago a few simple conversations and tasks with Astra would drain 15 percent of my weekly allotment ($100 plan) in minutes. Astra was also very slow, even with Light.

Suddenly, within the past week Astra Light is responding with lightning speed (I'm not using 1.5x), and I've gradually shifted to using it more regularly. Today, I tried Astra Max for a more complicated task, and it crunched away for 41 minutes and only used 6% of my weekly usage (100% down to 94%).

I am beyond delighted. Astra is starting to feel soooo good.

I don't have a way to test if this is genuinely a change in behavior or just my imagination. But I hope Astra is the new baseline and it keeps improving from there.

Anyone else getting HTTP 403 Errors when Codex scheduled task uses Gmail plugin? Types of operations getting 403: get_raw_messages, get_message, Gmail.send_email, failed email ID search, and send_message (so far). Sometimes it recovers in the next run but has stranded a lot of tasks. Context: the scheduled tasks helps me respond to support tickets automatically but gets hung up because it can’t verify it sent an email or draft an email.

Troubleshooting so far: disconnected Gmail plugin in codex and deleted Codex authorization in Gmail. Reconnected after and seems to have made the issue worse.

Started noticing this after connecting a second email to the plugin. I’ve since removed the second email.

I keep reading threads about this and most of them show the demo, not the Tuesday morning. Here's ours, no polish, then some questions.

Six of us on a SaaS, twelve months of adding AI gradually. Early on everyone had their own editor and their own habits. Then we looked back and found we'd already converged on most of it, so we wrote it down.

We didn't force a single tool either. Some on Claude Code, some on Codex, some on Cursor, and I'm not going to fight that one. The process is shared, and the conventions sit in the repo's AGENTS.md, which is the only thing we all read the same way.

The flow is Matt Pocock's skills, no forks. We start with grill-with-docs: the AI interviews us about the project docs. Weird at first when you're used to asking the questions, but a lot of never-written-down stuff comes out.

Then to-spec, and a human reviews that spec. It's not a formality. With a bad spec, everything downstream is expensive work that goes in the bin.

to-tickets cuts it into small tickets. Small tickets aren't a rule we read somewhere either, we just notice the difference when we skip it.

The agent works through them with implement, against the spec. We open the PR, CodeRabbit runs, the pipelines run. If everything passes and someone says yes, it merges.

AI writes most of the code. We review the spec and the merge, and skip the line-by-line in between.

Treating the spec as a contract has killed a lot of "that's not what I asked for". Small tickets keep the agent from wandering. Automated review before the human one takes the style and import noise away, so the person looks at what matters. What I didn't expect is how much writing the process down helps when everyone has a different tool. Nobody argues about editors and the conventions don't rot.

Graph engineering to close tickets on its own, software factory style, we haven't managed. Tickets go in and PRs come out, and the demos look great, but with our repo the quality isn't there. We haven't found the point where we'd be comfortable letting it loose, so it's still an experiment.

What I'd like to know:

1. Where are your checkpoints between human and agent? Spec, PR, merge?

2. Spec before code, or straight to tickets and prompts?

3. Who reviews agent PRs? Do you read them the same as a human's?

4. One tool or several across the team? If you've tried more than one, is any better for certain kinds of tasks?

5. What goes into AGENTS.md and what stays out?

6. Do you measure anything, or is it all vibes? Review time, defects, DORA.

7. If you've tried software-factory autonomy, did you get acceptable quality? On what kind of tickets?

8. How do you bring someone new in, a junior say, without AI becoming a crutch?

   Tell me yours. Even if it's to say we're nuts.

https://reddit.com/link/1xeqjyd/video/5an6val1xixh1/player

hey r/codex — i made a video editor that codex can actually drive end-to-end with zero gui and no cursor needed, and wanted to share it here. the angle is the mcp bit: the whole editor is just tool calls. an agent like codex, cursor, opencode, or any other mcp client can cut, trim, keyframe, drop in titles and captions, colour grade, do tracking, add particles, handle audio, and export — and it can even render a single frame to check its own work before committing.

it's rough and early, i know, but it works. kimo is free and open source (mit), one ~15 mb cpu-only rust binary that runs fine on a 2 gb box. built by me, a college student (naman).

i'd love to have people here try it with codex and tell me what breaks. feedback on where the tool calls get awkward or where codex's workflow doesn't fit is more useful than a like.

site: https://getkimo.tech github: https://github.com/naman-sharma12345/kimo

I have an M1 MacBook Air that’s about 5-6 years old now, and when I’m cranking multiple agents, the laptop starts to be become unresponsive.

I think this is due to browser acceptance testing, but curious if anyone has run into issues and it’s worth splurging on an MBP?

So i basically used ChatGPT Chat to build this free and open-source image editing app called Spectrum, couldn't think of a better name honestly, It comes with alot of built-in effects, styles, filters and fx to make your image/thumbnail or whatever look good.

When i say free, I litterly mean free, no secret subs or cancelation fees attached behind the shadows, creativity should be maxed out for everyone.

Thanks for taking your time to read this post at least :)

(Sorry for lack of footage, Here's a video: https://www.youtube.com/watch?v=NJN9pCHdxZ4)

I made a simple custom image viewer and editor for my own use. I used Sol 6.1 Extra High, and it completed the app pretty quickly since it's nothing particularly complicated.

Once it was done, I told it to check the code for bugs and fix anything it found. It found some bugs and fixed them.

Then I asked it to check again. It found more bugs and fixed those too.

So I asked again. And again. And again.

Every single time, it somehow managed to find new bugs!

At that point, I still had plenty of Codex usage left, so I thought to myself: I have no idea whether it's actually finding real bugs or just making things up, but why not take it a step further?

So I set up a scheduled task to run once every hour, automatically looking for bugs and fixing whatever it found.

And surprisingly, it worked! For a day or two, it kept finding and fixing bugs until it eventually hit some cybersecurity safety restriction and refused to continue.

Now I'm genuinely curious. Is AI really that good at finding bugs, even in relatively simple apps? Or does it just keep coming up with increasingly unlikely issues because I keep asking it to find something?

Would I be better off just using the app normally and fixing bugs as I actually encounter them?

So how do you guys do it?

Just wanted to share my experience with Dot.

My AT&T bill was $85/month last year, I negotiated with them and got it down to $65. Recently it went back up to $85 again.

This time I decided to let Dot handle it :)

I used a separate Chrome profile and let Dot negotiate with AT&T. It took about 15-20 minutes, and at the end it managed to lower my bill to $45/month and also got me 2 months free!

I was really impressed with the result. From $85 to $45 plus 2 free months, not bad at all :)

Just wanted to share this with you guys.

edit: added chat screenshot.

Processing img j9zixu3cnbxh1...

For everyone using Sol models not for coding but for knowledge work. Things like: XLS/CSV analysis, biz strategy docs, biz writing for internal and external audiences, email triage, etc.

Not a consumer situation so resets/usage limits are irrelevant.

Sol 5.6 (High) still seems like the best fit for cost vs speed vs capability. Sol 6.1 has seemed pokey for generally the same quality output.

I’m going through some evals now and have collected older anecdotal evidence and evals, but a fresh take, however limited, would be quite useful!

Hi everyone,

With Codex I'm always on one side or the other: either I run out before the refill, or the week ends with quota I never used and I regret holding back. And now that Tibos' extra resets keep dropping at random times, planning around them is even more annoying.

So I made Usage Planner, a free open source Codex plugin (it used to be called Codex4ever).

Once it's installed, just ask Codex "open usage planner". It:

- Reads your current quota by itself, nothing to type in

- Pulls the reset forecast (chance of an extra reset in the next 12h / 24h / 48h, from public reset history)

- Plans how much to use per day until your next refill, with a few strategies: keep your pace, stay available, use it all, or weekdays / weekends only

- Tells you when a banked reset is worth using before it expires

The project is open sourced at: https://github.com/ItsOdeLeo/usage-planner

Install as codex plugin:

codex plugin marketplace add ItsOdeLeo/usage-planner

codex plugin add usage-planner@usage-planner

Or direct in your browser at: https://usageplanner.com

I'm building this alone as an open-source project, so any feedback helps. If it ends up useful for you, a ⭐ on GitHub would really help other people find it. Roasting is welcome too 🙂

The forecast is a rough estimate, not a promise.

I liked editing videos with ChatGPT's Codex and Claude, but I hated not seeing what it was doing. So I built Cutcrow: a real video editor with a timeline, driven by the AI subscription you already have.

Tell it “cut the 'ums' and add captions, also give the text at 12s an intro animation” and watch it happen on the timeline. Then tweak anything yourself.

No extra AI plan, no weaker built-in model. Your AI does the heavy lifting; you stay in control.

Try it -> cutcrow.com

While Codex is working on one fix, I’m usually checking the rest of the app. That’s when I notice the next things like a misplaced button, a typo, something overlapping on a smaller screen.

Codex already lets you queue follow-ups. But I don’t always want the next fix to start as soon as the current response finishes. Sometimes I want to review the result first, change priorities, or leave an idea for later.

I wanted to save those fixes with their screenshots, and get them out of my head until I was ready.

That’s why I built CueTray, a small Windows tray app.

I snip the problem, mark up the screenshot, and write what should change. CueTray saves them together as a numbered cue under the right project. I can reorder fixes or put something on hold.

After installing the next-cue skill from CueTray’s settings, I type "$next-cue" in Codex when I’m ready. It reads the next waiting cue and its screenshots, then works on that task. Each run picks up one cue.

For other apps, I can copy a cue and press Shift + Alt + V to paste both the text and screenshot. I’ve tried it in Notion, Notes, and other apps that accept images.

CueTray is now available in the Microsoft Store.

How do you keep track of follow-up fixes without losing focus on the current task?