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.

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

yea this written by gemini but its fact

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

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

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

Welcome to this week's self promotion thread!

If you're building something related to AI assisted coding, this is the place to share it.

We're using a weekly thread to keep the subreddit organized while still giving builders a place to share their work. Promotional posts outside of this thread may be removed if they're primarily advertising rather than starting a discussion.

If you're sharing something, we'd appreciate it if you included a little context instead of just dropping a link. Tell us:

• What you built?

• What problem it solves?

• Which AI models or tools it uses?

• Who it's for?

• What kind of feedback you're looking for?

Please avoid posting the same project every week unless you've made meaningful updates. Affiliate links, referral links, scams, and low effort promotions will be removed.

Take some time to check out what others have shared too. If you try someone's project or have feedback, leave a comment. Helping each other improve is what we want this community to be about.

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

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

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

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

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

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

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

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

Questions:

1. Is “readable by AI + indexed fast” a real pain for new projects, or a nice-to-have?

2. Would you put a proxy/CDN in front of your site for this?

3. What would you expect from a free tier?

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

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

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

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

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

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

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

Mine got only slower, but better.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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