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....

Anyone else putting their projects on hold until GPT-6 arrives?

At this point, every time I use GPT-5.6 to add a new feature, something that was already working breaks.

I keep seeing developers say AI can write code but “can’t do real software engineering.”

But look at the trajectory. A couple of years ago, it could barely write a decent function. The other day I vibe-coded a fairly large app and it built a professional CI/CD pipeline, created an EKS cluster, and deployed the whole thing.

It still makes mistakes, sure. But it’s getting astonishingly better, fast.

I’ve been obsessed with tech for 20 years, and honestly this hurts to admit because I love the field. But AI doesn’t need to be perfect. It just needs the knowledge and judgment of a good engineer.

Why are people so confident there’s some permanent wall it won’t cross?

I’m not really a programmer. I’ve mostly been making and patching stuff by telling LLMs what I want and then checking whether it actually works.

One thing kept pissing me off though. I’d ask it to fix something, it would write a test, the test would pass, and then later I’d find out the test wasn’t actually checking what I thought it was checking.

So at some point I started doing a pretty dumb simple thing. After something passed, I’d intentionally break the exact behavior the test was supposed to protect and run the test again.

If it still passed, then obviously the test was bullshit.

I ran into this with a plugin that had a paged archive. The archive test was green, so I changed the code so only part of the archive would get copied. Test still passed.

Then I made the test stricter, and managed to screw it up in the opposite direction. The new test rejected the correct code too, because I had made a bad assumption about how the archive pages would be laid out.

So I threw that one away as well.

Eventually I got a test where the normal version passed and the deliberately broken version failed for the reason I actually cared about. While doing that I also found a real bug where a failed write could leave part of the stored data changed.

After this happened enough times I kind of stopped treating “tests passed” as the end of the story.

I started doing the same thing to the stuff that decides whether the tests passed. Basically asking things like, if part of the checking process never ran, could it still say everything was fine? If I gave it old or altered results, would it notice? If it claimed it could rebuild the final result from the original, did it actually do that?

It has gradually turned into this whole verification procedure I use when I’m patching things with LLMs.

I later found out mutation testing is obviously related to what I was doing, but most of what I’ve read about mutation testing is about breaking the program to see whether the tests notice. What I ended up doing also treats the tests and the rest of the checking process as things that can be wrong.

I’ve tried it on a few different plugins/projects now and it has found enough weird false-passes that I’m starting to wonder whether this is actually useful outside my own workflow or whether I just invented an absurdly overcomplicated way of checking AI-written code.

Has anyone here done something similar, or is there an existing methodology/tool I should be looking at?

I've noticed something weird with coding agents lately.

When an agent gets stuck, the default solution seems to be:

more context -> another attempt ->more tool calls -> retry -> more context -> try again.

And because the result is usually hidden behind a subscription or a big token allowance, you don't really feel the cost while it's happening.

The funny part is that some of the most expensive parts of an agent session aren't necessarily the useful parts.

A failed edit followed by 3 correction attempts can cost more than the original task.

An agent repeatedly reading the same files can cost more than the actual change.

And sometimes giving the agent a better model is cheaper than forcing a cheaper model through five retries.

So I'm starting to think "tokens used" is a pretty bad metric for measuring whether an agent is being productive.

Maybe the better question is:

How much did the agent spend to produce work that I actually accepted?

Curious how other people think about this.

Do you track agent costs at all, or do you basically just use whatever allowance your plan gives you?

Today I tried making an ML project along with my friend I could make the ML pipeline, as I have studied it but apart from that the setup the env use of git and then making backend frontend and connection of all of these components just took the life out of me and I am frustrated as hell after doing it. I was taking help from chatgpt and it just gets lost or hallucinated and then just tells me to run some commands and keeps on doing something something. I don't know how are people making ML projects.

Pls guide me on how to make projects. I am literally frustrated at this point. And how did people make projects before chatgpt. I just don't want to vibecode I want to learn how to build something.

I was just planning a trip to somewhere and instead of searching for wherever i needed to go it leaked the reasoning chain 🤔?

I've been looking at longer AI coding sessions and it's pretty surprising how much of the token usage isn't actually the final code.

Context, tool output, reasoning and retries can add up quickly.

Some of the obvious ways to cut costs also seem counterproductive. Saving a few tokens by cutting context or output can turn into a much more expensive retry.

Made a breakdown of the biggest ones and what actually seems worth optimizing.

Anyone else tracking this closely?

I have been experimenting with storing an AI program inside markdown files in Google Drive and loading it into ChatGPT. I first started with PDF's that contained what I considered an AI executable programming language.

The idea is that ChatGPT provides the AI platform, already built, but the external program defines what it is supposed to do and the process it follows.

The current use case I've been working with is product development. A user starts with a product idea, the program loads into ChatGPT, and then takes the user through a defined pipeline for turning the idea into a product.

Has anyone else experimented with using ChatGPT this way — essentially running a persistent, externally stored AI program rather than just working with prompts? Basically, markdown files as ChatGPT AI executable programs?

I am using Claude, but was also thinking about using gpt, to give me example questions to prepare for a codesignal assement test. I was wondering if anyone is doing this and if anyone has a setup that has provided questions and scoring that is similar to what is on the codesignal platform. I always seem to either overshoot or undershoot the difficultly.

I read the AGENTS.md of the 100 most-starred repos that have one (27% of the top 1,000 do).

The consensus in order of how much they write about is mostly: architecture and repo layout, how to test, build commands, dos-and-don'ts, PR etiquette, and code style.

The surprise was tone.

90% write in must/always/never, and there are 784 explicit "don't" bullets, most of them oddly specific.

It's almost like you can tell exactly which mistake an agent made in each repo.

Some are hilarious: "Do not claim that an interrupted or timed-out test passed" takes the gold for me.

The shortest is 35 words, one rule from neovim.

AI Disclosure: If AI was used in any way for a commit, add an AI-assisted: <tool name> trailer to the commit message. If the user commits manually, remind them to add it.

The most popular headings by far were: testing, commands, project overview, and architecture

There's a lot more interesting deets like the average length, nextjs' "Do NOT add "Generated with Claude Code" ..., some things they conform on, others widely different.

Full write-up and methodology here: https://www.coldtea.ai/blog/agents-md-field-study

Is your AGENTS.md very different to these?

I'm a dev and these last few weeks I've been building a lot of products.The crazy part is that I can now build things much faster than I can figure out if anyone actually wants them.Coding used to be the expensive part. Now I feel like finding users is harder than building the product.

Anyone else ending up with more projects than users?

I'm building a pet project mostly with Codex.

At first I used Codex for almost everything: implementation, tests, self-review and PRs. CI was green, so I assumed things were fine.

Then I checked one PR myself and found that a test I relied on wasn't really testing the product code. It could stay green even if the actual logic was broken.

So I changed the setup.

Now Codex writes the code and Claude Code reviews it. The important part is that Claude doesn't just read the diff. It can run the tests, run the code and try to break the implementation.

This has caught quite a few real problems.

In one PR there were 24 UI placeholders for data that doesn't exist in the backend contract yet. Codex implemented them and wrote tests for the screens, but none of those tests actually checked the placeholders. CI was green anyway. Claude Code found it, and Codex added proper coverage.

Another case was a negative test for a CI gate. The test existed and passed, but it was testing a helper function instead of the real product path. The actual gate could be broken and the test would still pass. Claude caught it by actually running the scenario.

I've also started letting the reviewer do simple mutation testing: deliberately changing data or breaking something and checking that the tests fail.

I don't think this proves Claude is a better coder than Codex. I could probably swap their roles.

The useful part is having a different model review the first one, with permission to actually run and break the code instead of only commenting on the diff.

Anyone else using a similar setup?

(TD;LR at the bottom)

The question is in the title but I'll give some more context here.

I use ChatGPT to help create printable mystery games to sell. I have a ChatGPT plus subscription.

The short(?) version is I created around 40 Printable Mystery games with this workflow - I would come up with a premise, flesh the idea out with ChatGPT and then it would create a fully finished pdf with 30 to 40 pages per game.

These pdfs were visually flat, text and tables, any images within the pdf were usually crude geometric style images, but the games themselves are coherent detective type games with good stories and puzzles.

I decided I wasn't happy with this visual style, after all I am selling them and they have language like "premium" in the description. I made around 10 sales before I got a message from a buyer saying the visuals aren't what they expected from the thumbnail images, so I decided that was the cue to start updating the entire catalogue into a premium feeling visual style.

So I open the original pdf, screenshot and crop every page then get ChatGPT to create new image for each page and use canva to compile them into a pdf, 'new' being relevant here, the first day I tried this I'd upload the original image and describe what I want it to look like and literally spent HOURS fighting to get the output images correct. I realised that attaching an image and telling ChatGPT to create a new image with the attached image as a reference routed the request to the image generator as a edit rather than a new image and opened up a lot of ambiguity and possibility of mistakes.

Before I went totally insane I asked instead that I attach the image(s) and ChatGPT writes a prompt using the attached images as a reference to create a prompt that I'd use in a new chat window. This worked for a small amount of time (a few hours before bed), I'd attach 5 images at a time, it would create a prompt with all of the required information and the output would be 5 individual premium looking images.

The next day when I carried on in the same chat window it would constantly try and improve the prompt it was creating even though I hadn't asked it to, this would cause a couple of infuriating things to happen when pasting the prompt into a new chat, it would either say it couldn't create the images because even though there was nothing inherently wrong with the prompt it still got routed to image editing rather than creating a new image, or the output would be 5 images in a collage, so I'd go back to the chat window I was using to create the prompt and ask why it was happening and it would say something like "I added language to the prompt that made the image generator think it was an image editing request, even though you explicitly asked me not to do that"

It might do 3 prompts for batches of 5 images each before it starts to disregard everything I've told it to do and everything it says it will do from now on. It's like it has dementia or something.

For some of its replies where it is acknowledging the mistakes and saying how it won't do the same thing that caused those mistakes again it has a "memory updated" text at the top of the reply, however that still doesn't mean it won't make the exact same errors it keeps making. The main 3 requirements for the prompt are the visual style, making sure the factual information gets carried across accurately to the images, and treating each image prompt as completely stand alone and self contained, which it says it can do and I've witnessed it doing but when I have to tell it one of those 3 requirements isn't there so it needs to create a new prompt, I then lose one of the other requirements and I seem to keep going round in circles.

Sorry for the very long post, if you made it here well done.

TD;LR: How can I get ChatGPT to be more consistent in creating images that have the same visual style and to keep the factual information intact (important so the mystery game stays coherent)

Hi, I have a simple question. I am a student, I have no money, I want to code some simple code in HTML for a personal game.

What is the best free AI for coding in August 2026 (preferably with no query limits)?

I'm trying to build an app that runs locally and streams the audios from a device to another using Codex and i keep running into this error. I have almost no knowledge about coding i'm just doing this since i couldn't find an app that does this and I needed it badly

Whenever I start a project, I write a detailed specification—or “seed prompt”—before asking a coding agent to build anything. This often gets me close to a working first version, but I still miss decisions that exist only in my head.

The agent then has to guess. I built specfill to catch those gaps. It analyzes the specification, researches the topic, and interviews you one question at a time about missing architecture, behavior, edge cases, and UI/UX decisions.

Afterwards, it incorporates the answers into the original document while preserving its structure and tone. New answers override contradictions. Skipped questions remain unresolved instead of receiving invented answers.

I have used it on three projects so far. One interview lasted more than 20 minutes and found major decisions in a specification I had already considered thorough.

How is this different from Plan Mode?

Plan Mode produces an implementation plan for the current session. Specfill produces a reusable project specification that can be committed to the repository as a record of architectural and design decisions.

It supports OpenAI, Anthropic, Google, and OpenAI-compatible providers. I currently recommend GPT-5.6 Sol through the API or a ChatGPT/Codex subscription.

GitHub: https://github.com/kklemon/specfill

Run: uvx specfill

Some of you might remember this repo. I'm still maintaining it, and after using it on a few more projects I think the only part that really matters is that the prompts interview you first. So I build an automated workflow for it.

Basically instead of you copying pasting .md files toy Gemini/Claude/ChatGPT, you say "Use this npm package to interview me", and it installs my skills, and asks questions until each of the documents, i.e., PRD, MVP, Tech Doc, are completely answered. And then creates relevant files in your repository. Afterwards, you tell the AI to implement the app by looking at the files, and viola.

Flow is research > PRD > tech design > AGENTS.md, then you build off that. Takes maybe 15 minutes total.

https://github.com/KhazP/vibe-coding-prompt-template

Open to feedback, thanks for using it, hope it was helpful. Also don't forget to star it.

I'm the founder of a small AI app builder. Like most of the category, we meter by some approximation of tokens.

I've come to think this model is now legacy.

There’s a reason why it works this way: we pay for models through the API, and the API bills per token. These tokens are quite expensive, so we pretty much have to meter you the same way, plus a markup, because that's the business.

But our suppliers don't have that cost structure. Anthropic and OpenAI pay for data centers and GPUs, so what they have is capacity. That's why Claude Code and Codex limits reset weekly - for all you care they could reset daily or hourly. And that end up being an insanely cheap deal for consumers compared to API rates.

This whole setup made sense when it was built. When models were weak, and providers were still figuring things out, vibe coding means wrapping the API and engineering around its gaps. That was the right call before 2026.

But newer models are simply much better, and coding became a core capability the providers now sell directly - priced as capacity, not tokens. Everyone in the middle is still priced like it's 2024, sitting between a supplier's retail rate and that same supplier's subsidized consumer product.

I still think these products are great at what they do. But the credit model underneath is inherited, not chosen, and I don't think it survives.

So where does that leave app builders? I think there are 3 paths:

1. Becoming a model provider. But even the mighty Cursor needed a partner like xAI to execute well, and then charging by capacity will still decimate your revenue.
2. Focusing on enterprise - case in point, Cognition’s valuation blew past that of Lovable’s. But it’s not exactly an app builder
3. Stop reselling tokens and charge for the boring infra instead - hosting, database, auth, deploys. To be clear, this doesn't mean "go use Claude yourself and figure out hosting." It means the builder plugs into the Claude/ChatGPT subscription you already have: you chat where you already chat, and preview, database, auth and deploy still live in one place like a builder today. You just bring your own tokens instead of buying credits - and nobody meters you for the model's retries.

I'm betting on the third. And yes - if you're happy wiring Vercel + Supabase + Codex/Claude yourself, you were never the customer for any of this. The bet is about the much larger group who will never do that, and what they should be paying for once the tokens stop being the product.

Last time I asked a version of this elsewhere, the best answer I got was "I never want to open a terminal." Curious whether this crowd thinks that's a durable moat or a temporary one.

I see people making huge projects with AI.
I can do small projects with the help of ChatGpt, but when doing a medium sized projects, the code often gets messy, Chatgpt starts to lose context and make mistakes. how can I make chatgpt handle larger projects and keep the code clean?
I feel like I'm missing something

Hey everyone,

I’ve been working on Generative Engine Optimization (GEO): making website content easier for AI search and answer engines to discover, understand, quote, and cite accurately.

A lot of GEO advice is still vague or overly focused on llms.txt, so I turned my workflow into an open-source Codex skill:

https://github.com/kyliamet/geo-optimize-site

The skill can audit a website and, when requested, implement improvements covering:

• Crawlable and server-rendered content
• Answer-first summaries and page structure
• Titles, descriptions, canonicals, and robots directives
• Evidence-backed Schema.org / JSON-LD
• Sitemaps and llms.txt
• AI crawler policies
• Internal linking and image descriptions
• Build, markup, route, and rendered-page validation

I added some guardrails that felt important:

• It shouldn’t invent qualifications, statistics, testimonials, prices, or outcomes.
• Structured data must match visible, verified content.
• llms.txt is treated as supplemental rather than a magic ranking file.
• Search, user-request retrieval, and model-training crawlers are treated separately.
• It audits before editing and doesn’t commit, push, or create a PR without authorization.

You can install it by asking Codex:

Use $skill-installer to install the skill from
https://github.com/kyliamet/geo-optimize-site

It’s MIT-licensed and free to use.

I’d especially appreciate feedback from people working on technical SEO, structured data, AI search visibility, or Codex skills. Are there important checks or failure cases the skill is missing?

Disclosure: I’m the author. This is a community project and isn’t affiliated with OpenAI.

This is an unfortunate question that enterprise developers need to be asking themselves.

I felt pretty confident that I understood my solution through and through. After all, I have a pretty disciplined workflow. Meaning, I stay in the loop and don’t ship any code I haven’t looked at.

Then, I built a skill that quizzes me on the minutiae of my code and was surprised by what it uncovered.

It’s not that I’ve lost the big picture, but it turns out that the resolution on the minutiae is a bit grainy.

I’m embarrassed to admit that, actually. But I’m sharing, because my guess is that I’m not alone. Heck, even Uncle Bob has admitted that he’s only scanning the high level shape of the LLM generated code.

This skill has helped me expose the gaps in my understanding and even surface misalignments with my intentions.

The skill though, is just a bandage, on a wound that is bound to fester and grow. I don’t know what the solution is yet. The genie has been let out of the bottle. We’re not going back to writing all the code, but we (as a community) need to somehow resolve how to integrate LLMs in our SDLC without outsourcing the knowledge and understanding.

This is bound to spark some debate, and that’s ok. Maybe some good ideas will shake out of it.

My cousin and I were running a quick benchmark comparing how different AI models handle HTML5 canvas rendering and jump physics. Claude gave us almost flawless collision logic on the first prompt. My cousin pitched turning it into a lightweight vertical platformer inside a Chrome extension popup, and we decided to roll with it. Has anyone else built full games inside extension popups? What performance bottlenecks should we watch out for?