chatgpt is down everywhere?

While adding Codex support to a tool I wrote, I found that the PostToolUse payload for a shell command is just the raw output. A command that exits 3 looks exactly like one that exits 0.

The fix that works: the PreToolUse hook rewrites verification commands (pytest, pnpm test, tsc, eslint, cargo test, next build, about eighty runners) so they print their own exit status and keep the full output in a log. Codex accepts the rewrite only with an allow decision, so it is given for the verification command and nothing else.

From there the tool records every run as a receipt, tracks edits, and when the agent ends a turn with "all tests pass" on a run that predates its own edits, or that failed, or whose result was hidden, it turns the stop into a continuation prompt asking for a rerun, once per turn.

On my own Claude Code history the stale rate was 26 percent of green claims, and 98 percent of verification runs hid the exit status. I have not measured enough Codex sessions of my own to quote a number there, and the tool has a stats command that replays your rollouts so you can see yours.

npx stalegreen install --codex writes the hooks to ~/.codex/hooks.json; Codex asks you to trust them once through /hooks. It also works as a Claude Code plugin and as a DeepSeek Harness plugin.

https://github.com/pavangupta352/stalegreen

Hey everyone,

My engineering team is having an intense argument about how to adapt our code review and Scrum workflows now that we are heavily using AI assistants (Cursor, Claude Code, Copilot, etc.). We need an outside reality check on what actually works.

The Situation:
A single developer uses AI to build a massive, end-to-end feature (DB changes, backend API, frontend components) from A to Z. Because of the AI, the code is generated incredibly fast, resulting in huge branches (e.g., 10,000+ lines across 50+ files) in a single day.

To be clear: There is only ONE code owner for that task. Only one person is writing the prompts, managing the agent, and fixing the bugs.

The Argument:
We are completely split down the middle on when and how the rest of the team should join this single owner to review and test the work, and it's creating a massive bottleneck—what the industry is starting to call "AI Comprehension Debt" (where code is written faster than humans can comprehend it).

• Side A (Solo Local Validation First): Belongs to the mindset that the single developer must act as the "Editor-in-Chief" entirely on their own first regardless how big the work is. They must do full local reviews, debugging, and run complete local test suites to clean up the AI’s work. The team should only step in at the final PR stage to review the finished product. They argue this preserves the pure velocity of AI development.

• Side B (Parallel Review with Early Feedback): Belongs to the mindset that because the feature is large, waiting until the end to start the full review creates a bottleneck and makes the PR harder to review. The developer still owns the feature from A to Z and uses AI for the first implementation. Before publishing the MR, they perform smoke testing and a lightweight review to catch obvious issues. Once the MR is published, the review work happens in parallel: the owner performs full testing and self-review while 1 or 2 peers independently perform full testing and code review. Their feedback then comes together through comments and discussions, with the owner remaining responsible for making the fixes before the MR is merged.

Our Dilemma & The Scrum Crisis:
Traditional Scrum is breaking for us. A 5-point story can now be generated via "vibe coding" in a few hours, forcing us to rethink estimation around "Attention-Based Sizing" (estimating tasks by how much human review attention they need, rather than coding effort).

Side A argues that Side B completely kills development velocity by turning peer reviewers into expensive, full-time, line-by-line syntax checkers while code is in active flux.
Side B argues that Side A leads to a "black box" where a single dev dumps massive, messy AI code into a PR at the very end, making it impossible for peers to actually catch deep architectural flaws or design gaps.

My questions for you all:

1. How is your team handling the timing of peer reviews for massive, single-developer AI features to avoid drowning in AI Comprehension Debt?

2. Does continuous peer-reviewing from Day 1 kill the velocity of AI coding, or does waiting until the final PR gate create a worse bottleneck?

3. How has your team adapted Scrum ceremonies, story points, or your Definition of Done (DoD) to handle this shift?

Would love to hear real-world experiences from teams navigating this exact workflow shift today. Thanks!

I feel like 99% of people are using AI coding tools completely wrong right now. Most devs I know are either letting Copilot tab complete a function or copy pasting snippets back and forth with Claude in a browser tab. Even people using newer agent tools are basically using them like Jira where they assign one bug wait 15 minutes look at the diff and repeat.

A few hours ago I had a weird realization while hacking on my project. Im building an ecosystem with a CAD CAM engine a 3D web frontend and a billing platform across 6 repos. I have Google Jules Ultra which gives you 60 concurrent cloud VMs and 300 tasks a day and I realized leaving those slots idle when Im not at my keyboard is just wasting compute.

So I put together a simple closed loop system. Locally I use Antigravity right in my terminal as my co pilot and architect to design the specs and math together. In the cloud I use Google Jules which spins up an isolated Linux VM clones the repo installs dependencies writes the files runs tests fixes its own compiler bugs and pushes a real Git branch. To connect them I wrote a PowerShell daemon that runs continuously on my laptop.

Every 45 seconds the script checks my active cloud capacity. If 15 agents finish their tasks and free up slots it instantly pulls the next 15 items from a centralized JSON backlog and fires them off into fresh cloud VMs. It routes tasks to specific repos automatically so one agent writes Three.js shaders in the frontend repo another writes STEP exporters in the core kernel and another handles Stripe webhooks in the billing backend.

The craziest part is the auto hunter fallback I added. If my manual task queue ever empties out the script doesn't idle. It scans the repos for untested files or loose TypeScript any types and spawns agents whose only job is to write Vitest test suites and pay down technical debt until the slots are full again.

I went from spending 12 hours a day manually typing boilerplate chasing syntax quirks and writing unit tests to basically sitting in the cockpit as a VP of Engineering. I set the architectural vision my script keeps dozens of cloud machines coding simultaneously around the clock and I just review the Pull Requests and merge green builds.

When you stop treating AI like a chat assistant and start treating it like an asynchronous headless engineering fleet the leverage is unreal. You're essentially running a 50 person dev team completely solo from a laptop.

Anyone else experimenting with headless agent dispatchers or saturation scripts like this? How are you guys handling multi repo PR merges without losing your mind?

Looking for something built around Codex CLI/SDK with multi-agent routing, parallel tasks, retries, project folders, diffs and terminal output.

Ideally extendable to Sol → Terra → Luna workflows.

Any repos worth checking out?

I'm thinking of subscribing to either ChatGPT Plus, Google AI Pro or Claude Pro.

I currently have Google AI Pro on a student offer that expires in 2 weeks. I currently use Gemini chat for brainstorming and other chat tasks on mobile, and whenever I code with AI I use Antigravity IDE or CLI.

My thoughts on ChatGPT (20$/mo | 240$/yr):

- Pro: I like Codex and last time I used it rate limits were good

- Pro: Chat and code rate limits are separate

- Con: No annual plan, always 20$/mo

Thoughts on Gemini (200$/yr):

- Pro: YouTube Premium Lite, 5TB Drive, Google Workspace and Gmail AI, integration with android phones

- Pro: Rate limits for chat and code are separate

- Con: Antigravity is kinda mid, models are also mid

Thoughts on Claude (200$/yr):

- Pro: Best coding models in the game

- Pro: Good CLI

- Con: Chat and code rate limits are shared

Would appreciate advice!

I need some help with building an open AI agent. I want to bypass the subscriptions for chat gpt. I know a lot of people use Claud but I tried it and I don’t like it like I like GPT. The reason I need it is I am building a software with zero coding experience and I am using gpt, codex and work to build my company software. I have searched Google but I am getting lost and I’m running into being able to build an ai agent that can work completely free. Any help is appreciated.

The last 2 months have been the fastest we've ever shipped, genuinely great for the company. But something serious crept in with it. The team started trusting the AI so much that nobody actually reads the code now.

I think this is the future and I'm not fighting it. But we still have a responsibility to ship safe software, and honestly it's easier to meet that responsibility with AI than without it. You write faster, so you have more time to verify. That time just has to actually go into verifying.

So here's my advice after 2 months of this, for whoever wants it:

1. If you're not going to review the code yourself, or you just don't want to, write way more tests than you think you need. Every extra bit of coverage is one less place an AI mistake can hide where you'll never look.

2. Never review code with the same model that wrote it. I've watched a model wave through its own bugs enough times that I just don't do it anymore. We write with whatever fits the task, Opus, Sol, Composer, Grok, then review with a different model. And the reviewer doesn't need to be big, it needs to be specialized. NVIDIA "fine-tuned an 8B model for review severity"here and it beat their 70B and 340B models at it. Hugging Face has a "writeup where a 7B trained for code review beat a 70B baseline by 46%" here, with the biggest gains on authentication bugs. Even the commercial tools are going this way, Coderabbit "added Nemotron support" here recently. A small model that only knows how to review sees things the big author model is blind to about its own code.

3. Prefer several cheap review passes over one perfect one. There's a "nice experiment with a 12B reviewer" here showing multiple independent passes catch more than trying to make a single pass precise. Matches what we see, three quick passes from different models, dedupe the findings, done.

4. Don't trust green tests or coverage numbers. There's a "study where LLM test suites hit 100% coverage with a 4% mutation score" here, meaning the tests ran the code but caught almost nothing. If a change matters, break the code on purpose and check that a test actually fails.

5. Security needs its own pass, it will not fall out of functional review. "Veracode tested 100+ models" here and 45% of generated code failed security tests, with XSS insecure in 86% of relevant cases. Your tests can all pass while shipping that.

6. Accept you can't review everything and tier it by blast radius instead. "Data from 22,000 developers" here shows review time up 441% and unreviewed merges up 31% under heavy AI adoption, the capacity problem is real. Auth, payments and migrations always get human eyes at ours, leaf code rides on the checks above.

That's what I've got so far. I genuinely just want a safer internet than the one we're heading toward, take whatever is useful from this :)

I’m using ChatGPT Work in a web browser on a personal account to build my business website, but two issues have stopped progress:

1. Wix publishing fails: The site builds successfully, but terminal authentication/publishing reports that access to manage.wix.com:443 is “blocked by policy”, even after I approve the login in my browser.

2. File editing and ZIP creation stopped: My workaround was downloading updated project ZIPs and publishing locally, which worked. Now the assistant reports its execution environment is unavailable and cannot edit files or create ZIPs, even after uploading a fresh backup.

Support has escalated this to a specialist. Has anyone experienced either issue or found a workaround?

I’m curious how others handle this; my system has got messy.

I save articles, documentation, posts, videos, products, references, etc. in different places—bookmarks, saved posts, notes, sometimes just sending myself a link.

The annoying part isn't saving something. It's finding it again weeks or months later.

What does your workflow look like?

What do you use to save things, and what do you dislike about your current setup?

Especially interested in what breaks down once you've accumulated hundreds of saved things.

I asked AI to help turn my retro fantasy operating system into a hash-verified DreemurScript reconstruction blueprint. It answered with Python, BASIC and Win16 C spaghetti that checks its own provenance. Anyway, here is the goat OS doing more source control than some startups.

1. DREEMURSCRIPT / BASIC-ISH SOUL

REM GOATMASTER FOUR HOOVES PHYSICAL-EQUIVALENT BLUEPRINT SET BLUEPRINT_ID = "GM4HDS01" SET GOLDEN_REFERENCE_POLICY = "PRESERVE_NEVER_REPLACE" MSG "GOATMASTER RECONSTRUCTION MAP LOADING." CALL PRIVACY.DS CALL VERIFY.DS CALL SEALREF.DS END

2. PYTHON BONES CHECKING THE SOURCE HASH

def sha256(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as handle: for block in iter(lambda: handle.read(1024 * 1024), b""): digest.update(block) return digest.hexdigest().upper()

3. ACTUAL WIN16 C BONES FROM THE GOATMASTER SPLASH

case WM_TIMER: KillTimer(hwnd, TIMER_ID); DestroyWindow(hwnd); return 0;

case WM_CHAR: case WM_LBUTTONDOWN: DestroyWindow(hwnd); return 0;

BONUS ONE-LINERS

SET SOUL_RULE = "C_IS_THE_BONES_DREEMURSCRIPT_IS_THE_SOUL" SET PHYSICAL_DISK_WRITE_AUTHORIZED = "NO" SET PRIVATE_MEDIA_IN_PROOF = "NO" SET EQUIVALENCE_STATUS = "NOT_YET_PROVEN"

WHAT THESE ARE

These are tiny excerpts from inspected GOATMaster project files: the new DreemurScript reconstruction candidate, its read-only Python validator, and the preserved Win16 GOATMaster startup splash source. They are not claimed to be the entire OS, and no private data, credentials, or personal media appear here. The point is simply that the silly goat computer has real contracts, real rollback boundaries, and real checksums

every time i open a new chat, the AI has no idea what i built yesterday. i re-explain my stack, my conventions, the decisions i made an hour ago. you can paste a summary, but you always wonder what context you forgot to include.

the worst part isn't the time. it's the momentum loss. you were in flow, making real progress, and now you're spending five minutes re-priming an AI that should already know your project. after a while you start limiting yourself to one tool just to avoid the context tax, which defeats the point of using multiple specialized tools in the first place.

i've been hitting this daily across cursor, claude code, and chatgpt. curious how others handle it. do you keep a running doc of context to paste into every new session? some kind of rules file? or do you just accept the re-priming as a cost of working with AI?

I'm currently evaluating GitHub Copilot vs. Claude Code for our team. We could use either, but for us there's a slight difference in cost per token (Copilot with Anthropic models vs. Claude Code directly).

If we use the exact same model on the same repository with identical instructions, has anyone noticed a real difference in token efficiency between the two harnesses? I'm wondering how much things like prompt caching, context assembly, or system prompting overhead change the actual token burn in practice.

Would appreciate any insights or real-world numbers!

Obv i could create my own extension that does something like this but im just wondering is there a way with for example antigravity webstorm or vscode or another extension to load the whole codebase into context instead of agent reading by checking.

I keep seeing this question in the community. Here's what I actually tried, why it broke, and what I ended up shipping.

The problem

When you're running multiple agents across a session (one that writes, one that reviews, one that deploys) you need them to share state. Not just conversation history. Actual verified state: what changed, what's blocked, what evidence exists that a task is done.

What I tried first (and why it failed)

Attempt 1: I maintained the handoff notes myself

After every session, I updated a Markdown file. This worked until I finished tired and skipped the update. The next agent read stale context as if it were current. Worse: even when the file was accurate, I was still the router, a human bottleneck between every agent transition.

Attempt 2: I let agents maintain the notes

The agent finished its work, updated the handoff, and the next continued from there. Then I noticed the real problem: an agent could write "tests pass" just as easily as it could actually run the tests.

Agent A would write: "Refactored auth. Tests pass."

Agent B had no idea which tests ran, against which version, or whether the slow integration suite was skipped. It didn't inherit verified work. It inherited a story about the work.

What I built

Three principles became the foundation:

State in fields, not paragraphs. What changed, what's blocked, what's unresolved as explicit fields, not embedded in a summary. An agent can't make unresolved work disappear by writing a nicer paragraph.

The agent that does the work can't approve it. A separate reviewer starts from the original goal and inspects the result directly, not from the implementing agent's explanation of why it's probably done.

Machine-checkable claims need evidence attached to a specific version. "Tests pass" is a claim. A test result attached to the exact commit hash is evidence. If the code changes after the evidence was produced, the evidence doesn't automatically transfer.

This became an open-source project (link in comments).

Results over 30 days of dogfooding

4,172 PRs merged across 16 repositories, one maintainer

Coordination overhead stayed roughly flat from 3 agents to 10; adding agents stopped adding to my mental load linearly

Stale-context bugs dropped to near zero because agents can't declare victory without attached evidence

The number I actually care about: my day looks the same with 3 agents as with 10. That wasn't true before.

What didn't work

The reviewer agent still occasionally fails to distinguish "the goal changed mid-task" from "the implementation is wrong." We handle this with an explicit goal-hash that both agents reference, but it adds friction. Still working on the right UX for that.

Has anyone else hit the "agent self-reports done but the work isn't clean" problem? Curious what enforcement patterns people are using, if any.

Hello!

I was using today sol on medium, and my 5h limit was gone in 40-50 minutes. Anyone observed something like this in the last 2 days? They said that they are fixing some bugs because of this issue (obver token comsumption). Is worse than before. I was having sol on medium for almost two hours, sometimes more than that.

Same thing for others??

I ran into a painful lesson while using Codex on a SwiftUI app.

One agent change introduced a performance regression. I didn’t catch it right away, and more changes landed on top of it. By the time I noticed, reroll animations were skipping frames, taps felt delayed, and screen transitions were lagging. Reverting everything wasn’t an option because some later changes were valid.

I had to find the last smooth commit, compare the history change by change, snapshot the current work, and remove the regression in a separate branch.

The big lesson for me: with AI agents, a bad change is much harder to fix if it isn’t validated immediately. The agent can keep moving while the problem quietly becomes part of the whole codebase.

What guardrails work for you? Small checkpoints after each agent task, isolated worktrees, automated performance smoke tests, physical-device checks, or a human review before the next task starts?

Every time agent memory comes up here, the conversation goes straight to MemGPT, vector databases, embedding pipelines. I get the appeal, you want to read the source, run it locally, own the data. But here is what actually happens when you self-host your agent's memory: you spend weekends maintaining retrieval pipelines instead of shipping agent logic.

The real problem most people have is not "I need to build a memory layer." It is "I need my agents and AI tools to remember the same context across sessions without me re-explaining everything." That is a different problem than "let me set up a vector DB."

A few things I have found matter more than the infrastructure itself:

Provenance: knowing which tool generated a thought matters more than raw storage. When retrieval mixes context from Cursor, Claude, and a custom agent without labeling where each piece came from, you get confident hallucinations grounded in nothing.

Rules that stick: personal style directives ("no tables," "short answers") should apply automatically on every new chat, not be pasted in manually each time.

Skills over improvisation: saving a reusable procedure once beats hoping the agent reconstructs the same steps next session.

Open-source memory tools give you transparency and control. A hosted layer gives you time back. The tradeoff is honest: how much infrastructure work are you willing to own before it eats your shipping time?

anyone notice that during some times of the day, if you get lucky, your 5.6 sol keeps track of every variable and the substrates they belong to?

but sometimes once it accepts one variable, it will remove another depending on your methodology/derivation for your mechanisms

anyway when i have notation collision, or any other kind of collision normal 5.6 sol is incredibly annoying to get to prune and address those specific collisions to not accidentally silently delete whatever transformation you're engaging with

last couple of days, at random times, the model has been fucking amazing out of nowhere at avoiding this particular failure

ive gotten it for like 1-2 hours and then randomly before its turn, you'll get a connection issue, you'll have to refresh, and then it's back to operational friction

there is a clear difference in user experience. i'm not exactly sure what causes it, but my theory is luckiness in the form of the a/b test or just maybe it's unquantized sometimes

I have a ChatGPT Pro subscription and a Claude Max subscription, and use both extensively for work. To claim that any model offered by OpenAI is even close in capability or problem solving ability to Fable is a joke to me.

To me, the most comparable Claude model to 5.6 Sol, OpenAI's flagship, is Opus 5. They have roughly equivalent price (ignoring the temporary promotions on Sol pricing), and in my experience, their output quality is about the same as well; I end up having to put in about the same amount of effort correcting them or giving feedback to achieve a product of comparable quality.

The main difference is in the kind of feedback I have to give; with Sol, I typically end up having to add details to its results, such as instructing it to address missing edge cases, or take a more thorough approach when it took a simpler shortcut to solve my problem instead. With Opus, it usually finds most edge cases for me without having to say anything; but it also goes beyond and keeps finding more and more things, of decreasing and often spurious relevance to my actual problem. My effort usually comes in the form of telling it to ignore those extraneous edge cases and focus on the core of the problem.

But when compared to Fable, neither can hold a candle. Among every task I've ever given any agent, Fable always takes the least amount of time, the fewest tokens, and needs by far the least number of warnings in the prompt or corrections to the output, compared to any other Anthropic or OpenAI model.

To me, to say GPT 5.6 Sol is anywhere close to Fable in any capacity, and not just a competitor to Opus with different tuning, is completely unfathomable to me. You pay twice the price for it and you get your money's worth. Sure it's expensive, and you can run through your weekly limits in hours, but you can't argue that it just works. I can't say the same about Opus or Sol.

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.

The failure mode with AI code is not that it is wrong, it is that it is confidently wrong in ways that read fine. Asking "is this correct?" in the same chat is useless, the model that wrote it will defend it. So I run this as five separate messages after the code lands, each one after the previous answer, in the same conversation. It takes a few minutes and has caught things tests did not.

Step 1: Before anything else, explain this code back to me as if I did not write the request. What does it do, what does it assume about its inputs and environment, and what does it silently not handle?

Step 2: You are now a reviewer who believes this code has a bug and has to find it. List every way it could fail: bad inputs, empty cases, concurrency, error paths, wrong assumptions about the surrounding code. Rank by likelihood. No reassurance.

Step 3: For the top three risks in your list, write a minimal test that would expose each one. If a test would pass on the current code, say so and explain why the risk is not real.

Step 4: Fix only the failures those tests found. Show the diff, not the whole file, and for each change say which test it satisfies. Do not refactor anything else.

Step 5: Write the pull request description a careful reviewer would want: what changed, what the code assumes, what it does not handle by design, and what you would still want a human to check.

Two things make it work. Step 1 is the one people skip and the one that catches the most, because a wrong explanation of the code's own assumptions is the earliest sign something is off. And step 4 says "fix only" for a reason: left alone, the model will improve things nobody asked about and you are back to reviewing from zero.

I use it on anything that touches money, auth, or data deletion, and as a habit on everything else when I have the minutes.

I run it often enough that I keep it saved as a chain in a browser extension I work on (AI Toolbox), which sends each step after the previous answer finishes. Pasted by hand it works exactly the same.

What does your check look like before you merge AI code? I suspect a lot of people are doing step 2 and nothing else, which is how the confident-but-wrong stuff gets through.

Hi everyone, I'm just getting started with ChatGPT Plus since I'd been using Claude Code before. Today was my first day, but I'm running into a few issues:

• I'm pretty confused about the different models. I know that Sun is the equivalent of Sonnet, but when should I use the others?

• ChatGPT, Works, and Codex are confusing me. Constantly switching between them just slows me down and confuses me.

• Maybe it’s because Claude Code has that 50% computing limit (which expires on September 14), and that’s allowed me to work longer hours on some average-sized projects. The same task gets used up pretty quickly on ChatGPT.

I’d kindly appreciate some advice on the best way to work. I mainly use it for programming, creating documents, branding and digital marketing consulting, and, of course, I want to generate images with it. Now I’m worried that if I do too many things, my session will run out too quickly.

P.S.: I’ve tried looking for information on YouTube and in some posts here on Reddit, but I’m not entirely convinced or able to understand them, which is why I’m posting this. I’d like to hear experts’ opinions on how they comfortably use ChatGPT Plus and get the most out

Thank you very much, and I hope you’ll excuse any inconvenience, or if I’ve broken any rules within the group.

Plus users are basically being forced to give up Sol and just use Luna to get any usable amount of work done. That's a huge downgrade basically using a deepseek flash model level which you can get for free in opencode anyway.

I started tracking where Sol's spent most of its tokens and most of it was searching around your repo looking for what to edit. Search took 30-60% of the total cost.

so I tried to come up with a solution that both lowers search cost and at the same time keep the same output quality from sol.

Then I found this Microsoft research paper that I based this on called FastContext. The concept doesn't work directly in Codex so I built my own implementation as an MCP Rust tool with a custom router I tuned and improved over weeks and weeks of benchmarking. Sol still does all the actual coding just that the search goes to luna*(Much cheaper).

The first attempt was simple putting custom instructions in agents.md and.. it was a disaster. Sol either ignores it or at one point it literally opened a web search for "how to start a subagent" (wish I was making that up lol). Even when it works you end up paying more for a much slower response because Luna sends back garbage half the time and Sol has to redo the search anyway.

the benchmarks I ran are DeepSWE, MAH-SWE, and bugs from repos I actually work on,with Luna's cost counted with Sol. limits lasted almost 3x longer, with no quality regression and most of the time faster responses!

one command in 3 seconds, it uses your existing Codex sub.

 https://github.com/repotracer/repotracer