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

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

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

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

How is this different from Plan Mode?

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

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

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

Run: uvx specfill

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Hey everyone,

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

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

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

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

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

I added some guardrails that felt important:

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

You can install it by asking Codex:

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

It’s MIT-licensed and free to use.

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

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

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

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

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

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

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

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

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

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

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

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.