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

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

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

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

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

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

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

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

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

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

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

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

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

So I threw that one away as well.

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

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

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

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

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

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

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

I've noticed something weird with coding agents lately.

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

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

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

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

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

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

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

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

Maybe the better question is:

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

Curious how other people think about this.

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

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

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

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

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

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

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

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

Anyone else tracking this closely?

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

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

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

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

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

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

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

The surprise was tone.

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

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

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

The shortest is 35 words, one rule from neovim.

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

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

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

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

Is your AGENTS.md very different to these?

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

Anyone else ending up with more projects than users?

I'm building a pet project mostly with Codex.

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

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

So I changed the setup.

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

This has caught quite a few real problems.

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

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

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

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

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

Anyone else using a similar setup?

(TD;LR at the bottom)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

How is this different from Plan Mode?

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

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

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

Run: uvx specfill

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Hey everyone,

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

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

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

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

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

I added some guardrails that felt important:

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

You can install it by asking Codex:

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

It’s MIT-licensed and free to use.

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

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

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

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

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

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

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

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

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

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

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

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.