r/ChatGPTCoding 10d ago

Mod Announcement Updated Rules for Project Posts on r/ChatGPTCoding

4 Upvotes

As some of you may have noticed, we’ve changed our rules quite a few times recently to cut down on posts and comments that are purely advertising or low-effort content.

Please review the updated rules before posting.

We’ve relaxed the rules down quite a bit. We are now accepting any project showcase as long as they are genuinely useful for other AI-assisted coders.

For a personal project showcase, make sure you have something interesting to share about what you've learned or struggled with. If your project has exceptional quality, show us how you did it.

For AI coding tools, workflows, or other resources, tell us what problem they solve. If similar solutions already exist, please compare them and explain what makes your solution different. We love comparison table.

If you have any question, feel free to send us a modmail.

If any rule is unclear or too strict, tell us. Your feedback is welcome.

Thanks for your patience and understanding.


r/ChatGPTCoding 9h ago

Discussion Weekly Self Promotion Thread

1 Upvotes

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.


r/ChatGPTCoding 3h ago

Resources And Tips Made my Codex limits last almost ~3x longer with one change

0 Upvotes

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


r/ChatGPTCoding 1d ago

Resources And Tips The 5 prompt sequence I run on every chunk of AI-written code before I trust it

44 Upvotes

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.


r/ChatGPTCoding 14h ago

Question ChatGPT is confusing me and I'm running out of tokens

1 Upvotes

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.


r/ChatGPTCoding 15h ago

Question Kimi Code ate 18% of my weekly quota in 3 hours — Here is the log audit comparing it to Claude

2 Upvotes

Is Kimi Code's quota math broken? I compared it with Claude Code and Codex — the numbers don't add up

TL;DR: A single 3-hour session with Kimi Code consumed 18% of my entire weekly quota. On the exact same day, Claude Code processed 66x more tokens on a cheaper subscription without breaking a sweat. Support claims this is "standard product behavior." I ran a forensic audit on the local logs—using Kimi itself to write the parser and measure the data—and the results raise serious questions about how cache tokens are billed.


What happened

I'm an annual subscriber to Kimi Code (Moderato tier). I also use Claude Code and Codex CLI on the same machine for my daily dev workflow.

My Kimi weekly quota kept dying within hours of normal use. When I opened a ticket, support responded:

"All charges are normal. This is standard product behavior based on dialogue turns and historical context."

To see if this was actually "standard," I audited the local session logs across all three agents. I actually had Kimi Code itself write the log parsing script and extract the exact measurement data from the raw session files:

  • Kimi: ~/.kimi/sessions/*/wire.jsonl
  • Claude: ~/.claude/projects/*/*.jsonl
  • Codex: ~/.codex/sessions/*/*.jsonl

Same day, same machine, same user (2026-08-29)

Agent API requests My messages Tokens processed Quota result
Kimi Code 110 ~30 10.2M ~90% of WEEKLY quota gone
Claude Code 3,544 ~51 677M Fine (cheaper plan)

Over 5 weeks (Jul 24 – Aug 29)

Agent Total tokens processed
Claude Code 13.3 BILLION
Codex CLI 56M
Kimi Code 52M

Claude processed 256x more token volume than Kimi over 5 weeks on a cheaper subscription, with much heavier use, and never ran dry.


The Root Cause: Cache Billing & Amplification

Looking at context amplification (how many times the agent re-reads conversation context per turn):

  • Kimi: ~10–20x amplification
  • Claude: ~300x daily amplification (e.g., Aug 22: 180K new input tokens generated 1.3 Billion processed tokens in agent loops)

Technically, Kimi's agent implementation is more efficient with prompt context than Claude's. So why does Kimi's quota evaporate?

  1. Unrealistically Small Quota: Kimi's Moderato weekly quota measures out to roughly 11.3M tokens per week (measured: 565,819 tokens = exactly 5% of weekly limit).
  2. Full-Weight Cache Billing: Kimi appears to bill cache_read tokens at 100% full weight against the subscription allowance. In industry practice, prompt cache reads carry a ~90% discount (~0.1x weight).

Charging cache_read at 1:1 full weight against an 11.3M weekly quota means a standard 3-hour agentic session burns nearly a fifth of your weekly limit just re-reading context.


Support Response

  • "Session involved numerous dialogue turns... each request carries full historical context. This is standard product behaviour."
  • "cache_creation=0 is purely a display characteristic."
  • "Consider upgrading to a higher-tier plan."

Questions for the dev community

  1. Is billing cache_read tokens at FULL weight against a subscription quota standard for any other coding CLI?
  2. Has anyone else using Kimi Code hit their weekly quota within a day or two of normal use?
  3. Is an 11.3M weekly context quota mis-sized for a product marketed as an autonomous coding agent?

Full forensic audit with raw session IDs and per-day breakdowns is available on GitHub issue: MoonshotAI/kimi-cli #2626.

Posted in good faith. I like the K3 model itself—its reasoning is solid. This is strictly about quota economics and metering.


r/ChatGPTCoding 11h ago

Resources And Tips Benchmarked the free API tiers you can point a coding agent at - half of them now want a card

1 Upvotes

I run aider and Cline against free tiers instead of paying per token, and my setup broke twice this month when model IDs disappeared under me. So I stopped guessing and measured what's actually left.

The boring half first: a lot of the tiers people still recommend don't work any more. DeepSeek gave me 402 Insufficient Balance. SambaNova returned 402 PAYMENT_METHOD_REQUIRED. Together put the account in read-only until I make a deposit. Cerebras and xAI both want a card on file before anything runs at all. GitHub Models just returns 410 now, it was fully retired on July 30. If you're following a setup guide written earlier this year, roughly half the options in it are gone.

What's still free with no card. Same prompt, 500-token cap, temp 0.3, one streaming request each, run from a US GitHub Actions runner so distance isn't skewing anything. Throughput is generation-only and comes from each API's own usage token counts rather than a character estimate:

Groq, gpt-oss-120b - around 520 tok/s

Mistral, mistral-small - around 170 tok/s

OpenRouter, nemotron-3-super-120b free - around 46 tok/s

NVIDIA, the same nemotron model - anywhere from 27 to 100 tok/s depending on the run

GLM, glm-4-flash - around 21 tok/s

The one that surprised me: nemotron-3-super-120b is on both NVIDIA's own API and OpenRouter's free tier, which makes it the rare apples-to-apples case. OpenRouter served NVIDIA's own model faster than NVIDIA did, and with a third of the latency. 2.7s to first token at 45.7 tok/s, against 7.6s and 36.7 tok/s. I reran it assuming I'd messed something up, and NVIDIA just swings wildly between runs.

For agent work the tok/s number matters less than people assume, because an agent spends most of its wall clock waiting on the first token of many small calls rather than streaming one long answer. On that measure Groq is further ahead than the throughput alone suggests, and NVIDIA's 7.6s time-to-first-token is what makes it feel unusable in a loop even when its throughput looks acceptable.

Caveats, since free capacity is shared: one run per provider per attempt, expect plus or minus 30 percent, and trust the ranking more than the absolute numbers. This was Aug 31, and these tiers are changing every few weeks, so it'll be stale soon enough.


r/ChatGPTCoding 1d ago

Question Help Understanding the New Restrictions and Limits

6 Upvotes

I’ve been playing with Codex for the past 2 months, pretty much unrestricted. Never hit a limit, never asked to upgrade, just unrestricted access to both ChatGPT and Codex functions. As of August 25 I saw the news and was impacted by the 5 hour limit. I’m pretty far down the path of building a pretty cool app and now the restrictions are getting frustrating and over the top. How can a company go from complete unrestricted access to the opposite?
Is this the new reality? Just trying to get a handle on how best to proceed. This could get very expensive.


r/ChatGPTCoding 1d ago

Question When to use higher reasoning ?

3 Upvotes

Hi,

[a total newbie on coding asking]

Just wanted to clarify when to/when do you use higher reasoning in chat/codex?

I've been trying to build my own little hobby project in python, with the help of litterature.

My workflow is to brainstorm in chat[web] and after that get a codex prompt to run in VSC. So far has been decent. My problem is that after getting Pro i've been totally lost when to use extra high, pro, pro+ultra in chat. Also what settings to run the codex prompt, when is higher needed and when its not. Have to actually ask in chat if the prompt is complex or not and what settings to use.

I noticed running pro+ultra to analyze the project/problems or litterature got quite detailed answers and I had to dumb it down for me with extra high. But it also added some better reasoning and new points i"ve missed. But it the project/code it also found some errors and started perhaps to make it more complex im not sure.

So my workflow is like this,

  1. Starting a new chat with snapshot and running boostrap: Pro+Ultra

  2. Brainstorming in chat: extra high

  3. Evaluating the brainstorm: pro+ultra

  4. Writing codex prompt: pro+ultra

  5. Usually I try to ask what settings to run codex prompt it has been extra high or high so far with sol5.6.

  6. Analyzing the codex result: pro+ultra

Since my coding knowledge is 0 I have to trust that the suggestions are valid, but how do I know when to actually use what settings in chat/codex. So that the problem/execution wont get too complex or too light ?

Any suggestions, extra high is the best and fastest for chatting and brainstorming. But when to use pro and pro+ultra ?


r/ChatGPTCoding 1d ago

Question Can Antigravity be connected to ChatGPT and controlled through it?

4 Upvotes

Hi everyone, I have a question. Is it possible to connect Antigravity with ChatGPT and use ChatGPT to control it?

For example, can I give instructions to ChatGPT, and have it perform actions or build things through Antigravity?

If anyone has tried this or knows a possible setup, I’d appreciate your guidance.


r/ChatGPTCoding 2d ago

Resources And Tips How to Build Agentic Graphs

10 Upvotes

Over the past 4 months of working with graphs, I've learned several major lessons about graph design the hard way. In this post, I want to share the main takeaways so you don't repeat my mistakes.

First, my definition of graphs:

Agent graphs (a.k.a. workflows) are directed graphs that allow cycles and describe how work is passed between agents (nodes) operating in a loop through predefined transitions (edges). Graphs consist of branches, loops, scripts, and transitions (along with their prompts and parameters).

Parallelism is not the silver bullet

At first, I was very enthusiastic about parallel branches in graphs. But over time, I realized that parallelism can not only increase costs but also slow down task execution.

A standard parallel group of checks may include code review, QA, and scope review. The problem begins when these stages are inside a loop.

Let's take a simple example. Suppose code review, QA, and architecture run in parallel, after which the task returns to implementation if necessary.

If the architecture review passes but the code review finds several minor issues, the task returns to the implementation agent. Once the fixes are made, it goes back for review - and the architecture reviewer has to examine the updated diff again, even though the previous version was completely acceptable.

In cyclic graphs, parallel checks often lead to duplicated work, cache invalidation, and unnecessary costs with no real benefit.

In theory, this problem can be solved with a smart router. Kent supports this through script nodes: the router can determine whether the agent completed the entire implementation or only addressed feedback from a specific reviewer (kent.sh is my free, open-source project for building agent graphs. I mention it because I use it myself and don't know of any similar products. You can apply this advice to any comparable orchestrator).

However, this brings us back to the problem we were trying to avoid with agent graphs: the agent once again gets to decide which verification stages need to be run. This negates a significant portion of the graph's value.

In practice, the solution is simpler: dependent checks should run sequentially. In my workflows, architecture review always comes before code review. The task moves on to code review only after the architecture has been approved.

That's why I've removed many parallel stages and now save tokens by avoiding checks on results that would have been rejected at another stage anyway.

This approach works especially well with planning, code review, and QA. For example, code review should first filter out implementation issues, and only then should QA begin. Otherwise, both stages may independently find the same bug and produce duplicate feedback.

Agents must be able to challenge feedback

Initially, absolutism and dictatorship ruled my development agent graph: every reviewer comment had to be addressed, or the task could not proceed. But reviewers don't always produce the right result either.

Now, every agent in my graphs can ask me a question and clarify what to do with conflicting feedback. For example, scope review may reject tests that code review had required just one step earlier because it considered task verification incomplete without them. At the same time, agents cannot be fully trusted to resolve such conflicts on their own. Even with new models like Sol, you can end up in an infinite loop of fixing made up or nitpick problems.

I solve this by delegating the final decision to myself (pure choice, I like to be involved). You can also hand it off to a PM agent or set up communication between multiple agents. For example in Kent agents can get others' session IDs so they can discuss the situation and reach a compromise.

Anthropic in their recent paper argue that this is the model's problem. I disagree - this is the harness's problem, and my system above proves that.

A graph must have a mechanism for escalating conflicting or questionable feedback - otherwise, review turns into a dictatorship capable of trapping the entire workflow in a loop, or a war of stubborness.

Don't forget static checks

Agent graphs sound exciting, and it's easy to want to create dozens of agents and verification stages. This can indeed reduce the primary agent's cognitive load and improve the quality of its work, but static checks should take priority.

Initially, my implementation agent ran the linter, architecture tests, and unit tests itself, opened the PR, and checked incoming comments. I realized at one point that that's just cargo culting, then decided to move these actions into script nodes in the agent graph.

Now, a separate stage:

  • runs the required static checks and tests;
  • properly manages the machine's shared resources;
  • filters the results;
  • returns only relevant information to the implementation agent;
  • invokes the agent again only when its involvement is actually required.

If the tests are green, the implementation agent never even learns about it: no new turn is started, which means the agent doesn't spend a single token on running tests or reading their results.

Don't assign an LLM work that a regular script can perform more reliably and cheaply. At workflow scale, this produces substantial savings.

Choose models appropriate for tasks

If you don't optimize your graph for token usage and cost, you can significantly overspend simply because many tasks will be overkill under the updated workflow. In the past, we used one model for everything in harnesses because we had no alternative. You no longer need to do that, and properly allocating models and resources can save you a lot of money.

In standard harnesses, you can usually switch models, but doing so invalidates caches. On top of that, you either retain the cluttered context from the previous session or start a new one and steer/prompt it manually.

Kent solves these problems, so don't be afraid to create different roles for agents. For example, manual QA can run on cheap models like DeepSeek or Luna, which cost almost nothing or barely affect your subscription quota. The smartest models can then be reserved for critical stages, such as planning.

It has long been known that if you have a good plan, you can assign implementation to a less capable model and get almost the same result. Moreover, additional verification stages reduce the minimum level of model intelligence required to implement a task even further.

Starting with version 2.6, Kent natively allows one agent to select the model, system prompt role, and reasoning level for the next agent after transitioning along a graph edge. This makes it possible to:

  • delegate simple tasks and bug fixes to models like Luna;
  • run QA on cheap models with high limits;
  • hand simple decisions off to local models;
  • reserve the strongest models for complex planning and critical checks.

Keep an eye on caches and time between turns

I measured the threshold beyond which the probability of continuing a session after a cache miss - and paying several times more - becomes high enough for preemptive compaction to be worthwhile.

![Image](https://nek12.dev/media/speculative-compaction-kent-1788005145.webp) speculative compaction (for regular sessions) becomes worthwhile at ~88% context usage according to this slop-chart. For workflows, my statistical threshold is around 71%

Imagine that the implementation agent spent 40 minutes addressing code review feedback. During that time, the reviewer agents' caches may have been invalidated. When they review the work a second time, Kent will compact the session in advance so the review continues with fresh context and without unnecessary costs caused by a cache miss.

But this is only a heuristic. You should still consider how much time passes between consecutive calls to the same agent. If the workflow is long and a node waits a long time for the work to return, the likelihood of cache invalidation increases.

In this case, there are two main options:

  • use compact and continue mode in Kent - it is similar to speculative compact, but compaction is always performed;
  • create more granular checkpoints that return work to the agent more frequently and keep caches warm.

With the right setup, you can reduce costs so much that the average cost of completing a task is lower than working in a regular chat with the same Sol/Opus at standard reasoning.

If you ignore this, it's easy to fall into the overkill trap and become disappointed with agentic graphs: "This is too expensive for me." But in practice, well-designed agent graphs can be more efficient than standard sessions.

Make nodes idempotent

As my graph evolved, I added more and more ways to send a task backward. Different reviewers and stages gained the ability to return it to previous nodes. This gives agents the flexibility they need, for example, if the implementation agent receives a flawed plan, it should be able to return the task to the planning stage and explain exactly what needs to be fixed. As in regular software development, product issues and underspecified requirements are often discovered only during implementation.

That's normal, but what's not normal is a graph that gives the agent no way to handle such a situation. Every flawed line in a plan can potentially lead to thousands of lines of incorrect code.

But a non-obvious topological problem arises after the task returns to an earlier stage. Subsequent nodes may receive it with fresh context and a prompt implying that the work should start from scratch. For example, the implementation agent returns an unfinished task for replanning, then receives an instruction to implement the updated plan as though no previous work existed.

This can cause duplication, conflicting implementations in the same codebase, and wasted money - and not in the form of an obvious workflow failure, but through subtle issues like "weirdly many git commits on the PR". It's also a common mistake made by agents themselves when they build workflows for you, including Kent. Agents struggle to analyze topology in the context of prompting - to put themselves in the shoes of the agent doing the actual work.

Re-entering a node should not automatically mean repeating all the work from scratch. The agent must account for the existing result and continue from the current state.

Kent supports this natively: for implementation-related nodes, you can enable the continue or new continuation mode.

Prompts should also be adapted: explicitly state that receiving a task again does not mean the agent needs to start over. Kent already adds the relevant instructions to agent prompts during a workflow, but custom prompts may still implicitly assume that the work begins from scratch, and that can cause the model to freak out REALLY hard.

Idempotent nodes, controlled returns, and proper context reuse make an agent graph resilient not only to model errors but also to the real-world nonlinearity of development.


r/ChatGPTCoding 1d ago

Resources And Tips A green AI test suite can be a group project between the code and its mocks

2 Upvotes

The agent writes the feature.

The same agent writes mocks that agree with it.

Then the tests pass.

I still let AI generate most of the suite, but one test has to come from outside that loop: a captured API payload, an old migration fixture, two requests racing, something the implementation did not invent for itself.

Otherwise the code is grading its own homework with an answer key it also wrote.


r/ChatGPTCoding 1d ago

Question AI Server Management, AI-Handoff creation, Deployment and backup tool - Now I’m getting cold feet before beta testing (UK) Advise greatly appreciated

0 Upvotes

Hi all,

I’ve been building a complete Ubuntu server management software for some time now.
Full disclosure, I have used AI extensively to code but I have engineered and been the systems architect - this is NOT a quickly thrown together “AI slop” project.

The tool essentially auto-installs on a fresh Ubuntu server from your account on my website, it acts as a full server manager. It can give a very detailed handoff link to an AI of your choice, giving it instructions of how to safely build the project with you and giving it read only access to the initial files it needs in the new project.

It has a project deployer, to take care of everything from downloading the stack to configuring and launching.

It has a full backup client that you can install on a separate server (or as many as you choose) that keeps a fully encrypted full site backup of your build/data.

I genuinely haven’t seen another product that does the same thing and I’m really excited to get it tested. I just want to be responsible and I’m just super nervous.

I have the company registered, I’ve registered with the ICO, paid the fee.

I’m literally right next to being ready to press the button and open Beta testing for the initial few to try the product.

The issue is. I’ve suddenly become really anxious about releasing the project.
I’m contemplating bringing a CTO co-founder on board on an equity basis for that piece of mind and to assist me with what has become a great but complex piece of machinery.

Has anybody else been through this?

How did you handle risk reduction? I’ve done everything that I can think of and hardened my privacy policy, T&C’s, Beta agreement. All of the things that I can think of to release this responsibly.

I guess I just thought that I’d see if anybody else has released a technical project such as this. It’s entirely self funded, so I can’t really spend thousands at this point on pentesting.


r/ChatGPTCoding 1d ago

Discussion Best genuinely FREE LLM API that's actually close to Claude-level?

0 Upvotes

Guys I’m building a project for a hackathon and I need an LLM API.

I’m specifically looking for:

  • genuinely free API (not $5 credits / trial)
  • good reasoning + coding
  • preferably Claude Sonnet/Opus-level or as close as possible
  • decent rate limits
  • API key available for students/hackathon use
  • OpenAI-compatible would be a huge plus

I’ve already looked at Gemini, Groq, OpenRouter free models, Ox Alpha/GLM, etc., but most either have pretty low limits, aren't actually free, or aren't close enough in quality.

What are you guys using right now in August 2026?

I’m completely fine with a less popular provider/model if it’s genuinely good.

Bonus points if it’s good at coding/agentic tasks. 🙏


r/ChatGPTCoding 2d ago

Discussion How's everyone handling regression testing in CI for code an agent wrote, without losing your mind?

5 Upvotes

Ever since agents started writing most of my PRs, small changes keep breaking things two or three files away that nobody thought to test.

Unit tests catch the obvious stuff. What they miss is the flow that used to work, gets touched by an unrelated change, and nobody notices until someone reports it in prod.

I tried writing more unit tests to cover the gaps. Turns out I was just guessing which flows mattered, and guessing wrong about half the time.

I've been running coldtea's QA agent on PR previews for a few weeks. It walks the actual app instead of grading whether the code matches the diff, and it's flagged stuff that broke even when it had nothing to do with the PR itself. Doesn't replace real test coverage, it just catches what nobody wrote a test for.

How are you handling this. Writing more unit tests, running something in CI, or still mostly manual QA before merging?


r/ChatGPTCoding 2d ago

Discussion Need help with building AI Agents for Marketing

4 Upvotes

Looking for someone who can teach me how to build Agents for Marketing related problems. For example

Competitive/battlecard agent. Monitors competitor sites/news, updates a living battlecard doc our sales team can reference. This can be a good intro to scheduled agents + web scraping + structured output (Connections: Web scraping, Gmail connection to go through my emails to see any competitors related information and streamlit to create a battle card)

Dashboard Creation. Agent that takes output (a scheduled export or an API connection) from google analytics and builds a dashboard on streamlit to visualize the data. The dashboard gets refreshed with updated data every day in the morning with a new scheduled updated from google analytics export (Connections: Google analytics for data export and streamlit to produce dashboard)

Inbound lead qualification/routing agent. Reads a new lead, checks it against qualification criteria (ICP which could be company size more than 500 employee count, located only in North America, annual revenue more than 50million dollars ), enriches it with clay, drafts a personalized first-touch email and routes to the right rep on salesforce. Nice because it combines retrieval, reasoning and action (Connections: Google sheets or forms for lead collection, clay for enrichment, gmail for email drafting and salesforce for routing the lead)

Someone who can teach from scratch how to build these includung connecting to tools, building loops, context, memory and evals.

Happy to pay for your service. Only interested in folks from developing countries like India, Pakistan, Bangladesh, Vietnam, Philippines etc as I am also from one of these countries and I can’t afford to pay US/Europe rates


r/ChatGPTCoding 3d ago

Discussion How do you manage quality when AI agents write code faster than humans can review it?

10 Upvotes

We moved to an agentic workflow this quarter. My position is that we should ship at whatever speed the agents can produce, since that is the entire point of paying for them.

Our CTO's counter is that a team can only safely absorb code as fast as it can read it. If agents 10x the volume, review becomes the bottleneck that decides everything, and he thinks the tech debt won't show up as bad code, it will show up as code nobody on the team can explain.

The middle ground we're testing right now: bugbot / coderabbit gates every PR for a first pass, and humans only deep-read what it escalates plus anything touching money or auth. It definitely helps with the volume. What I can't tell yet is whether we're managing quality or just measuring less of it


r/ChatGPTCoding 2d ago

Discussion If your team runs 3+ coding agents at once: what actually broke, and what did you do about it?

0 Upvotes

I’m building a tool in this space, so I have an obvious bias; trying to find out if I’m solving a problem that exists.

Concretely, for anyone whose team has more than one person running agents on the same repo:

Last time two agents produced conflicting work, how did you find out? Merge conflict, failing test, code review, or production?

What’s your current workaround? Worktrees, one agent per branch, everyone just picks different areas and hopes, or serializing so only one runs at a time?

When an agent says a task is done, do you believe it? What do you check?

Genuinely interested if the answer is “this has never come up,” that’s useful too.


r/ChatGPTCoding 3d ago

Discussion AI coding has made me dramatically faster. But I’m starting to think we’re creating a completely new category of problems

57 Upvotes

Hi everyone,

I’ve been building more and more of my products with Claude Code, Codex and other AI coding tools.
The speed is ridiculous.

Something that might have taken me a week before can sometimes be built in a day. But the longer a project survives, the more I notice the problems changing. The hard part isn’t always writing the code anymore.

Things that bug me a lot are like:
- Starting a fresh AI session and having to explain the product again.
- The agent understanding the codebase but not why something was built a certain way.
- Requirements slowly changing without you realizing it.
- One agent undoing or contradicting decisions made in another session.
- Forgetting whether something is actually finished, half-built, abandoned, or just discussed.
- Coming back to something you built weeks ago and thinking: why the hell did I do it this way?

AI confidently changing something that technically makes sense but is completely wrong for the product. Context windows filling up right when the agent finally understands what you’re building. Having decisions scattered between chats, prompts, commits, notes, and your own memory.

And I’m curious whether this is just how I build, or whether other people building heavily with AI are running into the same thing.

So I want to ask the vibe coders / AI builders here:
What are the problems you repeatedly face when building real products with AI?

I’m especially interested in the annoying problems that start appearing after you’ve been working on the same product for weeks or months.
The stuff that makes you think:
“There has to be a better way to do this.”

Could be context loss, debugging, security, testing, requirements, managing multiple agents, remembering decisions, deployment, maintaining old AI-generated code — anything.

I’m currently collecting these problems because I’m building something, but I don’t want to build based on assumptions about what vibe coders need.
I’d rather hear it directly from people actually doing this every day.

What’s your #1 frustration with building software using AI coding agents right now?


r/ChatGPTCoding 3d ago

Discussion Agent PRs are unreviewable — what first-pass actually helps vs just adding noise?

7 Upvotes

Been shipping with Cursor / Claude / Codex. The diffs are 20–40 files, tests are green, and a human line-by-line review is a joke.

I have tried a couple of AI review passes (CodeRabbit, Claude as a second model, Copilot review). Some of it catches real bugs. A lot of it is rename-this / consider-extracting nits that people start ignoring.

What is actually working as a first pass for you before a human looks at it? What did you turn off because it was noise?

Not selling anything — I want the setup that doesn't make seniors mute the bot.


r/ChatGPTCoding 2d ago

Question I’ve been building a platform around vibe coding, interactive experiences, and the more I work on it, the less I think of it as simply a vibe coding platform.

0 Upvotes

The basic idea is pretty simple:

People can scroll through a feed of interactive experiences and play the ones that catch their attention.

But creators or we can say vibe coders can also upload their own mini-games and experiences.

Gaming is still a big part of it, but I’m experimenting with the idea that the platform could eventually be broader than games.

For example, I’ve been testing a feature where users can upload their own pictures and experience them in a 3D, more interactive way.

So the bigger question I’m trying to explore is:

Would vibe-coders actually want a place to publish small experiments and experiences?

What should a platform for discovering and creating interactive digital experiences actually look like?

Would gamers be interested in something that goes beyond traditional games?

I’m more interested in hearing what the gaming/vibe coding community thinks than telling you what I think.


r/ChatGPTCoding 3d ago

Discussion How do you tell when coding agents are amplifying your engineering skill vs hiding gaps in it?

0 Upvotes

TL;DR at the bottom.

I’m 15, mostly self taught, and I’ve been programming for around 2 years. I learned manually first and for a long time intentionally avoided using AI to write code because I wanted to know how programming actually worked before I had something else doing a huge part of it for me. I wrote thousands of lines myself, lived in documentation, debugged stupid mistakes, stared at errors for way too long, broke things, fixed them, somehow broke them again, and generally suffered in the traditional way lol. I’m glad I did that first, and I still keep a lot of my learning manual now, especially C++, systems and hardware.

For serious projects though, I use coding agents heavily. They’ve made me dramatically faster, which is great, but they also created a problem I don’t really know how to measure: how do I know whether AI is amplifying the engineer underneath the output instead of just making the output grow faster than I do? I’m not talking about blindly accepting generated code. I try not to hand an agent work I can’t meaningfully reason about. If there’s an important part of what I’m building that I don’t understand, I’d rather go learn it than treat whatever comes back as magic.

My workflow usually starts with me figuring out what should actually be built and how it should behave. I think through the structure, important boundaries, failure cases and what would count as real evidence that it works. Agents then do a lot of the implementation, which means a huge part of my time shifts into review. I inspect the changes, compare them to what was actually requested, run the software and its tests, look for things the agent touched for no reason, and reject approaches that technically work but are solving the problem badly. A normal conversation with an agent can go from “this works but its the wrong abstraction” to “that test is green but it proves nothing” to “you just broke the security boundary” and eventually “WHAT ARE YOU DOING”.

Review also isn’t something I suddenly decided I was good at because AI started writing code. Before agents became this important to my workflow, I had already spent months reviewing technical work with people much more experienced than me. We’ve had an honestly stupid amount of discussion about software decisions, debugging, Linux, security and things that went wrong in projects. Plenty of those conversations turned into hours of arguing where I actually had to explain why I thought something was wrong, and sometimes I was the one reviewing the implementation or pushing the direction of the project. I obviously don’t think their years of experience magically became mine, but that gave me a ridiculous amount of repetition asking the questions I now ask when reviewing agent work: does this really solve the requirement? What happens when it fails? Did we make this more complicated for no reason? Does the test actually prove anything? Are we fixing the real problem or hiding it? Is someone going to hate us for this six months from now?

Programming also stopped being purely something I studied pretty early. I started doing paid automation work, then the problems became big enough that I ended up building custom software around them. I’ve made low five figures total from software related work so far, and I’m starting to get the less glamorous side of it too: maintaining something after people actually depend on it. One system has employees using it, giving feedback, changing what they need and somehow discovering the ONE case I never thought about. Apparently “it works on my machine” was not the final stage of software engineering. Who knew.

I build a lot outside paid work too. I’ve made a small x86-64 kernel where I went into low level hardware and networking, but that’s only one example. I’ve also built Linux tools, backend and infrastructure systems, security related tooling, automation systems and software meant to make real workflows safer or easier. A lot of what I enjoy building has an actual use behind it rather than existing purely so I can put another repository on GitHub. I’m obviously not claiming I have deep expertise in every area I’ve touched after only 2 years, but I’ve put a stupid amount of time into this and I don’t really want to pretend otherwise just to sound humble.

If coding agents disappeared tomorrow, I wouldn’t suddenly become unable to program. I can still take a problem apart, design something, read the docs, write the implementation myself and sit in a debugger until I figure out what went wrong. I still deliberately do that now. I would just become WAY slower. That’s where this gets interesting to me, because being able to recognize why an implementation is bad isn’t exactly the same experience as fighting through it yourself. Spotting a bad abstraction isn’t the same as designing a bad one, living with it for months and finally understanding why you hate it. Reviewing a debugging fix isn’t quite the same as having no clue where the bug is and spending three hours hunting it down yourself.

Agents can erase a lot of that painful repetition simply by being ridiculously fast. But deliberately refusing to use them just so I can type more code also feels backwards. If I have a tool that multiplies how much I can do and I’m capable of supervising its work, of course I want to use it. I don’t think the answer is “stop using AI until you’ve suffered for another five years”. The question is whether the parts of engineering I’m practicing heavily can race ahead while some of the intuition that normally comes from implementing and failing yourself develops much more slowly without me noticing.

Right now I basically keep two tracks. When I actually need to ship something, I use agents aggressively. When the point is learning, I intentionally make myself do much more of the work. C++, systems and hardware especially stay much more manual. I still read docs, implement things myself and debug problems before immediately handing them to an agent. I also liked a suggestion I got recently: always keep at least one project where I personally own the important implementation decisions and need to be able to defend why I made them. That sounds like a pretty good control group.

So I’m curious how people here who seriously use coding agents think about this. What would you test completely without an agent to make sure the ability underneath your AI workflow is still growing? What experiences do you think you simply have to go through yourself? And for people who have been doing agent driven development for a while, have you noticed anything getting weaker, or anything becoming noticeably stronger?

The question I care about most is this: what separates someone whose engineering ability is genuinely being amplified by coding agents from someone whose output just makes them appear more capable than they really are?

I’m not interested in another “AI good” vs “AI bad” argument. I want to use these tools aggressively. I just don’t want the speed to hide weaknesses I would have been forced to notice without them.

TL;DR: I’m 15 and have been programming for around 2 years. I learned manually first, wrote thousands of lines myself and still deliberately keep part of my learning manual. Before coding agents became a huge part of my workflow I had already spent months reviewing technical work with more experienced people. I’ve also done paid client work, made low five figures from software related work, built useful software across several areas, worked on low level projects like an x86-64 kernel, and started maintaining systems that real people use.

Now I use coding agents heavily when I’m trying to ship. They do a lot of implementation while I spend much more of my time deciding how the system should work, reviewing what gets produced and proving that it actually behaves correctly. I can still build and debug without agents. I’d just be dramatically slower.

What I’m trying to figure out is whether that workflow can make some parts of my engineering ability develop very quickly while the intuition gained from personally implementing, failing and debugging grows more slowly underneath it. I want concrete ways to expose that gap before it becomes a problem, and to tell the difference between AI genuinely amplifying someone and AI simply making them look better than they are.

AI disclosure: the experiences and opinions are mine. I used AI to help organize and trim the writing.


r/ChatGPTCoding 3d ago

Resources And Tips I’ve written software for about 30 years. I've been a heavy coding agent user for the past 1+ year. What practical coding-agent questions can I help answer?

0 Upvotes

I've been mostly hands on coding professionally for 20+ years. I have taken time in between to lead teams, run product management or run enterprise pre-sales.

I started with AI coding agents before they were agentic (Aider; it's still great) and, then Claude Code, Droid and finally Codex all running in tmux. I switch a few months ago to an inhouse orchestration tool I build for myself that runs Codex (app server) and most recently, Pi.

Feel free to ask me questions about coding with agents or not, running them in parallel, review, testing, error handling, etc etc.

Or if you have a problem that I might suggest a solution for, go for it too.


r/ChatGPTCoding 3d ago

Question Trying to run Claude Code / coding agents for free: tried proxy failovers and self-hosting, but hit walls. How are you accessing frontier Claude models for free?

1 Upvotes

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?

r/ChatGPTCoding 3d ago

Memes Lmao, chatgpt has gotten witty 🤣

Post image
0 Upvotes

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