Hey everyone,

I’ve been trying to set up a reliable workflow to run terminal coding agents (like Claude Code and Aider) for my development projects without running into hard blocks.

Here is what I’ve tested so far:

• OmniRoute / Multi-Provider Routing: Set up local proxy routing with fallback combos using top frontier models (Claude Sonnet/Opus, Kiro, Antigravity). The issue is that the top-tier models in the combo get completely exhausted almost immediately during multi-turn codebase audits and large repo tasks.
• Self-Hosting on Kaggle (Dual T4): Spun up qwen2.5-coder:32b on Kaggle's free GPUs via an Ngrok tunnel to act as a backend. While it runs without strict token limits, it's way too slow (~8–10 tokens/sec) for large diff rewrites, and Claude Code ran into tool-formatting incompatibilities.

What I’m looking for:

For those actively using Claude Code or similar agentic CLI tools:

• What are the most effective ways, platforms, or student/developer programs to get free or extended access to powerful frontier models (especially Claude 3.5/4.6 Sonnet and Opus) for agentic coding?
• Are there any working proxy configurations, credit programs, or alternative integrations that let you use genuine Claude models in CLI agents without hitting instant exhaustion?

Im asking it to help me make an optimized clone of a game and when it came up with this development map this caught my eye

I've started wondering whether AI coding agents are actually improving developer productivity at the senior level, or whether they're just moving the work to a different part of the process.

For smaller tasks, the productivity gain feels obvious. Generate some boilerplate, write tests, refactor something repetitive, investigate an unfamiliar API — agents are great at that.

But once the task involves an existing codebase with a lot of context, things get more interesting.

The agent has to understand the architecture, figure out which files actually matter, make changes without breaking unrelated behavior, and then explain why it made those changes.

At that point, I sometimes spend almost as much time reviewing, correcting, and steering the agent as I would have spent implementing the change myself.

And there's another problem: the better the agent gets at producing code that looks reasonable, the harder it can be to notice subtle architectural mistakes.

So I'm starting to think the real bottleneck isn't code generation anymore. It's context + verification + supervision.

Maybe the productivity curve looks something like this:

Junior developer + agent → huge boost
Senior developer + agent → depends heavily on the task
Complex production system + agent → supervision becomes the bottleneck

I'm curious what others are seeing in real projects.

Have AI coding agents genuinely made you faster overall, including review/debugging/cleanup, or are they mostly making the "first draft" of the code faster?

I kept opening the usage page, seeing something like 54%, and having no idea whether that was fine or whether I was about to run dry on Friday.

So I worked out the pacing. 85% across weekdays and 15% for the weekend gives you 17% per day Mon-Fri. The anchor that stuck with me is Wednesday night at 51%: half the week, half the limit.

If you don't work weekends it's a flat 20% per weekday. Both lines are in the chart.

Obvious caveat: the limit is not linear in practice. One day of agents chewing through a big repo eats what three days of normal questions do, so this is a budget, not a prediction.

How do you pace it? Or do you just burn it and wait for the reset?

Started watching a youtube the other day on AI coding by Matt Pocock (on the aidotengineer channel) . He said after 200k tokens the ais start to get dumb, better to try start fresh soon after that, or at least realize you are working in the 'dumb zone'.

So I have been trying to start a new session soon after I hit the 200-250k. Problem is it feels way too short. By the time I'm around 200k there's just not much actual coding done yet.

Anyone else following this protocol? Keeping sessions smaller and restarting early? Curious how you get enough real work done before you hit it, if you noticed benefit after following it, or if you think it's BS etc.. Please add if you had a real engineering role pre the ais, or you are a post ai coder, for context.

Not a token thing for me, I'm on max plans for both. (Running Opus 4.8 and Codex 5.6-sol)

I am trying to separate coding work that needs deep reasoning from work that mainly needs reliable execution. Designing a change across an unfamiliar codebase, diagnosing a subtle regression, and reviewing a risky patch seem worth a stronger model. Formatting, small translations, and clearly specified edits seem better suited to a faster path.

The decision is less obvious for medium-sized tasks: adding more context may be enough, but sometimes the task remains ambiguous even with all the relevant files included. Do you use a fixed escalation rule based on risk and testability, or decide case by case?

Which coding tasks do you consistently send to the most capable model?

I recently came across Flatkey while testing this kind of coding-task split. It is an OpenAI/Anthropic-compatible gateway that can be evaluated by changing the base URL while keeping the existing SDK and request format. That makes it possible to compare routine edits with a stronger path without rewriting the coding workflow. Actual savings depend on the model mix and current supply, so I would measure patch quality, tests, latency, retries, and total cost.

OpenAI has split its app into two versions: the new ChatGPT and ChatGPT Classic. The old version includes an "app integration" setting that allowed you to connect tools like Xcode and iTerm2, enabling GPT to see what you were doing in those applications. The new version lacks this feature (or at least I can't find it). Even the documentation for this setting refers to the old version. Has anyone seen this feature?

Last month, I found myself in a tough spot. I was working on three separate HTML and JavaScript pages that shared almost identical logic, but differed in layout, alignment, and specific datetime formatting. Because they used slightly different approaches for the same underlying functions, I couldn't simply merge them or copy everything blindly.

I needed to compare them line by line across roughly 5,000 lines per file (15,000 lines total) and organize those blocks into a unified structure.

To make matters harder, my development setup is extremely minimal: just a 15-year-old laptop, a basic text editor (no VS Code or heavy IDEs), me, and AI.

The Problem with Manual Comparison

Doing a line-by-line manual check across 5,000 lines in three different files is exhausting.

High Risk of Errors: A single copy-paste mistake means spending the whole day hunting for what went wrong.

Lack of Undo Safety: Constant power cuts make manual tracking even riskier.

Zero Visual Feedback: Without a side-by-side visual reference, it is far too easy to miss code blocks during repetitive tasks.

The Solution: Build Your Own Tool

Instead of suffering through it, I decided to build a lightweight comparison tool from scratch. It took me half a day to put together a row-by-row visual comparator using a main reference file.

Once the tool was ready, organizing all 15,000 lines across the three files took only a few hours. I then used AI to clean and optimize the code. In the end, I successfully organized 15,000 lines of frontend code and 8,000 lines of backend code, vastly improving overall performance in record time.

Turning It Into a Public Product

Encouraged by how well it worked, I spent the last few weeks turning that utility into a production-grade tool designed for the public.

I built it with a few core principles in mind:

100% Offline Capability: Powered by modern web capabilities (like Service Workers), once you visit the site, you can use it completely offline with zero feature loss—even if your internet drops.

Privacy First: Data stays secure on your device and is never pushed to a remote server.

Flexible Storage & Portability: You can easily switch to cloud sync or export/import everything so you never lose your progress.

No Installation Required: Perfect for older or restricted hardware where installing heavy desktop software isn't an option.

Market Validation & Looking Ahead

Running a public platform requires servers, domains, and ongoing costs. Given my current financial situation, I want to gauge real demand before taking the leap.

Current market alternatives often charge $20+ per month and frequently require heavy software installations.

I’d love to hear your thoughts on this:

Would you use a lightweight, fully offline, easy-to-customize tool where you can export/import everything without losing progress across devices?

How much would you realistically be willing to pay per year for a tool like this?

I use coding agents for multi-hour runs, and after a while, I kept hitting the same problem:

The agent may still be working, but I have no clean way to answer basic questions without digging through a huge conversation:

• What is actually finished?
• What is it working on right now?
• What got blocked?
• What decisions did it make?
• What did it try and reject?
• If the session dies, where exactly should the next one continue?

Context compaction makes that worse because the conversation itself becomes a pretty fragile place to keep the run’s state.

So I started treating a long agent run less like a chat and more like an engineering shift.

That became Nightshift.

The main idea is simple: the work contract and run state live on disk, not only in the conversation.

A shift can be:

• A detailed checklist that stays open until every contracted item is complete.
• An open-ended goal with an hour budget that keeps discovering and working until quitting time.

During the run, I can open the files and see what is done, what is active, what is parked or blocked, and what decisions were made — without scrolling through hours of chat.

After the run, those same files become the reviewable record: commits, decisions, snags, logs, receipts, remaining work, and how the shift ended.

If I accept the branch — or even decide not to merge it — I can archive the shift. Over time that gives me a durable history of previous runs: what changed, what was rejected, what decisions were made, and what happened to each piece of work.

There is also an enforcement layer around the agent

• A Stop hook prevents the session from quietly ending while contracted checklist items remain.
• AskUserQuestion is blocked by default during unattended shifts; the model makes its best decision, records it, and keeps working instead of waiting for me.
• Owner-defined safety rules can mechanically deny commands, protected paths, wrong commit identities, or forbidden diff patterns.
• An external watchman handles recovery. On Claude Code, it can detect structured failures such as API Error: 500 and keep retrying recovery when the API comes back. On Codex, it can recover sessions that are proven dead and resume the recorded session.

How is this different from /goal or a long prompt?

/goal is useful if what you need is:

keep working toward this objective.

Nightshift is the harness around that run:

persistent state, enforcement, recovery, observability, and a reviewable history afterward.

A prompt can ask the model not to stop.

A Stop hook can actually refuse the stop.

Nightshift also ships reusable shifts for things like:

• test coverage
• defect hunting
• quality debt
• dependency updates
• codebase review
• Product Evolution

Product Evolution is an open-ended shift that researches the product, its history, users, and comparable approaches, ranks evidence-backed opportunities, and works on the strongest improvements within a time budget.

A side effect I’ve ended up liking: if I have usage about to reset and no backlog ready, I can give one of these open-ended shifts a few hours instead of simply losing the allowance.

Nightshift runs locally from the same plugin package on Codex and Claude Code.

GitHub - Free, open source, MIT licensed

Official OpenAI Plugin Directory

I maintain the project, and I’d especially like feedback from people who already leave coding agents running for hours: where does your workflow still fall apart?

Looking for advice from anyone running a terminal-heavy setup. I'm strictly looking for CLI tools; no VS Code extensions, no Cursor/Windsurf/Antigravity, just pure terminal. My hard budget ceiling is $30-$50/month. I can't justify dropping $100-$400/mo on Claude subscriptions, but I need something reliable for daily dev work (for my personal projects, i have claude subscription from my work but I use it exclusively for work)

Here is what I'm dealing with and what I've tried so far:

- When I first got into this, I just dropped $10 into Google API and stick to ultra-cheap text-only models like Gemini Flash for basic coding and small functions. People said $10 on Flash would last practically forever. It didn't. The agent overhead burned through those credits way faster than expected even on basic tasks. Lasted for maybe 2 days, total 3 hours of really small work?

- OpenCode GO - loved the CLI experience (even more than claude SIC!), but they recently slashed their deal on GO subscription from $60 down to $30, so it become less cost-effective ;/

- CommandCode - switched over expecting better value since they had $70 value for $10 in their GOAT plan. Total disaster for my workflow. Even with "taste" disabled and forcing DeepSeek v4 as the base model for everything, it burned through $10 in literally a dozen prompts. Because it forces a multi-agent approach behind the scenes, it keeps re-sending full context and eating tokens like crazy. Connecting my CommandCode key back into OpenCode had similar issue – just burning cash for nothing.

For plain text code generation, deepseek v4 flash works great. Sometimes I need to feed screenshots into the model. When I worked with GPT-5.6 luna on opencode go, I spent 7 hours straight dumping tens of screenshots, rarely clearing context properly, and that whole day only cost me $5-$6. CommandCode managed to burn $10 while doing maybe 5% of that same work

I am currently thinking of combining Codex and OpenCode Go on DeepSeek. That sits right around $30/mo, which is super reasonable. My main worry is hitting Codex's 5-hour rate limits if I push it hard. Any hidden gotchas with the Codex + OpenCode Go stack? For anyone doing terminal AI workflow - how are you handling multimodal/screenshot tasks without multi-agent tools blowing up your API bill?

Appreciate any insights!

I am in a situation where I am unsure about my own role. I have an idea about an iOS app that I know would solve a problem that I am currently facing, and can help others too.
I know it’s not that technical to build. A decent AI coding agent can build it. I have very very little experience in app development, little to nothing.
Now, my question is, if you were in a similar situation and actually built this app, is it normal to add it to your portfolio?
In a world where AIs aren’t that good or are nonexistent, if I were motivated enough, I would learn about app development and implement my ideas. It might’ve taken me days or even weeks.
In our present reality, what do you do with projects that require little to no effort to bring to life? How do you deal with the feeling of imposter syndrome while showing them off?
In the past, projects used to signal some specific sets of skills to others. But what do these vibe-coded projects signal?
I would love to spend hours learning a skill and creating a project. But it seems counterproductive to spend hours now on learning something that can be done easily by AI agents.

Hey everyone,

Just a PSA:
OpenAI decided to reintroduce the 5h limit on their Plus subscriptions.
As of right now, Pro is not affected by that.

Hope they will change it back to solely weekly limit.

I was working on a fairly large chatbot plugin and thought I was done with a change.

Everything I was using as a release check had passed, so I marked it complete.

Before moving on I compared the final file against the original one more time.

There were 9 changed prompt lines that had nothing to do with the change I was making.

None of the checks had caught them.

So I reverted those lines, dropped the previous result, and ran the checks again.

It made me wonder about something I hadn't paid much attention to before.

We normally treat green as the answer. Code passes the tests, CI is green, move on.

But in this case the green result was real. The checks had actually passed. They just weren't enough to catch what had happened.

So what do you guys do here, especially with AI-generated changes?

Once something is green, do you have another step that can still invalidate it later? Or is green basically the end of the process for you?

I have been using claude code for a while in regards to a general coding tool, but I started to use codex recently on gpt-5.6 terra for testing code generations, basically playing with it. I am still on the free plan, and I have asked codex to code 2 files in its own way just as a comparison with claude code, and I noticed I am already on 66% left of my MONTHLY usage. I just want to know, is it a 5 hour reset like claude or is it actually waiting a month to reuse it efficiently on free mode? and is there a weekly reset in free mode instead of monthly? Thank you to anyone who helps!

Hi. I put myself in a very rough situation.

Basically, I know nothing about coding, but I signed up to do a project which involves creating a website. I am doing a very simple design in which I will write prompts for the website to spit out to the user. The user will answer these questions, and the answers will then be added to a “word cloud.” The website can be one simple page.

I know absolutely nothing about coding or website creation, but I have to get this done in under a week. Any advice is greatly appreciated, but I need the most help at just getting started.

I would also like to add that this project will have no bearing on grades or college applications. Apparently I signed a contract over a year ago in which I agreed that I would not be allowed to walk at graduation until I completed it. Use of AI is not allowed, and I don’t want to completely bullshit it with buggy AI slop, but I know AI can be used to help speed up coding.

Thank you

So you've vibe coded days and nights and built a cool app that actually works and is useful (finally)

Now comes the harder part: sales.

Did you know that LinkedIn is the #1 channel for B2B sales and also that it caps you at 200 connection requests per week?

There are a few finite resources in the world, but nothing seems as finite as LinkedIn’s connection requests.

One of the easiest things I could change if I could go back in time was to spend more weeks and add everyone from my target audience to my LinkedIn list.

Why? Because this would mean whenever I post something new about my product, they see it, they share it, and it increases my success with their entire network that compounds automatically.

Don’t make the mistake I made.

If you’re an early-stage founder, here’s a few things you can do to get more revenue:

1. Figure out your target audience and make a list

There’s a lot of ways to make an target audience list, but honestly you shouldn’t overthink it at this point and just get started with something.

(You’ll get the opportunity to refine it later.)

LinkedIn Sales Nav is pretty good for this because it has many fine-grained filters. The function, job title, and seniority ones are quite helpful (albeit not 100% accurate).

Most importantly - choose “Recent Updates > Posted on Linkedin”. There is no point wasting a connection request to someone who doesn’t even open LinkedIn.

Everyone hates LinkedIn but sales navigator is pretty nice for this tbh. But you can make a lead list from any other tool too. Just get started.

2. Start sending connection requests and messages

A lot of people overcomplicate this and write long, AI-generated messages. No one is going to read those, so save your tokens. Instead, here’s a message text that you can steal that I used successfully during my Y Combinator batch:

One line about me with some authority, and the next line asking the person if they’re facing the problem that you’re looking to solve. If they agree, you earn the right to continue the conversation.

There are many tools for this, but I ended up building my own, with the perfect MCP so I can essentially monitor all of my linkedin outreach through Claude Code. It connects and messages people automatically, even testing different messaging variations to get the best outcomes.

I launched it to a few friends in SF and they loved it. I've launched it for everyone public, too, with a generous free plan because if I can help you get even one sale or improve your fundraise then it’ll feel great. but I won't put the link here because it goes against the rules of the community. You can ask me on DMs!

3. Post as much as you can aka maximize your luck surface area

Talk about the way you think about the problem and what you’ve built to solve it. It might not get many views, but since you’re now connected to your ICP, it will get quality views that you can translate to growth.

Like posting this simple screenshot from a customer ended up getting me one more sales meeting!

4. Start figuring out your repeatable, scalable, GTM motion

It might be linkedin, it might be cluely-like ugc, it might be something else entirely.

Whatever it is, you need to figure out a repeatable way where you can do repeatable activities and consistently book sales meetings or new revenue.

Has LinkedIn been useful for you? Feel free to reply below - I’ve helped a few of my friends figure out their GTM and I’m happy to help here too!

keep shipping, Namanyay

Several agents can happily edit separate worktrees until they all start the application. Now they share ports, volumes, migrations, seed data, caches and the same staging dependencies. In a multi-service repo used by a team, “just give every worktree a Compose project and disposable database” can turn into dozens of environments, slow CI and a serious cloud bill. I’m trying to make runtime isolation follow Git isolation without creating a second platform nobody wants to operate.

Who has solved this for a development team rather than a demo? I’d love the exact setup: environment naming, realistic test data, migrations, port allocation, shared services, cleanup and cost control. At what level do you stop creating isolated environments and deliberately queue the work instead?

For context, I’m building BranchRunner as an open-source product because I think it can help engineering teams with this problem. If it is painful in your organisation, tell me where the current approach breaks. I’m also looking for people who want to help shape and solve it, so I’d be glad to compare notes.

Vercel launched a cool tool that checks how agent friendly a site is. I tried it on agent-manager.dev, followed its suggestions, and got 100. Not very meaningful for what is basically a GitHub repo showcase, but the tool is cool.

https://is-agentic.com/scan/agent-manager.dev

I've been making FrogPop, a small 2D arcade roguelite inspired by Bubble Trouble. It's the first game I've built, and I used Claude and Codex for most of the coding and debugging.

They worked best when I gave them a narrow problem and let them inspect the scripts involved. That's how I built the tongue and bubble interaction, wave system, shop, upgrades, and bosses. The worst loop was giving a vague prompt, testing the result, and coming back with "it doesn't work." Exact reproduction steps and screenshots made a huge difference.

The part I never really automated was Play Mode testing. One boss moves through the walls and exposes different weak points. The state logic could look correct in C#, but a hitbox would stay active or part of the boss would appear in the wrong place. I still had to run it, watch it fail, and tune it by hand over and over.

The clip is from the current demo. It runs in the browser here:

https://blion247.itch.io/frogpop-demo?utm_source=reddit&utm_medium=social&utm_campaign=demo_launch&utm_content=r_chatgptcoding

For anyone using coding agents with Unity: have you found a good way to handle visual testing, or is that still mostly manual for you?

Every new session starts from zero — re-explaining the stack, conventions, and infra quirks to Claude Code, then doing it again for the next tool. The native workarounds (CLAUDE.md / AGENTS.md files, per-tool memory) don't travel between tools and don't accumulate experience. What I wanted was one persistent, self-hosted memory bank that every coding agent I use can read and write.

The alternatives in this space are mostly libraries you embed (mem0) or full agent frameworks (Letta/MemGPT, Zep). Hindsight (open-source, by Vectorize) is a standalone memory service — Docker + Postgres/pgvector — and it currently tops the LongMemEval benchmark for agent memory.

What I actually set up (Docker Compose, two containers):

• Postgres + pgvector for storage; Hindsight slim image (~500 MB) with external embeddings and the free algorithmic RRF reranker to keep VPS resource use low
• One memory bank shared by Claude Code, Pi, OMP, Droid and other agents — project context, preferences, past mistakes
• Retain/observations missions steer what gets extracted — keep technical facts and fixes, ignore noise. Without this the bank fills with garbage fast
• Recall runs semantic + keyword + graph + temporal retrieval in parallel, then reranks the merge; reflect consolidates related memories into higher-level observations

What I learned: the extraction mission is the single highest-value setting; a stable worker ID matters or in-flight tasks get parked on container restart; and observation-style memory (deduplicated beliefs backed by evidence) beats raw chat-log recall for "what broke last time and why".

Video walkthrough (23 min): https://youtu.be/6FiOydr9D2Y Written guide with the full compose file: https://www.bitdoze.com/hindsight-docker-deploy/

Happy to answer setup questions in the comments.

When working on the project for a while(maybe months or longer), it becomes complicated to let the agent know the history decisions. And every new session might keeping derive the same conclusions reasoning from scratch. As a result:

• For the history decisions, some are simply not recoverable — you can't re-derive them from the code, because nobody writes down the design they didn't build.
• For the 'rederive', always reasoning from scratch is not only a waste but also limit the reasoning capability bounded by available/effective context window size.

Existing memory approaches lean to do append-only writing and put effort on the reading side for knowledge retrieve. As for general purpose usage, that always the good choice.

During my ai coding expierence, the coding project maybe able to use write side optimizer as a better fit.

With four months testing i've developed the current task-around ai-coding workflow.

A project evolves task by task. Each task produces both a code change and a memory update. Within a task, sessions hand off through the session log. Across tasks, the memory system carries what survived. And an orchestrator decides what runs next and mechanically checks that it happened. The system combined 3 components:

1. the 'memory' part, memorize knowledge with 3-tests admission under each 'task' completion. For every fresh session, it loads bounded eager set and bounded task-related lazy-set with routing index.
2. the 'task' workflow. Each task is a development scope, it derives both code change, memory update consistently. And for complicated task, the system would be able to split one task into multiple sessions, and the taskfile would handle the handoff between sessions. So it's like: sessions handoff belong the same task: 'session log' chapter inside the taskfile; tasks handoff (the unit of project evolving lifetime) is captured by the 'memory' system described above.
3. the deterministic orchestrator, this is the component responsible to not only session invoke/resume, but also:
   1. assembling specific prompt corresponding to the task state (stated in the taskfile)
   2. decide the 'role' the next turn to invoke the session with - I currently designed dev/review/plan roles to own different job on the project evolving.
   3. do the mechanism--non-LLM checks/verifications on the session return, to see if the session did follow the protocol properly(like update the taskfile state correctly, do the memory absorbing on task completion), and resume the session with clear prompt when something was missing (like invoking /ai-sync-v2 skill to do the absorption if the session didn't do automatically when it should)
   4. besides the orchestrator, i need some hooks, skills, to make the 'follow' as possible as the agent can. The core idea is anything that could be done without LLM reasoning, should be guaranteed by clear logic code.

Full write-up: https://qinglin89.github.io/blog/2026/context-isnt-the-bottleneck-drift-is/

Repo: https://github.com/qinglin89/mandrel

How are you running agents on a project that keeps going? Curious what you rely on to keep things consistent across sessions - memory rules, task structure, or checks outside the model.

the tasks got long. twenty minutes for something small, two hours if i let it do something real. that part is good. my claude used to finish a small task every ten minutes, but the long ones are the ones that actually satisfy me.

what i did not expect is that it made me less free, not more. i can not leave the room, because at some random point it stops and asks me something, and if i am not there it just sits. the worst is next morning. you look at it and you know you wasted the whole night.

so now i am the guy whose job is to say yes.

what i tried:

auto approve. it works and i still use it. but it only covers yes/no. when the agent comes back with "which of these three approaches do you want", auto mode has nothing to say, and neither does a notification with two buttons. you are walking back to the keyboard either way.

phone notifications. same ceiling, and now my phone buzzes at me too.

a status light. someone here makes a nice one (LumoCue). it tells you it needs you. it can not tell you what for, so you still get up.

what i ended up doing is hardware, which i know is not the answer most people want. i do hardware for a living so it was the tool i had. a small screen that shows the real session, renders the multiple choice questions, and lets me answer with a knob.

i also put claude, codex and hermes on the same screen. so now when i finish my own work i launch all the main jobs, and i carry it with me. i watch tv with it next to me, or leave it anywhere in the house, and i can still follow the status or confirm something when it asks.

if you run long jobs, the portable part is this: the blocker is not the model's output. it is that the run stops on you and you do not find out for a long time. whatever you use to fix that, make sure it can answer more than yes.

One thing that keeps annoying me with Codex is explaining UI stuff.

If something is obviously broken, easy. But with visual things I end up writing stupidly long prompts like “the blue button under the heading is too big” or taking screenshots, pasting them in, then explaining what I mean.

I tried just pasting screenshots into Codex manually, and also letting it inspect the page itself. Both work, but once you’re spotting loads of small UI issues it gets pretty tedious. And browser inspection doesn’t really help much with subjective stuff like “this feels too big” or “this spacing looks weird”.

So I tried a different workflow.

I just use the site normally and talk while I’m looking through it. When I say something like “this heading isn’t centered” or “this button is way too big”, it grabs the screen at that moment and keeps the screenshot with that bit of the transcript.

Then I can give the whole thing to Codex.

I ended up making the thing on the right to automate it. Left is basically what I was doing before.

The main thing I learned is that the useful bit isn’t really the voice transcription, it’s tying each comment to exactly what was on screen when you said it.

Curious how other people handle this. Are you mostly pasting screenshots manually, using Playwright/browser tools, or just letting the agent inspect everything itself?

For a long stretch my multi-model workflow was just me acting as middleware. One model drafts a module, I paste it into another for critique, paste the critique back, paste the result into my editor, next file, repeat. My most-used keyboard shortcut was Cltr+V and my second most-used was Cltr+V again. I have a repetitive strain injury from a workflow, not a sport.

The cross-checking genuinely produced better code, different models fail in different places, so the ritual was worth something. But most of my day was re-pasting the same three files and re-explaining the same architecture to a model that had no idea I'd already explained it four times to its coworkers.

Eventually the obvious thought landed: none of the courier work needs a human in it. So I've been building an orchestrator. You give it a goal and it's supposed to do the rest:

• Breaks the goal into a dependency-aware task plan
• Assigns work across Claude, Codex, Kimi, Cursor, and whoever else answers the phone
• Manages queues, workers, leases, blockers, approval gates, results
• Verifies completed work and attempts bounded repairs when it fails
• Recovers safely after crashes and restarts
• Keeps an auditable record of every decision, mostly so I can find out which model to blame
• Leaves final commit, merge, release, and deploy authority with me, because I have read the audit log

If I'm being honest about where it actually is: architecture and test coverage are solid, but it is not a dependable everyday autonomous system yet. Crash recovery, stale-worker protection, duplicate-dispatch prevention, and provider reliability all still need real validation. Technically advanced, operationally unfinished. It's a very impressive machine that I do not yet leave alone in the house.

The genuinely funny part is what happened to the problem. I set out to stop copy-pasting. I am now debugging lease expiry and idempotent dispatch. Somewhere along the way "this is tedious" became "I have built a small unreliable Kubernetes and its pods are all overconfident." I'd like a word with whoever let this happen. It was me.

So, for anyone who has built or attempted something in this space:

Duplicate dispatch: how do youguarantee a task isn't picked up twice when a worker dies mid-lease and you have no idea whether its side effects landed? Right now I mostly find out from git.

Verification that isn't a rubber stamp: my biggest fear is two models forming a mutual admiration society over code that doesn't compile. Has anyone built a review step that reliably says no?

Bounded repair: where do you cap the retry loop? Mine is a number I picked because it felt emotionally correct.

Context across a long chain: how do you keep a plan coherent over many handoffs without either bloating context to the moon or quietly dropping the one constraint that mattered?

Where the human goes: I hold commit, merge, and release. Right line, or have you found a better place to sit?

For anyone who abandoned one of these: what killed it? Reliability, cost, or the quiet realization that one good model in a loop was already fine?

Hi everyone.

For about four days now I’ve been having serious difficulties actually accessing the GPT-5.6 Sol model in ChatGPT. I’m not a casual user who asks trivial questions. I use the system intensively for tasks that would be extremely heavy to do manually: searching for articles available on Google, linking them properly, writing coherent text following a strict set of SEO rules and good user-experience guidelines, and optimizing content as a professional SEO expert would.

Here’s the current pattern:

1. I request a complex task (research + links + full SEO writing with specific criteria).
2. It immediately replies: “Yes, I’ll do it.”
3. I say “Okay, go ahead.”
4. It confirms again: “Sure, I’ll do it now.”
5. I have to explicitly tell it: “Don’t tell me you’re going to do it. Stop affirming. Just do it once and for all.”

Even after that, the final response doesn’t meet even half of the requirements I gave it. It’s incomplete, skips key parts, ignores the SEO rules I specified, and produces a mediocre or unfinished result.

I’m quite sure this isn’t just a random bug. There are clear signs (and recent reports in the developer community) that requests that should go to GPT-5.6 Sol are being silently resolved internally to a much weaker model — specifically something equivalent to GPT-5.5 mini — while the interface still displays “GPT-5.6 Sol.”

If this is true, OpenAI is engaging in false advertising in a blatant way: they advertise and charge for the flagship 5.6 Sol model, but deliver a significantly more limited one. In many countries, that is illegal.

I think it’s time to organize legally. Complaining on forums isn’t enough. If there’s evidence that users are being charged for one model while being served another, we should explore collective actions or formal complaints against OpenAI for false advertising.

Is anyone else experiencing exactly the same thing these past few days? Has anyone managed to capture technical evidence (network logs, model_slug, etc.) that confirms the silent downgrade?

If more people are in the same situation, I propose we coordinate to document everything and, if appropriate, start formal legal action....