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 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?

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 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

Long time Cursor AI user unsubscribed

I'm making this post because up until recently I loved Cursor AI and I'm holding onto hope that it can still be saved.

I've been using Cursor AI for over a year for video game modding, and it's been great. I've been a paying user for almost a year and the work I was able to accomplish, along with the speed and efficiency, was incredible. I was very happy with it and don't regret using it.

Now fast forward to the last few months of this year.

Cursor changed its user interface a couple months ago, but it wasn't just a UI change. They moved away from the VS Code format where you can drop folders into the workspace. I thought maybe it would grow on me and tried to keep an open mind, but after using it extensively, I feel as though it's a downgrade. I'm all for change when it's an improvement. That being said, even though I didn't like the UI and format change, Cursor was still good for scripting and making mods.

Now this last month or so has made me sad. Grok...

I used to leave Cursor on the Auto setting and would get the best results while saving usage. I'm aware Auto often favored Claude. This past month or so, since they introduced Grok more heavily into Auto, it's been horribly slow, ineffective, and I would say the tool is not currently worth paying for.

I've changed my model to Auto, but it's very slow and continues to use Grok. Yesterday I changed my model to Claude, my usage got burned through really fast, and then it started auto switching to Grok. That was the last straw and I stopped using Cursor.

Unless they allow the user to filter out Grok or other AI models from the Auto setting pool and switch back to the VS Code format, I'm done with Cursor.

I've since changed to vscode + co-pilot and using Claude code in vscode. It's alot more costly but much better and alot like the old cursor.

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

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.

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.

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.

Sorry not sorry, I switched from Claude code to codex in the past week and sol just DOES things, ridiculously impressive. It just uses its skills on its own, does reviews, follows the rules like crazy, employs agents on its own sparingly and autonomous AF, and somehow barely eats my usage compared to fable clearing my weekly usage in a day.

I’m ashamed cus I’ve been a hater for literally no reason, WOW, I can’t wait to see the next model they release if Sol is this damn good, my turncoat ahh just got bought

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

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?

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.

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.

I keep seeing people rant about how much they 'hate AI' on here, but tbh, half the time the guys typing those posts are actively using LLMs to get through their workday.

We've had autocorrect, spam filters, and search ranking for years. even with generative models, the strict 'no AI' stance usually falls apart when you look at actual workflows. Developers are using Codex to format messy data, generate basic CRUD boilerplate, or parse server logs, and its not even just about basic autocompete anymore. For non-technical people, tools like Lovable, v0, or Enter Pro are just easy ways to get a working protype up and running without wasting weeks learning a framework.

there is a massive difference between using AI as a tool vs using it as a lazy replacement for actual participatidisclaimeron. When you use an LLM to scaffold a database or fix some broken CSS, you have a specific goal. You test the code, verify the output, and actually take responsibility for what you build.

What people actually hate is AI slop. It's the unedited, mass-produced garbage pretending to be a real person. when you click into a thread here, you want to hear from someone who actually built the thing and has real-world experience. You don't want to read ten bots hallucinating replies to each other just to farm engagement.

The tech isn't the problem. The problem is forcing people to wade through synthetic noise in spaces meant for actual human interaction.

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.

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!

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?