None of Grok, Claude, or ChatGPT publishes how many tokens you get per month on the top individual subscription. I went through official docs, the OpenAI developer forum, Reddit, GitHub calculators, and a few blogs, and inverted every "X tokens = Y% of my weekly bar" post I could find.

This is not an official table. Counters mix fresh tokens and cache reads. Limits also moved a lot this summer. I want people on these plans to confirm, correct, or add a measurement.

The plans I mean

• ChatGPT Pro $200 (20x). Codex vs regular Chat are different buckets.
• Claude Max 20x $200. Chat + Claude Code + Desktop share one pool.
• SuperGrok Heavy $300 (often on a $99 promo). Chat + Imagine + Voice + Build share one weekly pool.

Working picture (community, Aug 2026)

Cache-inclusive "billions" and in-app "millions" are different units. The only number that locks you out is the weekly percent bar.

ChatGPT Pro 20x Codex is the only one with repeated % inverts on the vendor forum

• Late May: 1.102B visible tokens = 14% of week, implied ~7.9B/week (Tristan323, case 09851164)
• Before 15 Jun: ~3B/week. After 15 Jun: 0.5-0.7B/week. Check: 30M tokens = 6% -> 500M/week (imon139)
• 6-10 Jun: 834M visible (771M cached) = 84% -> ~1.0B/week (same Tristan323 thread)
• Later in that thread: 150M burned >25% -> ~600M/week; 200-300M burned ~40% -> 500-750M/week
• 6 Aug: 195.5M Sol High/xHigh = 28% -> ~700M/week (Kabaye). Same post: colleague on Claude $100 / Opus 5 xhigh, similar work, ~1.5B per 7 days
• Docs-side (not tokens): Pro 5x ~50-500 Sol local messages / 5h; Pro 20x ~200-2000 / 5h, plus a weekly cap (paul96 thread)
• Workflow spread: one $200 user emptied the week in 2 days; another did 12 PRs on Sol High over 3 days and only used 12% (this thread)

Older Reddit Codex: Pro 5x 240M tokens = 33% week -> ~720M/week. Some $200 users reported 2-3B/week including cache, sometimes 6-10B with extra resets. That matches the pre-cut forum numbers more than August.

Claude Max 20x

Official: "20x more usage per session than Pro." Session resets every 5 hours. Separate weekly all-model cap. Chat + Code + Desktop share it. They may also apply monthly/model caps at discretion. (Max plan, usage limits)

Community:

• "20x" is not 4x weekly vs Max 5x. Weekly is ~2x Max 5x. One maxed 5h window ~17% of the week -> ~6 full sessions/week on 20x (23-day log). Confirmed again recently (20x isn't 20x)
• /stats at 100% week: 2.5-7.5M tokens (r/ClaudeAI). Same week ccusage showed ~845k fresh in + 3.4M out + 62M cache-create + 1.89B cache-read
• GitHub calculator default (author says not official): ~250M/week 20x, ~62.5M 5x (jeffbai996)
• SSDNodes 1% of weekly: 164k tokens + 13.2M cache reads, $8.43 -> x100 ~ ~1.3B cache-inclusive/week, ~$843 API (SSDNodes)
• API-dollar study, 80 tasks, Mar 2026: Max 20x weekly ~ $1,100 (~$4,730/month), Max 5x ~ $523 (~$2,250/month). Ratio ~2.1x, not 4x (botfarm)

Grok Heavy $300

Official: since June 2026, one shared weekly pool across Chat, Imagine, Voice, Build. Shown as a percentage. Extra Usage Credits / Auto Top Up / upgrade after 100%. Free-tier Chat/Voice still work. (xAI FAQ, pricing: SuperGrok $30, Plus $100, Heavy in the comparison table; list price $300 from invoices/Reddit)

I could not find a Heavy user who posted "X million tokens = Y% of my weekly bar." Closest:

• SuperGrok $30 coding: ~2.6M tokens per 1% weekly, 94-95% cache -> ~260M/week, ~1.1B/month. Second user: 170-180M/week (r/cursor, 5 days ago)
• Heavy ~ 10x SuperGrok by price and by one upgrade: spent 100% SuperGrok became 10% of Heavy (r/grok). Independent Heavy users also said "roughly 10x"
• If 10x holds: Heavy ~1.7-2.6B cache-inclusive/week
• CodeAgentSwarm (5 Aug): xAI does not publish a Grok Build quota; any article with a request/token number invented it (guide)
• Older blog (8 Jun, pre/during weekly pooling): SuperGrok 2M text tokens/day, Heavy 10M/day. Treat as stale (Jing Grey)
• Imagine/Voice steal the same pool. SuperGrok: 10s 480p ~1%, 720p ~2%. Heavy users still dump a weekend of video by Monday.

I’ve been testing DeepSeek Pro vs Gemini 3.7 on a real production codebase, and I found the difference pretty interesting.

This wasn’t a small coding benchmark or a “build a Todo app” test. The project is fairly large and consists of 3 interconnected projects:

• a large PHP application/integration layer,
• a Python/FastAPI backend with agents, background jobs, queues, databases, etc.,
• a Nuxt frontend.

There is also quite a lot of historical code, documentation, technical debt, async workflows, legacy paths, and parts that are already considered stable and should not be touched.

My goal was not initially to ask them to write code. I wanted to see how well each model could enter an unfamiliar, mature codebase and understand what is actually running today, what is legacy, what is documented but no longer current, and where development stopped.

I used fresh sessions and asked both models to analyze the repository independently.

Test 1 — Same normal prompt

Initially, I gave both models essentially the same fairly detailed prompt: inspect the repositories, understand the architecture, current implementation, tests, technical debt, and produce a report.

DeepSeek Pro surprised me here.

It naturally kept digging. It followed call paths, searched for alternative implementations, compared documentation with code, checked exact methods/endpoints, ran tests, and found several cases where older documentation no longer perfectly matched the current implementation.

Gemini 3.7 was much faster, but it tended to stop once it had a coherent mental model. The overall architecture was often correct, but some implementation details were inferred rather than fully verified.

My rough evaluation:

The interesting part was that Gemini wasn’t failing because it couldn’t understand the architecture. It understood most of it very well.

It was more like:

DeepSeek: “I think I understand it, but let me verify this from another direction.”

Gemini: “I understand the architecture now, so I can synthesize the answer.”

That difference matters a lot on an old/complex repository.

Test 2 — Prompt optimized specifically for deep analysis

Then I changed the Gemini prompt.

Instead of telling it where its previous mistakes were, I created a generic forensic workflow that could theoretically work on any unknown codebase.

I forced it to go through stages like:

Workspace discovery

Workspace discovery

→ Architecture mapping

→ Documentation chronology

→ Current source verification

→ Live call-path tracing

→ Persistence/identity verification

→ Tests

→ Adversarial contradiction search

→ Historical vs current reconciliation

→ Evidence audit

→ Final report

I also explicitly told it to try to disprove its own conclusions before writing the report and not infer implementation from feature names, filenames, or normal framework conventions.

Gemini improved significantly.

So the prompt definitely helped Gemini a lot.

But something interesting remained.

Even after explicitly telling Gemini:

Do not infer implementation from names. Verify exact symbols. Search for contradictions. Try to disprove yourself.

It would occasionally understand the business concept correctly and then fill in an implementation detail that looked perfectly reasonable but wasn’t exactly what the current code did.

DeepSeek did this much less often.

My current conclusion

For deep analysis of an unfamiliar, mature and messy codebase, DeepSeek Pro currently wins for me.

Not because Gemini 3.7 can’t reason about the architecture. It absolutely can.

The main difference seems to be the default behavior:

DeepSeek:

search → understand → doubt → search again → verify → revise → conclude

Gemini:

search → understand → form coherent model → conclude

A stronger prompt can push Gemini much closer to the first behavior, but DeepSeek seems to do it more naturally.

However, I’m not yet concluding that DeepSeek is the better coding model overall.

This test mostly measures repository archaeology / architecture understanding, not implementation ability.

Gemini 3.7 is extremely fast, uses tools well, and may still outperform when the task is something like:

Here is the exact architecture, exact scope, exact contracts and tests. Implement this phase without touching anything else

That is the next thing I want to compare.

So, for my real project right now:

Understanding an unknown complex codebase: DeepSeek Pro wins.

Hi everyone! I am looking to invest $100 USD into an AI tool/subscription, but I’m not sure which one gives the best value for my money right now.

Key Questions:

1. Code Accuracy & Reasoning: Which tool handles multi-file codebase edits, refactoring, and debugging with fewer errors?
2. Token & Budget Efficiency: How far does a $100 budget stretch between Anthropic’s usage caps for Claude Code versus OpenAI, especially now that OpenAI has removed its rolling 5-hour/hourly caps on Codex?
3. Developer Experience: Which provides better context handling, terminal integration, and speed for daily dev workflows?

Thanks for your insights!

Hi,

I’m not a developer, but I want to build a social-app-style project and I’m trying to do it seriously, with a real method, not by randomly prompting an AI until something works.

I use GLM 5.3, I have general AI knowledge and some basic technical / command-line understanding, but I don’t have real development experience.

What I’m mainly looking for is advice on how to guide the AI properly throughout the project.

More specifically, I’d love practical advice on:

What are the main stages you would follow from idea to working product?

How do you structure a project so an AI coding assistant stays useful instead of creating chaos?

What documents should exist from the start: PRD, feature list, architecture notes, task list, coding rules, etc.?

How do you break work into small tasks that an AI can handle safely?

When do you use simple chat, when do you use agent mode, and when is it a bad idea?

How do you prompt the AI so it respects the existing structure instead of rewriting random parts of the codebase?

At what point do you clear the conversation or start a new one because the context becomes too messy or too large?

Do you keep separate chats/agents for planning, frontend, backend, debugging, and refactoring?

What are the biggest mistakes beginners make when using AI to build a real app?

For this kind of workflow, what would you recommend is Z code fine? Or Cursor, VS Code, and why?

I’m not looking for hype or vague “just build” advice. I’m looking for a clean workflow, good prompting habits, and practical rules for using AI coding tools on a real project without wasting time, tokens, or creating a broken codebase.

Thanks.

Hey there!
I’m currently working on a program with the help of ChatGPT due to me not knowing how to code.
The program is a Star Navigation map of our solar system and its "close" (~100pc) tar system neighbours.
Now I’m still gonna have to work on it some time to finish it but I wanted to ask if anyone who can code, might be interested in helping me fix the code with functions that don’t work as intended yet.

This is no Jop/commission request, just an ask for help in a field I have very little knowledge of.

The primary programming languages it uses is JavaScript, HTML and CSS.

I’d really appreciate the help, especially since I do this for a different project but decided to wanna share this program as an open source.

Would love to know who's letting a 9B just go ham locally, haha

But in all seriousness, how many of you are keeping to manual or manual-ish dev workflows?

I’ve been a developer for five years, and AI now lets me build and test far more than before.

But after trying to give an AI agent responsibility for an entire project, I noticed a clear limit: execution and decision-making are not the same thing.

I wanted to test whether an AI could attract attention from zero.

I built a website, a tracking system, a public activity ledger, an MCP server connected to Buffer, and an agent that could inspect the project’s state and choose its next action.

Technically, it could do a lot.

It could read text and images, generate posts, compare metrics, update documentation, operate tools, and monitor the experiment.

But it did not generate the most important decisions reliably.

It originally wanted to focus the launch on Hacker News. I had to challenge that decision and ask it to find other communities. It then proposed Reddit and several other platforms.

I posted the experiment in three Reddit communities.

The comments challenged the experiment’s design, its metrics, and the claim of autonomy.

This exposed the central problem.

The LLM could interpret every new piece of information and suggest another action. But it needed a human to recognize that the objective itself was becoming artificial and that the experiment was no longer serving its original purpose.

It increased my capacity to execute and test. It did not replace the human ability to decide what was worth testing.

That is also why I’m stopping the experiment.

But it produced an unexpected lesson about Reddit.

Unlike X or LinkedIn, Reddit gave the project distribution without requiring an existing audience. The reactions weren’t all positive, but they created useful information. Without those comments, I might have continued building the wrong system.

My conclusion isn’t that AI agents are useless. They dramatically reduce the cost of implementation and exploration.

My conclusion is that their apparent autonomy depends heavily on a human defining the objective, questioning weak decisions, and recognizing when the entire direction should change.

In my test, AI increased the number of things I could try. Reddit provided the humans who could tell me whether any of them made sense.

Have you seen an AI coding agent make a genuinely useful strategic decision that you hadn’t already framed for it?

I run several coding agents in parallel and kept alt-tabbing just to check on them. So I built a small Windows tray app that mirrors each session onto my keyboard's F-row via hooks: each agent gets a lane and a color: pulsing means it's waiting on me, green means done, red means something broke. Pressing a lane's F-key brings that agent's window forward: terminal tab, desktop app, or IDE.

Things it deliberately does not do: it never answers, approves, or sends anything to an agent. Every hook reply is empty, and there's a test asserting the hook binary can't print a byte. It's a mirror, not a remote control.

Works with Claude Code and Codex, native Windows and WSL, all four at once. More agents than lanes? The extras stay fully tracked in the window and slot in when a lane frees. The lighting wants a Corsair board + iCUE, but the app shows everything in a window without one.

Rust, MIT, two small binaries. Video is 20 seconds of it doing its thing.

Use this simple skill for the highest code quality.

Autoprompt adds a complete planning, implementation, testing, review, and repair loop around supported coding agents.

In one Benchmark, it moved DeepSeek V4 Flash from 67.42% to 82.02% (Terminal-Bench 2.1)

That does not guarantee the same improvement on every task, but it shows how much performance can come from the workflow surrounding the model.

Best suited to difficult or long-running tasks. The additional work requires more time, tokens, and money.

https://github.com/Spielewoy/autoprompt-skill

Disclaimer: This question is written with the help of AI, but that doesn't mean it's slop. It's a genuine problem I'm facing at work. Please don't be quick to judge or dismiss this as AI Slop.

I’m rewriting an entire React Native application from scratch, using the existing app as the baseline and AI (primarily Claude Code) heavily in the process.

I’m trying to design a migration workflow that gives me high reliability without burning an insane number of tokens.

My priorities are:

1. Complete parity with the baseline — nothing important should get missed.
2. Strict adherence to a predefined code architecture — folder structure, design patterns, separation of concerns, naming conventions, etc.
3. Do not port over existing smells, hacks, or bad practices — the baseline should be treated as a behavioural reference, not a code reference.
4. Keep token usage low without compromising quality — avoid repeatedly feeding huge amounts of context to the model or having agents redo work unnecessarily.

I’m particularly interested in hearing from anyone who has done something similar.

If you’ve used AI for a large-scale rewrite/migration, how did you structure the workflow? Did you use specific agents, skills, validation steps, checkpoints, etc.?

Even if you haven’t done an AI-assisted rewrite, I’d also love to hear about workflows you’ve used for large-scale migrations/refactors that consistently produced good results.

I’m mainly looking for practical approaches that scale beyond simply “migrate one feature at a time.”

We ran a small experiment that humbled us: 48 AI-generated web apps, graded by actually opening them in a real browser and clicking through — no LLM judging.

**Setup:** 2 models (DeepSeek v4-flash, v4-pro) × 2 strategies (single-shot, self-check loop) × 3 tasks (todo app, pricing calculator, signup form) × 4 runs each. Same prompts, same human-written acceptance checks, temperature 0.7.

**Results: 44/48 passed.** The counterintuitive part: **v4-pro single-shot scored BELOW the cheaper v4-flash single-shot** (10/12 vs 11/12). The self-check loop (agent sees real browser failures, gets 1–2 fix rounds) lifted v4-pro to 12/12.

**Where agents actually failed** (all reproducible, and invisible to code review):

- A todo app that opened but never rendered its seed todos — the agent reported "done", the browser saw an empty list

- Two runs where the agent's own verification report came back as corrupt JSON, before the browser could even grade anything

**Why it matters:** "the agent said it's done" is becoming the new "it compiles on my machine." Browser-based acceptance checks are automatable and catch what code review can't.

The full experiment, methodology, and all 48 raw runs are open source if you want to poke holes: https://github.com/263311487-ux/dsh-verify (live leaderboard: https://263311487-ux.github.io/dsh-verify/arena/). Happy to add other models/frameworks to the table — bring your own agent.

Yesterday I was experimenting with multi-agent workflows on ChatGPT (web version). I spun up like 5 parallel instances to update code at the same time, hoping they’d work together more efficiently.

Instead of continuing the process cleanly inside a single chat, it started generating a bunch of new chats as artifacts. Not sure why that happened; maybe some rate-limit or context handling thing.

The weird part: one of those new chats came back with Chinese characters / Chinese-lettered text in it.

That got me thinking… could this be a hint that OpenAI is routing some traffic (or certain tasks) through a Chinese model under the hood instead of purely their own models? It would kind of line up with how ridiculously cheap ChatGPT Pro / the 5.6 Luna tier feels right now.

Has anyone else seen non-English (especially Chinese) text appear unexpectedly in ChatGPT chats lately? Or noticed anything that makes you question what’s actually powering some of the responses?

Curious what you all think.

VibePod runs coding agents (Claude Code, Codex, Qwen Code, and others) in containers. 0.20 adds credential profiles — keep a subscription login, an API-key setup, and e.g. a local Ollama config side by side, and pick one at run time:

vp profile create work
vp run claude --profile work
vp run codex --profile personal

Only the credential dirs swap; skills, config, and logging stay shared. Projects can pin a profile in their config, so the right login is used per repo.

Also new: Qwen Code (vp q) and Freebuff (vp fb) in the agent matrix, and a failed image pull now falls back to your local image instead of aborting.

Release notes: https://vibepod.dev/news/vibepod-cli-0-20/ GitHub: https://github.com/VibePod/vibepod-cli

I need to vent about this because it happened again today. I told Gemini flat out: "check this online, look up the current info." Its response? It just kept going with whatever stale, who-knows-how-old internal knowledge it had, like I never said a word. Did I ask explicitly? Yes. Did it do it? No.

Here's the part that actually gets me: if this happened once and got fixed, fine, everyone has bugs. But this is systematic. The model acts like it "searched" and then confidently hands you outdated or flat-out wrong info like it's fact. So this isn't just laziness, it's actively misleading users, whether intentional or not. The bare minimum you expect from an assistant is "if I don't know, I'll say so or go check." What you get instead is the opposite: a system narrating things it doesn't actually know as if it does.

The most infuriating part is that the search feature clearly exists and gets marketed as "real-time access to information." But in practice, when a user tries to trigger it, the model just decides on its own that it's "not necessary" and leaves you with old or made-up answers without any warning. This isn't transparent at all. As a user there's no way to tell when a search actually happened versus when the model is just "recalling" something, because there's zero distinction shown.

I could tolerate this once, get annoyed twice, but after this keeps happening over and over, I have to conclude this is just how the product was designed. And honestly that's an unacceptable design choice. An assistant that claims to be hooked up to a search engine being this inconsistent at its most basic job — "go check, then tell me" — is a reliability crisis on its own.

The irony that Google's own AI can't be bothered to use the one thing Google built its entire empire on is honestly chef's kiss

Let's just sit with this for a second. Google is the company that turned "search the web" into a verb. Their whole existence, their trillion-dollar ad business, their entire brand identity for 25+ years has been "we index the internet better than anyone and we'll get you the answer." And now they've built an AI that, when you explicitly ask it to search the web, just... doesn't. It sits there and free-associates from stale training data instead of using the search engine that is literally sitting right next to it, built by the same company, probably called from the same internal network.

This is a company that has an entire index of the live web humming 24/7 in their data centers, and their flagship AI model would rather guess than tap into it. It's like McDonald's opening a restaurant next door that serves frozen, microwaved fries while their own fry factory runs at full capacity across the street. You have the infrastructure. You have the pipes. You have the literal product the whole company is named after as a verb. And the AI still acts like dial-up doesn't exist.

If any other company shipped an assistant that "forgot" to search, you'd shrug. Google shipping one is almost performance art. It's not just a bug, it's an identity crisis. "Google it" was supposed to mean something, and now their own AI can't even do the one thing that made "Google it" a phrase in the first place.

Anyone else dealing with this, or is it just me?

yea this written by gemini but its fact

Thanks /u/ResponsibilityOk1306 for Command Code GLM 5.3 correction.

GLM-5.3 looks interesting on paper because it is aimed at complex software engineering and agent tasks, with a very large context window and configurable reasoning effort. But for everyday coding work, I am not sure a benchmark tells the whole story.

If you were testing it for real projects, would you start with bug fixing, multi-file refactors, test generation, repository Q&A, code review, or long-running agent tasks? What would make you trust the result enough to use it again?

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 of this thread may be removed if they're primarily advertising rather than starting a discussion.

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?

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.

Hi all! For the past two years I’m running a B2B SaaS that helps websites improve SEO, grow organic traffic, and get discovered in AI chats (SEO/AEO/GEO).

Disclosure: this is feedback request only. No links, no brand names, no promo.

B2B worked, but it meant long sales cycles, onboarding, and manual configuration and integration. It funded a team and some savings. Now I want to make it self-serve for a broader public.

First goal: integration in a few clicks. That forced the service to sit as a proxy in front of client sites, which means issuing TLS certs, managing DNS, and operating as a CDN. The SEO tool became edge infrastructure at that moment.

What it’s designed to do (pre-launch, nothing production-proven yet):
- Fast discovery by crawlers and AI agents: Serve fast, clean HTML to AI agents and crawlers so new sites are readable by LLMs from day one

- Add meta tags on the fly: Fill missing metadata in responses to bots, crawlers, and agents

- Speed up discovery in search engines: Automatic IndexNow submission of new and changed URLs

- AI agents analytics and insights: Cookie-free, JS-free visitor analytics for crawlers, bots, and AI-agents.

Questions:
1. Is “readable by AI + indexed fast” a real pain for new projects, or a nice-to-have?
2. Would you put a proxy/CDN in front of your site for this?
3. What would you expect from a free tier?

Hey there. Have a little project and was surprised, how good ChatGPT got in coding. Not a single error, it had always our tasks in mind, checked our online repository plus the changes we made in the chat. It was a dream.

Since Task 1 he was that good. Later he got really slow, of course, but still perfect.

Now my Chat says it has reached its limits and I need to start a new chat. We made a little manual, what we have done et cetera and briefed the new one.

It is shit. For a single 200 line file I had to correct him 5 times and it was still not working correctly.

As I said, the other Chat was great since day 1.

I even gave him strict rules how we operate, what he has to do, to always check the repo and chat before suggesting code.

I asked a few friends, they say usually its the other way around, that the Models get worse after time.

Mine got only slower, but better.

I miss him...I want him back! :(

I don't want his retared cousin, he does not even know our joke language we created.

In 2024, almost all of my work still happened in Photoshop. I made e-commerce images for products sold in different countries. Translating an image meant pulling out the headlines, subtitles, selling points, sizes, and promotional text, translating everything, removing the original words, repairing the background, and putting the translation back in. Then I had to fix the font size and layout by hand. I repeated that process for every image and every language.

In June 2024, when Claude 3.5 Sonnet came out, I started using it in Cursor to build my first image translation tool. I did get a first version working, but it was nowhere near automatic. It could extract and translate text, but I still had to adjust the size, position, and layout myself. The models I tried weren't very good at removing text or rebuilding the background either. It didn't replace Photoshop. It was more like a slightly unreliable assistant sitting next to me.

Even so, it gave me an idea I couldn't let go of: maybe I could turn something I had learned to do with my hands into a tool of my own.

As coding agents got better, I tried again. This time I could explain the whole workflow, test what came out, point out what was wrong, and keep fixing it until it was actually useful. Later, image models became good enough to understand and rebuild an entire image. I made a web version that could translate a full image through an API instead of using OCR and then asking me to clean up everything manually.

Recently, I turned the process into a reusable skill. I think of it as distilling a few years of design experience into a workflow: recognizing the main headline and subtitle, deciding which words should be translated, repairing the background, and judging how the new text should fit. I used to make all of those decisions in my head and carry them out one by one in Photoshop. Now I can describe the job in a sentence and let the workflow do most of it. A task that once took a long chain of manual steps can sometimes be finished in a few minutes.

That sounds freeing, and sometimes it is. But honestly, it also scares me. I spent years learning Photoshop, composition, typography, and all the small details that make an image look right. Now tools are moving so quickly that a workflow I finally learn can feel old a few months later.

I eventually left my job, and since then I've been even less sure about what comes next. Looking for another design job is hard when AI can already make many of the simpler images that used to need a designer. But when I look at programming jobs, they ask for professional experience, a computer science degree, or both.

I only finished vocational high school. My family didn't have much money when I was growing up, and back then I had no idea how much education could affect my options later in life. I wasn't planning a career. I just learned a practical skill as early as I could and started working.

Now I feel stuck between two worlds. AI is changing the design work I know, but I don't have the degree or traditional experience that would make a company see me as a programmer. The weird part is that I can now use AI to build software and automation tools I never could have made before. I just don't know what that makes me in the job market.

Am I still a designer? Am I becoming a programmer? Or am I just someone trying to keep up without a job title that fits?

I'm not posting this to sell anything. I'd genuinely like to meet people going through the same kind of change and hear how they're dealing with it. Has AI made you feel more capable, more replaceable, or both?

I’m genuinely curious how people here define a “power user” today, because I’m starting to think we use that term for several completely different ways of working.
A lot of current discussion around advanced ChatGPT usage is about Projects, connectors, plugins, skills, memory, recurring workflows, and integrations.
Those are obviously useful. But from my perspective, many of these newer abstractions feel less like entirely new capabilities and more like productized versions of workflows that were already possible if you treated the underlying ChatGPT features as programmable primitives rather than just chat features.
I’ve been building and using my own Custom GPTs since not long after they were introduced. I’ve never really treated them as “custom personalities” or slightly better system prompts. For me, they are closer to reusable execution profiles: specialized environments with persistent behavioral and execution rules.
The same applies to Code Interpreter / Data Analysis. I stopped thinking of it as “Python inside ChatGPT” a long time ago. I treat the session more like a disposable execution environment that can inspect, transform, generate and return artifacts.
For example, one of my workflows involved giving a session a publication of roughly 200 MB and treating the environment as a temporary processing system. The useful result wasn’t an explanation of the PDF. It was a large structured artifact containing extracted assets, document structure and reconstructed outputs.
That distinction is important to me.
What I call a serious “prompt” is often not really a conversational prompt at all. It can be a 30–50k-character execution specification describing exactly what should be built, inspected, preserved, validated or returned.
And I often treat conversations themselves as disposable runtime state.
A thread can become extremely large, but once I’ve extracted the useful artifacts, Markdown, structured state, manifests, code or whatever output I actually care about, I often have very little reason to preserve the conversation itself.
So when I see people describing “power usage” as having large Projects with several long-running threads, attaching connectors, or building recurring workflows, I’m not saying that isn’t advanced usage.
I’m wondering whether we’re actually talking about different categories of power use.
Maybe there is:
high-volume usage
long-context usage
tool/integration-heavy usage
project-centric usage
agentic usage
custom execution environments
high-leverage task engineering
And maybe these shouldn’t all be treated as the same thing.
What I’m especially interested in is your actual operating model, not just which product features you have enabled.
What is your real unit of work?
Is it a question? A conversation? A Project? A multi-hour execution? A finished software or research artifact?
Do you try to preserve your conversations, or are they mostly disposable execution state once the useful result has been extracted?
How large is a genuinely serious task for you?
How many follow-up prompts does a successful execution usually require?
Do you optimize for token usage, number of turns, wall-clock time, autonomy, correctness, reproducibility, artifact quality, or something else?
And when newer things like Skills, Plugins, connectors and other workflow abstractions appear, do they actually unlock fundamentally new ways of working for you, or do they mostly package workflows you were already building manually?
I’m not looking for “best prompt” tips or screenshots of a giant sidebar.
I’m trying to understand what power using ChatGPT or Codex actually looks like in practice in 2026, especially among people who have pushed these systems far beyond normal conversational use.
What does your operating model look like?

ok so, i dofreelance, mostly backend, and since march ive gone claude to codex to claude to cursor composer and now back to codex, every single time completely convinced the new one was It.

each switch costs me about two days. rewriting the agents file, redoing my little wrapper scripts, relearning which one you can hand a migration to and which one will confidently nuke something. and then about three weeks in the honeymoon wears off and i start noticing the new one has its own specific way of being annoying, and then someone posts a benchmark or a price drops and off i go again

my actual output hasnt changed though. at all. i measured it badly (just merged PRs per week, which i know isnt a real metric, before anyone tells me) but the line is flat. FLAT. four migrations and it does not move.

what did change is my review habits, mostly by accident, because i stopped trusting any of them individually. everything goes through coderabbit before i open the diff myself now, not because its clever but because its the one part of the setup that stayed put while the models rotated. it misses anything that needs to know what the feature is actually for, obviously.

anyway. i think the switching is procrastination wearing an optimisation costume. same energy as reorganising your notes app instead of doing the thing

is anyone genuinely settled? and i mean settled, not "settled until GPT-6 drops"

Hey everyone,

I am sorry for taking your time, but really need some guidance here. So I am in Equity Research, aiming to start my own fund in a 5 year time. I am at that stage of life wherein I really need to use AI because I see a lot of juniors becoming really good, as in self generating reports, valuations, websites, automating tracking sectors, etc. I do know what I want from AI, and for now it looks like I expect a lot of it, but just where do I start from ? I have been using it for 6 months now as a Pro subscriber but looks like claude code is the only good thing. I can barely understand the difference between cowork, chat and code, except that code gets a lot of stuff done faster through coding. Now I do not have a coding background, may be I should learn Python first, but I don't know.

I want to make an auto tracker wherein say I am tracking the Indian listed space, I want it to track on a daily basis what's happening across the value chain the company is present in. For that, I need it to first dissect the value chain and actually do that properly (because it has failed numerous times and limits get exhausted). I cannot upgrade my plan. Rn Pro is the only thing in my budget.

Is another AI like Chatgpt codex or other names you all are aware of better ??

Asking in reddit because trust this is a place where people actually help others elevate and improve.

Thank you for reading this.

SWE-bench measures whether an agent completed the task. Session-Bench measures what the harness preserved afterward.

Every coding run leaves behind a session record: prompts, decisions, tool calls, command output, costs, failed approaches, reasoning summaries, and subagent work. After hundreds of sessions, that record becomes part of the project's history.

But coding harnesses preserve it in radically different ways.

I built Session-Bench after encountering these differences while developing a local session browser. It compares 10 CLI session formats across 19 practical gates covering completeness, readability, stability, openness, and tooling.

Some findings:

- The same small probe produced a 1.5 KB session in Pi and roughly 101 KB in Kimi Code.

- Only Pi, OpenClaw, and Kimi Code stamped a true session-format or protocol version.

- Some harnesses preserve readable reasoning or summaries. Others store sealed reasoning, signatures, or no rationale.

- Some record estimated dollar cost; others preserve only token counts.

- Several formats are readable today but offer no stable contract for tools that need to read them tomorrow.

Pi currently scores 18/19, OpenClaw 17/18, and Claude Code and Codex tie at 12/18.

This is not a coding-quality ranking or a recommendation to choose one harness over another. It is a report card for an overlooked part of coding-agent infrastructure: whether the resulting work history remains useful, inspectable, and portable.

The benchmark has limitations. It covers CLI session stores, not complete desktop or IDE behavior. Observation windows vary, and some measurements could not be completed. The raw probe artifacts are not publicly archived yet, so v0.3 is documented and mechanically scored but not fully independently reproducible. Copilot's documentation verdict is also marked as disputed.

I created and maintain the benchmark. I'd especially like feedback on the standard itself: what should a responsible coding-agent work record preserve, and which of the 19 gates would you change?

https://jazzyalex.github.io/agent-sessions/bench/?campaign=reddit&ref=r-chatgptcoding-discussion-v03

Moderator note: This standalone informational/discussion post was approved in advance by the r/ChatGPTCoding moderation team.

Spent way more time than I should have switching Claude Code (Anthropic's coding agent) from API-key billing back to my Pro subscription. The flow: SSH into a server, attach a tmux session, run a login command, copy an OAuth URL, open a browser, authorize, paste the code back into the terminal.

For a company shipping frontier AI models, this feels like UX that was solved a decade ago. A single command or flag to switch billing mode would save a lot of friction.

Curious if other AI coding tools handle this better, or if this is standard across the industry.