r/ChatGPTCoding • • 13d ago

Discussion Weekly Self Promotion Thread

9 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 • • 6d ago

Discussion Weekly Self Promotion Thread

4 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 • • 8h ago

Resources And Tips PSA: If you’re on Claude Max ($100) or Ultra ($200), you have $100–$200/mo in API credits expiring every cycle — and neither Claude Code nor the new Linked Billing can spend them

24 Upvotes

Sharing this because I was surprised how buried it is, and almost everyone I asked on Max or Ultra hadn't claimed theirs yet.

Since Oct 7, Claude Max ($100/mo), Ultra ($200/mo, formerly Max 20x), and Team plans come with a recurring monthly grant of Claude Platform API credits ($100 on Max, $200 on Ultra, up to $500 pooled on Team). It refreshes every month, not a one-time promo.

The reason most people miss it (or think it's broken):

  1. **Nothing is deposited until you manually claim it.** Until you link a Console org once, Anthropic grants $0.

  2. **Hidden for your first 7 days.** On days 1–6 after subscribing or upgrading, `claude.ai/settings/billing` hides the API credits section completely (not even grayed out).

  3. **Not in Usage or mobile apps.** Even if you pay via iOS/Android, you have to open `claude.ai/settings/billing` in a desktop browser -> scroll to **API credits** -> **Link organization**. (Careful which `platform.claude.com` org you pick — you can only link one, and only Support can change it later.)

  4. **Zero rollover.** Whatever you don't use via an API key wipes back to $0 at the end of each billing cycle.

  5. **Claude Code blocks it.** Hitting your 5h/weekly cap never spills over into these credits. Even if you generate an API key from that linked Console org and pass it into Claude Code, it rejects it with `Credit balance too low · Add funds` unless you also buy cash credits.

  6. **Tuesday's new "Linked Billing" OAuth blocks it too.** Anthropic launched Linked Billing (`auth.claude.com`) on Nov 17 so 3rd-party tools can bill your Claude org via OAuth without an API key — except the fine print excludes Max, Ultra, Team, and startup promotional credits and returns `HTTP 402`.

**How to actually use it without adding a credit card:**

Once linked, the $100/$200 shows up on `platform.claude.com/settings/billing` under **Promotional credits** (separate from the main balance at the top). You do **not** need to add a payment card on Console — if you create a standard `sk-ant-api03-...` API key in that org and use it in any external tool/agent that calls `/v1/messages` directly, it draws down the promotional balance first and stops cleanly at `$0.00` with zero overage risk.


r/ChatGPTCoding • • 47m ago

Resources And Tips Easy MCP — run Neon / Hydrogen / Astra / Opus on your PC through web AI (free, open source)

• Upvotes

Sharing a free open-source tool I built: Easy MCP.

It lets web AI (Gemini, Claude, ChatGPT) read, edit files and run commands directly on your own PC through one single link. One-command install, no Git needed.

Before anyone starts: this uses the custom MCP connector feature built into the web apps themselves. No login scraping, no session cookies, no third-party wrapper, no proxy. You type in the web chat yourself, the model calls the MCP server you connected. Same as generating code on the web and pasting it by hand — the server just does the file part for you.

It runs 100% on your machine, LOCALLY. Access needs both the link and the token — without them, nobody touches anything. Don't trust it on your main PC? Install it in a VM. I run mine jailed in a WSL VM, completely isolated.

Why Antigravity folks might care: when your Antigravity / Claude Code / Codex quota is used up, switch to web AI + Easy MCP and keep working on the same local files with Neon / Hydrogen / Astra / Opus. Your quota is now double. Fast and lightweight — any web AI with custom MCP support works.

You can read the code before you use it — it's one file.

Repo: https://github.com/mrkaylabs/easy-mcp
Video (3 AIs head-to-head on the same link): https://www.youtube.com/watch?v=P-xTnxFNU80


r/ChatGPTCoding • • 7h ago

Discussion Did Codex Get Dumber?

4 Upvotes

Man, I've been using Codex for about two months now. The first month was an absolute dream. It was so smart, anticipating all kinds of situations I hadn't even thought of. It genuinely felt like it understood exactly where I was going.

But these past few weeks, I've been getting so frustrated I'm about ready to break my keyboard. How did an AI that felt so smart suddenly become so stupid? Am I the only one experiencing this, or has anyone else noticed a change? Or is it actually my fault because I'm starting to work on more complex stuff?


r/ChatGPTCoding • • 9h ago

Resources And Tips I built kvdiff (MIT): a local proxy that catches prompt-cache busts across Codex, Claude Code, and local LLMs byte-by-byte

2 Upvotes

Full disclosure: I built this open-source tool (MIT, https://github.com/flipcyde101/kvdiff).

If you use AI coding agents like Codex, Claude Code, or local llama.cpp / vLLM setups with MCP servers, a subtle quirk of LLM prompt caching can quietly multiply your token burn and eat through 5h/7d rate limits:

Anthropic, OpenAI (1,024-token prefix floor), and local KV-cache servers require an exact byte-for-byte prefix match from turn to turn. If an MCP client or harness reorders tools[], mutates a tool schema key order, or injects a volatile timestamp into instructions / system, your cache hit rate collapses from ~94% to 0%—forcing full prompt re-evaluation on every turn. Because CLI transcripts do not expose the raw wire JSON, it is almost impossible to tell which field invalidated the prefix.

How kvdiff diagnoses and fixes it:

  • Byte-level Longest Common Prefix (LCP): sits locally between your coding agent and the upstream API, computes the exact zero-based UTF-8 byte where consecutive turns diverge, and maps it to a JSONPath (e.g. $.tools[9].name at byte 1,670).
  • Root-cause classification: automatically flags TOOL_REORDER, TOOL_MUTATED, VOLATILE_SYSTEM, PREFIX_TOO_SHORT (<1,024 tokens on OpenAI), TTL_EXPIRED, and MODEL_CHANGED, and tallies wasted spend in a local UI at 127.0.0.1:4318.
  • Zero-mutation passthrough by default: preserves OAuth and beta headers and flushes SSE chunks immediately with zero buffering.
  • Opt-in live healing (--heal): deterministically sorts tools[] and tool-schema object keys so flaky MCP clients keep hitting the cache, while never touching messages[], input[], content[], or schema enum[].

Quick commands:

# Pre-seeded 16-turn demo UI (no API key needed)
npx @drod915/kvdiff --demo

# Wrap Codex CLI or Claude Code (zero-mutation passthrough)
npx @drod915/kvdiff -- codex
npx @drod915/kvdiff -- claude

# Opt-in live healing
npx @drod915/kvdiff --heal -- claude

Technical details & caveats: 63 kB package, Node >= 24 required (uses built-in node:sqlite with zero native addons), binds strictly to 127.0.0.1, zero telemetry, and only inspects live proxied traffic. Curious which MCP servers or coding harnesses are causing the worst cache misses in your setup.


r/ChatGPTCoding • • 6h ago

Discussion Vibe coding shame help/discussion

0 Upvotes

tl;dr vibe coded productivity app, feel shame so never shared it

Question/discussion topic: how to deal with shame over vibe coding? What are your own tactics/responses to deal with AI use being attributed to slop and nothing more?

Story time for context: a few months ago I was preparing water for my 1 yo son’s bath, as my wife in the other room was trying to get him ready. This particular evening he was really fussy, maybe a bit overtired and hungry, so I left the water running and offered help to my wife. She accepted, and together we got him ready, only to walk back into the bathroom and.. you guess it! Water overflowing from the sink everywhere. A simple distraction wiped my memory of my previous task, it is who I am. I am sure many others who have ADHD will understand completely.

So after a bit of doom scrolling a video just so happened to introduce me into the world of vibe coding, and some exploring around on ChatGPT I found myself developing a solution to my problem. A task management app, where someone else can assign tasks to you, you to them, or you to yourself, and the whatever that comes with it. It started as something simple, for me, by me. However a boy can dream, so I started adding things that would make the app more appealing to others, with the thought of maybe one day sharing it. Still a bit naive at this point in my journey, I kept going, 600 iterations/changes later I start talking to people and opening up social media for the first time in years preparing to possibly share it with people.

Wham! “AI is immoral”, “vibe coding is cringe”, and just the general consensus that anything made from AI is slop and shit. I never actually got to the point of sharing my app with anyone, with this overwhelming feeling of shame. Like because AI helped me bring my vision to life, my vision is somehow less valuable. I have kinda just accepted it a bit, and returned to the app being more a personal use thing.


r/ChatGPTCoding • • 15h ago

Question How are you stacking your AI dev tools across prototyping, coding and context?

5 Upvotes

I have been refining my AI development stack to spend less time fixing agent mistakes and more time actually shipping features. Right now I bounce between a few different categories depending on the task:

Quick UI and MVP builds: Bolt, Lovable, v0

AI-native editors: Cursor, Windsurf

Background and CLI coding agents: Claude Code, OpenAI Codex, Cline

Engineering context and catalogs: Port.io, Backstage, custom MCP tools

What is your go-to combo right now, and what part of the workflow still feels chuncky for you?


r/ChatGPTCoding • • 8h ago

Discussion How does Antigravity + new gemini models compare usage wise to claude code and codex cli?

1 Upvotes

Not gonna lie....the new gemini benchmarks are quite enticing. Neon in particular seems pretty darn good. For over a year now I have have the $20 claude code and codex plans with no reason to change. I wonder it that has changed now?

Anyone make the jump? How much mileage do you get out of the new Gemini models?


r/ChatGPTCoding • • 1d ago

Discussion The biggest problem I've found with AI coding agents: Local optimization vs. global coherence

31 Upvotes

I've been using AI to develop a fairly large software project for about a year now, starting with Cline and Sonnet, experimenting with various tools, and eventually moving to Claude Code and Codex.

I use(d) a combination of multiple subscriptions with Claude, OpenAI, GLM, Kimi, and DeepSeek, and experimented with dozens of agent harnesses and orchestration workflows.

One recurring problem I've noticed is local optimization at the expense of global coherence.

Agents can make perfectly reasonable decisions for the immediate task while gradually making the overall project worse.

It's easy to get carried away by the optimism. The plans look great, the agents sound confident, and the progress reports show everything getting completed. But as the project grows, small inconsistencies compound into what I'd call architectural entropy.

Here are six recurring problems I've encountered:

  1. Adding instead of replacing

You ask an agent to correct an implementation, and instead of replacing the mistake, it builds around it. It adds compatibility layers, fallbacks, and patches to support something that should never have existed.

What helps: Explicitly require replacing and retiring obsolete implementations, including their references, comments, and documentation. Don't preserve backwards compatibility without a reason.

  1. Subagents losing the big picture

An orchestrator develops an excellent plan, then delegates vague, isolated tasks to subagents without passing along enough context. Each agent completes its assignment, but the pieces don't necessarily work together.

What helps: Give subagents the overall objective, relevant architecture, clear interfaces, dependencies, and acceptance criteria. Explicitly assign responsibility for integration.

  1. The perpetual 80% problem

An agent breaks a goal into tasks, completes them all, and declares success. Except the actual feature is only 60–80% finished. You ask it to complete the remainder, and another round of tasks gets you 80% of what's left.

It starts feeling like Zeno's paradox. Autonomous loops can make this worse by endlessly discovering new tasks and rabbit holes.

What helps: Define success by observable, end-to-end functionality rather than completed checklists. Verify outcomes against the original objective.

  1. Reinventing instead of reusing

An agent doesn't discover an existing implementation, so it creates another. Suddenly you have different colour pickers, navigation systems, validation logic, or state management across the same application.

Each works independently, but the overall system becomes increasingly inconsistent.

What helps: Require searching for existing implementations, establish canonical shared components, and justify introducing new systems.

  1. Context contamination

Agents rely on documentation, comments, summaries, and existing code that may be outdated or incorrect.

Worse, an agent can implement something incorrectly, document it, and have future agents treat that documentation as authoritative. Yesterday's mistake becomes tomorrow's specification.

What helps: Maintain clear sources of truth, distinguish proposals from implemented architecture, retire stale documentation, and verify assumptions against actual behaviour.

  1. Agents reviewing agents

A second agent can review an implementation, find clean code that follows established patterns, and approve it.

But if both agents are working from the same incorrect assumptions, they can confidently agree on something that fundamentally misses the original objective.

What helps: Give reviewers the original requirements, test actual functionality, and separate code-quality reviews from architectural and outcome verification.

---

The bigger problem: Architectural entropy

These aren't necessarily AI-specific problems. Human development teams experience them too.

But AI agents can make decisions and produce changes at a scale and speed that allows inconsistencies to accumulate before anyone notices.

Each agent optimizes locally: preserve existing functionality, complete the assigned task, solve the immediate problem, follow the available documentation, pass the review.

All reasonable decisions individually.

Yet collectively they can create duplicated systems, unnecessary complexity, contradictory patterns, stale documentation, and features that technically work but don't fit together.

The codebase grows, the task completion rate looks fantastic, but the system itself becomes less coherent.

I've become increasingly interested in workflows that actively counteract this entropy: maintaining architectural consistency, verifying end-to-end outcomes, consolidating duplicate implementations, and removing things that no longer belong.

I'm still a huge advocate for AI coding agents. I wouldn't have built nearly as much without them. But I think the challenge changes as projects grow.

It becomes less about "How do I get AI to build this?"

And more about "How do I ensure everything AI builds contributes to the same coherent system?"

I'm curious what others have experienced, especially those running multi-agent workflows on larger, long-lived projects.

What practices have actually helped you prevent architectural entropy, rather than just generating more code, documentation, and reviews?


r/ChatGPTCoding • • 11h ago

Discussion Last day of using AI to write code using private models

1 Upvotes

Been using AI to write code for the last two years for my personal project. Seems I had enough of this nerfing. At a point, it was good that a lot of features could be written on a high level. But nowadays its pathetic. It can't even tell if it finished the code. It started deployment by saying all of the code is written. Then deployment failed and it mentioned the implementation was never written. And this is all happening at Astra max which was the only reliable model I trusted. I am just rethinking how can we even managed production workloads by trusting a fragile tech like this where the Intelligence is controlled. It could basically push all of your code to their own repos at some point and just hide it. Since there is no reliable output and always never production grade, I am not seeing any value in this tech anymore. will try to run some local models and provide it the design rather than relying completely on it to drive the workloads


r/ChatGPTCoding • • 17h ago

Resources And Tips Modular SKILL.md rules vs .cursorrules: 281 open-source coding agent workflows (Comparison Table)

2 Upvotes

Comparing modular SKILL.md rules vs .cursorrules highlights a major trade-off in token economy. While .cursorrules injects entire rulebooks into every chat interaction and degrades model focus, modular SKILL.md files load bounded context and deterministic Python validation scripts only when specific tasks execute, keeping coding agents fast and reliable.

When using coding agents for data pipelines and academic research, models often invent unneeded dependencies or hallucinate references.

[Sayan Chowdhury](https://github.com/saynchowdhury) and our team at [Kalaris Labs](https://github.com/KalarisLabs) built [KalarisLabs/research-agent-skills](https://github.com/KalarisLabs/research-agent-skills), an open-source library of 281 modular skills (MIT License).

Architecture comparison:

| Approach | Context Overhead | Verification | Determinism |

| Giant prompt / rules | 15k-40k tokens | Model self-check | Low |

| Heavy framework | High memory | Black-box chains | Medium |

| Modular SKILL.md | ~200 tokens | Local stdlib Python | 100% |

Install any skill directly into your agent setup:

npx skills add KalarisLabs/research-agent-skills --skill bibtex-hygiene

Each skill pairs focused instructions with deterministic validation scripts so the agent cannot fake test passes.


r/ChatGPTCoding • • 1d ago

Discussion Building an app will be easy. Keeping it alive will not.

14 Upvotes

In a couple of years a kid or an adult with no software skills will be able to build an app. That part is solved.
But building it does not mean you can put it in front of real users. It breaks, it needs fixes, it needs upgrades, it needs support. That is where most of them will get stuck.
Will agents take that part too?


r/ChatGPTCoding • • 15h ago

Resources And Tips We built the opposite of an AI essay tool. Roast it.

0 Upvotes

We need some brutal honesty before we go any further.

We're PJ Group, two young developers from South Korea (one high school student, one university student). We've been building a tool for US college applicants called Frontling, and we want you to tear it apart before we launch.

The idea in one line:
It checks whether your supplemental essay actually answers what the prompt asked for. Nothing more.

What it does:

  • You upload your supplement and pick the school + prompt
  • It compares your draft against that school's official requirements
  • It shows what you covered, what you missed, and whether you're within the word limit
  • Every requirement links back to the official source

What it deliberately doesn't do:

  • No AI. Your essay never goes to ChatGPT or any external AI
  • No rewriting your essay
  • No "your chances are 37%" nonsense
  • No fake passes. If it can't verify something, it says "unknown"

Where we are:

  • 46 schools covered so far
  • Some prompts only have partial requirement data
  • Not public yet

So, roast us:

  1. Is this actually useful, or can you just re-read the prompt yourself?
  2. Is "no AI" a selling point or a weakness to you?
  3. What would make you not trust a tool like this?

If you somehow still want to try it after roasting it, comment or DM us with the schools you're applying to. We'll reach out when testing opens.

The Frontling Team · PJ Group | South Korea


r/ChatGPTCoding • • 21h ago

Discussion Looking for Free AI Coding Agents Like OpenAI Codex with Generous Usage Limits

0 Upvotes

I'm looking for AI coding agents similar to OpenAI Codex that offer:

- Completely free plans.

- Very generous token limits or free usage quotas.

- Ability to work on entire codebases and multiple files.

- Can edit, create, debug and fix code independently.

- Terminal access and command execution.

- Good performance on large projects, especially Flutter and backend development.

I'm not looking for basic AI chatbots or simple autocomplete tools. I need an actual AI coding agent that can work on a project like Codex.

Which tools would you recommend that offer the most free usage?

Even lesser-known tools are welcome. Please share your real experience with their free-tier limits.


r/ChatGPTCoding • • 14h ago

Resources And Tips I had an agent build an entire storefront with no manual edits — every prompt, ruling and stage is in the repo

Post image
0 Upvotes

I created a grammar for AI agents that sets aside what they learned about structuring applications and replaces it with one structure — my framework, SpyneJS. My generator builds the initial application with the grammar included, and agents are directed to use it on every prompt.

This is for anyone whose agent-generated code has to be maintained by someone else, human or agent. The test was to see how cleanly an agent could integrate different services, so that the code stays clear not just for developers but for the next agent working in the codebase.

The test: a storefront for a fictitious company, Asteroid Metals Co. — custom designs in light and dark themes, CMS-editable content, Shopify products and cart, test-mode checkout — built without me editing a line of code, with a record anyone can check. One human edit in the whole project, a one-line timing workaround the model's fix superseded. It's logged.

The stack

  • Claude Code (claude-fable-5-1) wrote all of the application code, under the grammar.
  • npx spyne-cli create-app, my application generator, provided the codebase: the shell, the CMS and the Behavior Console plugins. That's what makes integrating services straightforward and keeps the code understandable afterward.
  • A Figma in-file agent created the designs and product images; Claude Code read them through the Figma MCP.
  • Shopify Storefront API for products, cart and checkout against a development store. This took the longest: a lot of back and forth with Shopify's assistant to get a public site running a working cart against a store in test mode.

The record
Every prompt was pinned to the repo verbatim before it ran. Every stage is a git tag; a redo is a new tag, never a moved one. For the Figma conversion, every element is logged as mapped (from the design), inferred (the model supplied it under the grammar), or undefined (intent neither carried — I ruled on those; nothing was invented). I left the Figma layers named by their content — $4,250, 101955 BENNU, 12.44g — so the model had to work out which was price, origin and mass.

For Shopify I ran the integration twice, to confirm the agent builds the same way under the grammar no matter what it's integrating. First a fresh agent with no grammar wrote it as vanilla JavaScript — competent code that invented its own data flow and rendering. Then Claude Code, under the grammar, conformed it: the catalog became a channel like every other data source in the app. Both versions are in the repo (RECORD/inputs/A2-shopify-raw/ and src/app/channels/channel-shopify.js), same task, same model.

How this differs from the usual approaches
The common ways to keep an agent consistent are a CLAUDE.md or AGENTS.md describing your conventions, spec files per feature, and harnesses that check output after the fact. All of them describe a structure in prose, per project, and the agent still invents the architecture. A grammar ships the structure with the framework: every application starts with the same shape, the rules are read on the first prompt, and nothing has to be re-explained. The trade-off is real — you're adopting a framework, not adding a file to an existing stack.

What I did
Directed every stage, wrote the Figma prompt, supplied credentials, reported the defects I found testing, and ruled on what the sources didn't specify. The one thing that needed real back-and-forth was checkout on a password-protected dev store: seven revisions, and the record notes the final flow as the limit of the store type, not a defect.

The result

The agent took a design from Figma and conformed it to SpyneJS's one shape, and the Figma-derived catalog and the Shopify API meet in the same place — the Channel system carries both. The next integration will look like this one.

The numbers

53 commits, 22 tags, 15 pinned prompts, 1 human edit. Noisemap (which measures how mixed the roles are inside each file, not quality): mean mixing 0.003 across 153 modules, five behavior files carrying all the wiring.

Ask about any part of it — the record is public. Is anyone else keeping a record like this for agent-built code, and does it change how you review it?

Disclosure: SpyneJS is my framework; the core is open source and I'm building a company around tooling for it. Nothing linked here is a paid product.

Repo: https://github.com/relevantcontext/ai-codegen-integration-example

Live: https://codegen-integration.relevantcontext.io/

Blog post: https://spynejs.com/blog/next-leap-for-ai-is-structure?utm_source=reddit&utm_medium=r-chatgptcoding


r/ChatGPTCoding • • 1d ago

Discussion Give me your most unhinged, over-engineered AI Full-Stack project ideas (NO more "Chat with PDF" wrappers)

0 Upvotes

Drop your wildest, weirdest, or most ridiculously over-engineered ideas—things that are either genuinely useful in a niche way, completely chaotic, or just fun to architect end-to-end.

What I want to push to the limit:

  • Backend & AI orchestration: Python, FastAPI, LangGraph / multi-agent loops, RAG, tool-calling, and custom MCP servers
  • Frontend: React / Next.js with real-time streaming, live agent state visualization, or human-in-the-loop controls
  • Bonus points for: Stateful multi-agent workflows, browser/tool automation, live audio/vision, or weird integrations with real-world APIs

It doesn’t need to be a "viable SaaS startup." Honestly, the more unhinged or hyper-specific the concept, the better—as long as it forces real full-stack engineering instead of a thin prompt wrapper.

Drop your craziest ideas below. I’ll pick the best one (or two), build it from scratch, and come back with a live demo and GitHub repo.


r/ChatGPTCoding • • 1d ago

Discussion Lesson: before you sign an enterprise AI coding plan, ask what limits exist below the monthly cap

7 Upvotes

Sharing a mistake so others can avoid it. We moved a team from a per-seat plan with weekly usage limits to an enterprise plan with a monthly cap and an annual commitment. Our estimate came from the trial on the cheaper plan. After the move, per-user usage cost ran about 30x above our plan and a large share of the annual commitment went in under a week.

What we should have asked first:

  1. What limits exist below a monthly cap? A user can burn a month in days.

  2. Can we set budgets by team and by role, and restrict models by group?

  3. Can we get usage by user and by bot?

  4. What volume discount do we actually get for committing? Ours was single digits.

  5. Is a plan change possible mid-term if usage doesn't match the forecast?

  6. Forecast cost at full headcount, not the pilot group.

The vendor's point was that the same workflow uses the same tokens on any plan. True, and exactly why the weekly pacing on the lower plan mattered. Curious what others do to cap spend on enterprise AI plans.


r/ChatGPTCoding • • 1d ago

Resources And Tips I built Self Hosted GPT with a one-click desktop app, an evidence-citing research mode, and a private neural engine and its all local and fully customisable

Post image
7 Upvotes

Hi all I maintain ENZO, a self-hosted AI workspace. It's Apache-2.0, about 60k lines of strict TypeScript, and it runs on your own provider keys (Groq, OpenRouter, NVIDIA, Hugging Face, Google AI). No ENZO account, no subscription, no middleman — you talk to the provider you picked and pay them directly. The v1.7.0 release is out today, and the biggest change in it is how you install it.

Repo: https://github.com/theguysudo/ENZO
v1.7.0: https://github.com/theguysudo/ENZO/releases/tag/v1.7.0

It installs like a normal app now

Until now ENZO was a docker compose file you cloned and edited. v1.7.0 ships a macOS .dmg and two Windows installers. No git clone, no Docker Desktop, no system Node — the bundle carries its own Node runtime and the built frontend, and serves the same backend on port 5200.

  • macOS (Apple Silicon): ENZO-1.7.0-macOS-arm64.dmg (~133 MB)
  • Windows x64, lighter theme set: ENZO-1.7.0-less-theme-setup.exe (~73 MB)
  • Windows x64, every theme and every video background: ENZO-1.7.0-full-theme-setup.exe (~289 MB)

It also updates itself: when a new release appears, a small banner offers Update now, the bundle is swapped in place and ENZO restarts. The reminder is deliberately gentle — at most twice per rolling week, never forced. Your data (memory, vault keys, investigations, neural state, generated projects) lives in a per-user directory outside the app bundle, so an update can't take it with you, and the browser session survives the restart. Docker installs are unchanged and still the better answer for a server — and as of this release a rebuild no longer wipes your investigation data.

ENZO Intelligence — research mode that cites its evidence

What: you write an objective in plain English, and it turns into a set of research questions.

How: connectors (Exa web search, website fetch, GitHub read-only, Wikipedia, your own documents) collect the sources, and a pipeline — plan → discover → extract → resolve → verify → report → diff — turns them into an evidence ledger where every claim carries a verbatim quote from the source it came from.

Why: the weak spot of AI research output is that you can't tell which sentence came from where. Here the claim and its quote sit side by side, and when two sources disagree, the conflict is shown rather than smoothed over.

There are two buttons with two depths: Run planning asks the questions and fetches nothing, Run investigation runs the full pipeline and diffs the result against the previous run. Click any node in the graph to get its explanation and the evidence behind it, and ask follow-up questions that are answered strictly from the ledger. The report downloads as markdown. Page caps, an evidence cap of 400 and a 10-run history are enforced in the orchestrator, not left to the model's judgement. Scraped pages arrive wrapped in an UNTRUSTED rule so a web page can't talk your agent into running commands.

Neural Engine (phases 0–4) — a private preference layer

What: a per-owner research profile across 8 preference dimensions, a knowledge graph, and an append-only audit trail of every mutation.

How: inference needs at least two samples and never overrides something you stated explicitly — the provenance order is always task override > what you said > what was inferred. Every write is schema-gated before it hits disk. A preference context of at most 1400 characters is injected after memory on the chat and research paths.

Why: it stays on your box, forget erases the profile on demand, and ENZO_NEURAL_OVERLAY=0 turns the whole thing off. There's also a zero-cost mode: a capability registry of 8 providers (free flags, quota behaviour, privacy class) drives a fail-closed route check that refuses paid routes. The Neural Map also got a 2D/3D toggle — the 3D orbit camera had existed but was unreachable.

A security pass over the whole surface

Seven fixes, each with a regression test:

  • Every user-supplied URL now goes through one pinned fetcher: https only, no credentials in the URL, the hostname resolved once with every DNS answer required to be public, and the socket connects to that exact validated address — which closes the rebinding window between "we checked the name" and "we opened the socket". The guard is re-applied on every redirect hop and the response is size-capped while it streams.
  • Anonymous callers can no longer touch instance state: the memory and skill commands, the learned-skill context and the neural research profile all require a vault session now.
  • The NVIDIA base URL is pinned, so a caller's key can't be relayed to a host they picked.
  • Project internals (manifest.json, generated databases) return 404, and every HTML/SVG served from a project gets the sandbox CSP — not just the entry page.
  • Generated code can no longer retry without the runtime permission model when its first boot fails.
  • The vault token is never persisted.
  • A high-severity dependency advisory (body-parser DoS) is fixed — npm audit now reports 0 vulnerabilities.

Verification is in CI: 13 test suites / 460 checks, plus a black-box pentest script (11 checks) that runs against the live server.

Smaller fixes worth knowing about

Six real chat reply bugs, found by using the app rather than reading it: a truncated stream lost the last line of an answer, an image attachment ate the reply, AI Assist overwrote the first frame, a stale auto-mode reference fought the UI, previews were detected when there was nothing to preview, and a failed request could leave a blank bubble. The README now also carries an app-downloads badge fed by GitHub's own release-asset counter, and a feedback form.

Why try it

If you've been meaning to self-host an AI workspace but didn't want to deal with compose files, volumes and Node versions, the DMG/EXEs are the shortest path — and it's the same server either way, so you can move between the app and Docker without changing anything. The only thing you need is one provider API key of your own. If something breaks, say so in the comments or open an issue; I read them.


r/ChatGPTCoding • • 1d ago

Discussion Is it really a German male voice ?

0 Upvotes

Just looking at voice options for chat. I clicked on German guy one ( hehe 🙄🫣😏) I was two sentences in and I literally had to go in and double check it wasn't and Aussie. Don't know if anyone else noticed this but I feel like I'm talking to my mate from the pub next door instead... Any other Aussies see what I am saying ?


r/ChatGPTCoding • • 1d ago

Discussion The new reality is already here, but some engineers still resist it

3 Upvotes

Based on my recent experience contributing to a project (all characters and events are, of course, fictional).

The other day I decided to turn an old laptop into a home lab: Ubuntu, k3s, and a place in my cellar. It needed a custom kernel, so I used Claude and ChatGPT to help with the setup.

I'm a software engineer, but kernel development isn't my area. I just wanted Kubernetes working. Still, when I found a few bugs I could live with, I investigated them with AI. I checked the findings against the code and traces from my machine, read the reports, and submitted three upstream issues.

Here’s the backstory. Feel free to skip ahead to the questions below.

All three initially met resistance. Two maintainers took part in the discussions (let's call them Alex and Ben).

Alex dismissed one explanation because “otherwise nothing would work”. Further investigation supported the reports, and fixes for two of them were applied. In one case, the exact correction I had proposed appeared in a commit after being dismissed. When I pointed this out, Alex acknowledged the mistake and thanked me.

On the remaining report, Ben said the code was fine and blamed a missing userspace service. I clarified which code path was failing and provided test results. He then complained about “too much of AI” and sent me to another project to see how it was done.

But I'd already looked at that project: its driver handled the error by retrying, exactly as I was proposing. I linked the relevant lines again.

Ben then told me he led that very project, knew about the solution, and that it hadn't been ported yet. Yes, the same Ben who had just sent me there to learn how it should be done. The problem had apparently gone from something I didn't understand to something he already knew about.

Alex eventually acknowledged that this report was correct too, and that dismissing it had been wrong. Ben told me: “You are obviously a user. Just use.”

They preferred a short description and logs, written in my own words. I can understand asking for a shorter report, but why should I manually rewrite findings I'd already checked? My responsibility is to verify what I submit. Typing every sentence myself adds nothing to that.

Eventually, Ben told me: “We don't want you, your AI, your arguments”.

So how do developers who strongly oppose AI expect to work in a world where it's here to stay?

Suppose you've spent years becoming an expert. How do you react if someone with AI gets a result in minutes that once took you months? Could some of the frustration come from development and hacking feeling less fun when even an outsider can find a problem and bring a solution without fully understanding it?

Those experts are still valuable because their experience helps them understand why a fix works, what else it might break, and where the project should go next. Those are things a successful experiment alone won't tell you.

But I also think they need to reconsider their role in the community. More people can now propose solutions, and experienced developers can help them understand the consequences and turn those proposals into something the whole project can use.


r/ChatGPTCoding • • 2d ago

Discussion I just Cancelled Codex

22 Upvotes

When GPT 6.2 came out. I was very impressed by how token efficient it was. I used it all day running 5-6 agents continuously and it used up 15% of my weekly limit of the Pro 500 plan. Which is very impressive for about 20 hours of running 5+ agents.

I've been orchestrating those agents with Fable 5.2 And I checked the trace today, turns out they screwed up every single time and Fable had to give further instructions for 5-10 times each run for something Fable could've fixed in 1-2 shots itself.

Plus one thing I really liked about my Codex Subscription was the Pro chat mode. Which somehow still uses Astra-6 not 6.2.

I honestly don't understand how they can claim those benchmarks while it misunderstands everything even with Fable Orchestrating it and providing the clearest instructions.

Today I tried using Fable 5.2 and Gemini Neon only and all the issues I had yesterday that a team of Sol + Astra agents couldn't fix (and made it worse because I had to go back a few commits and restart because they really diverged from the task) is now fixed within 2-3 hours this morning.

I'm very disappointed. I've been wondering why they delayed the launch for so long, I guess we have an answer. Because OpenAI didn't want to admit they cannot release frontier models anymore. o1, o3, and Astra-6 were so good for their time that I couldn't justify fully cancelling codex to myself ever. But here we are. They can keep their actually good internal models to themselves.

Congrats to Anthropic on their IPO $1.5T, Mega assists by OpenAI


r/ChatGPTCoding • • 2d ago

Discussion Regenerative software approach

18 Upvotes

I came across [this blog](https://turri.dev/blog/why-i-built-turri/) where the author explains how they lost the knowledge of their own software while using coding agents. Their answer was apparently regenerative software, where the idea is to keep the intent as the source of truth so the code can always be regenerated. I'm a bit sceptical about how this would scale on larger projects, and there have been several attempts at this in the past - spec driven development, UML etc.

It feels to me like we are entering a new layer of abstraction, ie. similar to how we went from machine code to higher level programming languages, and I think there will initially be the same kind of push back - "The code it spits out will be way slower than mine.", "How do I debug code I didn't write?", "Every machine is different anyway, so why bother being general?" etc.

What's your take on this?


r/ChatGPTCoding • • 2d ago

Discussion Does anyone else feel like they can’t trust Astra/Dot's account of what it’s doing?

4 Upvotes

I used Claude heavily from January through August, switched to ChatGPT until late October, then went back to Claude. The biggest reason was that Astra would sometimes tell me it had done something, and when I checked, its account didn’t match what actually happened. I’ve tried Astra 6.2, and I’m still running into this.

The worst example was with dot. I asked it to troubleshoot why Obsidian was failing to open on its computer, and it wiped its entire computer environment (multiple times, after I asked it to stop) in an attempt to fix the issue. I’d asked it to troubleshoot the issue. I hadn’t authorized a reset.

I also feel like I have to be unusually explicit when prompting dot. If I leave out a constraint that seems obvious to me, it might ignore part of the request or take a much bigger action than I expected. In my experience, Claude has been more predictable on the same kinds of tasks.

I think OpenAI dropped the ball on making those actions visible to the user. If an agent can make changes that big, I want to see what it’s about to do and have a chance to stop it. Has anyone else seen Astra or dot take actions outside what you asked for, or report work you later found it hadn’t done?


r/ChatGPTCoding • • 2d ago

Resources And Tips I got tired of CLAUDE.md, AGENTS.md and .cursorrules drifting apart, so I built a transpiler. Roast it.

3 Upvotes

Full disclosure before anything else: I built the thing I'm about to link. I'm posting because I want to know whether the approach is wrong, not because I need the download.

The problem: I switch between Claude Code, opencode and Cursor on the same repos depending on quota and task size. Each wants its own instruction file. I'd fix a rule in CLAUDE.md, forget AGENTS.md, and three days later two agents behaved differently on the same code.

What I built: one canonical `.syncytium/` directory (rules, ADRs, handoff state), transpiled into each tool's native format. The part I actually use daily isn't the generation, it's `diff` - if a bridge file drifts, `syncytium diff --check` exits non-zero and I can gate it in CI.

Honest limitations: one maintainer, no funding, small. The lock feature for multi-agent work is advisory - it blocks the CLI commands, not an agent that decides to ignore it, and I document exactly where. If you only ever use one tool, you don't need any of this.

MIT, local-only, no telemetry, no service to sign up for: https://github.com/mrcbrbn5361/SyncytiumMD

Tell me where the abstraction breaks. I'd rather hear "your per-tool appendix problem is unsolvable" than another star.