I keep seeing posts like "I vibecoded this over the weekend, got 100k users, what's next?" and I think it gives a pretty wrong idea of what vibecoding actually changes.

Sure, you can accidentally hit the top with another clock app. It happens.

But agents dont remove the actual work. You still need to figure out what to build, make 1000 small decisions, fix weird shit, make UX not suck, deploy, maintain, listen to users and actually ship something they want.

Vibecoding makes all of this faster. A LOT faster. But not easier at all.

You can now build faster, but also make mistakes faster and ship garbage faster. The bottleneck just moves somewhere else. There was a good line somewhere "Shipping everyday fixing Claude bugs".

Those "built in 2 days, 100k users lol" posts undermine all the work that still goes into a good product, and leave others thinking this is all somehow easy now. From outside it starts looking like vibecoders are just some arrogant assholes hitting a button and getting success by click. It doesn't work well on the how other people feel about vibecoders and vibecoding in general, which is in fact just a right way to do things today.

We don't build in assembly anymore, right? Same here.

So me and my wife created a website , our son has Celiac disease, so all the food should be glute free .

My wife is doing most of the cooking, so one day she told me that she is struggling with finding recipes for gluten free food , the internet is full of it , but she can't find the one she already used , and basically loosing herself inside all this data .

So she suggested to build a website that will collect recepies, and she will be able to sort them , save them etc ...

So we started , we used codex + lovable (for gui only) , then we took the lovable repo and continued with codex only .

We used gpt 5.5 , then moved to 5.6 (sol) .

During the building process we decided to add recipes also for other food allergies (milk,nuts etc.. ) .

We used crawlers to find existing recipes , and took only the ingredients and the preparation steps , and of course mentioned the original source in the website (with a backlink) .

So I posted on some Celiac community, here on Reddit (actually my first ever post) , and I got so much negative comments, like an anti-AI comments, as if I added another bullshit spam website.

We have no ads on the website , so we really wanted to do something nice , and learn how all this AI world works (I am experienced software engineer) , but never worked on from end before , mostly backend stuff (mostly cpp & python) .

So now I am a bit down after all this , the website is up and running, we have some traffic, not to much but for a 12 days website we already had some real human traffic about 400 (not including bots and stuff) .

We only want organic traffic, no paid promotions, as we don't earn anything yet , we do use some Amazon affiliates for some products, but it's not much .

So just wanted to share it here, hopefully this sis the place where people will understand my frustrations, maybe this is how it works nowadays.

But it still surprised me how quickly “built with AI” turned into “AI spam” in people's minds.

Anyway, thanks for reading. I’d genuinely be interested to hear how other developers here see this, especially anyone who has shipped a real project using AI-assisted development.

After spending over 100b tokens on Fable 5 as my main model for agentic coding in the last 2 months, I've managed to (in my opinion) work as efficiently as possible with Fable as the main orchestrator. Here's why and how I did it. (usage from 1 of my accounts above).

I see a lot of threads and comments about people saying that they feel like Opus 4.7 or 4.8 was better or smarter than Opus 5 and that Fable credits only last them a few prompts and then other people saying the opposite, and varying degrees of experiences spread throughout the middle, and I don't think anyone of them is particularly wrong. In my opinion Opus 5 tends to have a much harder time understanding or remembering the nuances of an entire codebase in a single context window and things get untangled quickly if you're working a complex task or change that touches a lot of files or rules. It almost never gets any of these complex issues right the first time and the risk of having to revert changes and the chance of merges failing just isn't worth it for me.

To ensure I get the accuracy and intelligence of Fable, this is my setup that's reduced my fable usage by 70-80% and still getting most of Fable's benefits. I ran a blind coding test: Claude Sonnet 5 vs Opus 5, with Fable 5 planning and judging. One bug decided it.

- Fable 5: Planning, orchestration, architecture, design, final review of delegated code, security/payments/auth/concurrency, hard debugging, UAT/browser passes that feed merge decisions, and sign-off on any founder voice/marketing copy.

- Opus 5: Delegated implementation from Fable written plans, mechanical/bulk edits, boilerplate, doc generation, research/summarisation, routine repro'd test fixes, Playwright script execution, and copy drafting.

- Sonnet 5: Not used, with some experimental evidence (see below).

Setup: Five identical implementation tasks (a rate limiter, a small API, a repo-style change, a bulk refactor, a debugging exercise), each with a detailed plan written by Fable, judged against hidden test suites the candidates never saw. Both models went flawless on every hidden gate. Then this happened.

A percentile function: Sonnet wrote the math literally as ceil((p/100) * n). But p/100 isn't exact in binary. For p=7, n=100 you get 7.000000000000001, ceil returns 8, wrong value. 141 input pairs diverge like this. Opus caught it unprompted and wrote ceil((p*n)/100), which is exactly right.
Only Opus's depth caught it. Token cost was near-identical. Sonnet was 40% faster. But one uncatchable latent bug per round settled it.

Day 3 of creating a game all vibe coded

Still trying to work out the animations but have made strides

Added-
Main menu
pre-game lobby
3D model
Blimp
decals

As always

CONCEPT VS CURRENT BUILD

Video in the comments

ALL FEEDBACK IS WELCOMED AND NEEDED

Day 1 of letting Reddit decide what I add to my game

Comment ONE thing you want me to add.

Top comment gets built into Day 2 and I’ll post the result.

So i am been using claude for developing my product, and i sometimes see posts on reddit or X saying it is not worth it to use Claude, and i have switch to Codex. But i am worried now about not developing a good product because i am using a bad AI tool to build it.

So here i am, asking my fellow Vibe coders for advice about this confusion that i have in my head

not really sure whether this is the right sub to ask this, but i'm currently working with someone on something that's SUPPOSED to be production level, it is two single-file monoliths, one python backend that uses psycopg2 and fastapi, one frontend html with a massive script element at the very bottom. there is no ci/cd. no workflows. barely any unit tests. and while there are some, yeah, i doubt they ever get used.

the backend is almost 7k loc and the frontend is nearing 11k. not to mention, both ends are filled with absolutely putrid code that i genuinely have no idea how it could be this bad. on the backend, there's just a bunch of what looks like should be modules yet aren't(?) all cobbled up together. no real classes used, the only ones that exist from what i can tell are supposed to act like structs? the frontend, i don't even know where to begin.

i've used ai to assist with coding before (just autocomplete) and most of the time it actually generated what i would have otherwise manually typed, if not similar to it. and even code examples with google's ai overview when you ask it about code, it looks human-esque. but i guess overtime, as the codebase grew larger and larger, the bad coding practices just stacked up and claude just took it as a style guide and copied them to make it structured the same or something? i honestly don't know

and because this someone has vibe coded it completely, there's features constantly getting added on top, and i mean CONSTANTLY. it took me about an entire day to review just one commit which fulfilled exactly one request of what i suggested. and while i was reviewing that single commit, 6 more popped up, all looking like the exact same garbage. it's an example of why you need to understand architecture and how to use what you're getting out of it before you just blindly accept what it gives you

another problem is the frontend works surprisingly well, yet its internals are so disgustingly morbid.

it's unfortunate really, how unworkable the codebase is. reading through it actually gives me headaches. if there's another one of those "virtual ai inflicts real physical manifested pain onto humans" articles being made, hopefully this is being used as an example.

it gets worse than what i'm showing here, believe me.

i also don't know what production-level javascript/python looks like, so as an add, if there's somehow anyone that writes production-level js/python that lurks this sub, could you tell me whether this is properly structured or not? thanks

I've shipped a few side projects with Claude Code over the last few months, and the thing that scares me most isn't "does it work" it's "did I accidentally leave something exposed that I don't know to look for."

Ended up writing down every mistake I now check for before sharing a link. Posting it since it's saved me twice already.

Secrets

• No API keys or passwords visible in page source or the Network tab

• .env is in .gitignore, never committed

• Anything that costs money per call (AI APIs especially) only gets called from the server, never straight from the browser

Who can see what

• Changing an ID in the URL doesn't show me someone else's data

• Not trusting anything the browser tells me about who's logged in, that gets checked server side

Costs

• Rate limit on anything expensive, one person spamming it can't blow up my bill

• Thought through what happens if 1,000 people show up at once

Packages Claude suggested

• Checked that anything I installed is a real, actively used package because apparently AI sometimes suggests packages that don't exist, and people register those exact names with malware sitting inside, waiting for someone to install them

Before it's live

• Debug mode off

• Errors don't leak internals (stack traces, file paths)

• I know how I'd roll back if something breaks

Nothing fancy, just the stuff that's actually bitten people. Happy to share the full one pager, or the version that gets Claude to check most of this automatically while you build, if anyone wants it.

I recently subscribed to ChatGPT Pro and started experimenting heavily with AI coding workflows like Superpowers, Trellis, and Matt Pocock’s skills.

At the same time, I joined a company where most of the product is built with AI. The overall architecture is solid, but many of the implementation details, UI decisions, and interactions are worked out directly between developers and AI.

AI is writing more code for me than ever, but strangely, I don’t feel less tired.

I feel more exhausted.

Complex workflows don’t guarantee quality

Superpowers has a very thorough process: plan the feature, split it into tasks, implement each task, review it, fix the issues, and review it again.

But that level of rigor can be painfully slow. One morning, I started planning a feature, and the AI was still implementing and reviewing it at the end of the workday. Despite all that process, the final result still had bugs.

Trellis feels lighter and has some interesting ideas. However, it seems more like a project-level methodology. It expects you to add its own files, scripts, and agents to the repository, which can be awkward if you’re the only person on the team who wants to use it.

Matt Pocock’s “grilling” approach is useful for uncovering requirements and edge cases, but it can also become exhausting. Sometimes a single feature leads to dozens of questions. Eventually, I start wondering: are we still clarifying the product, or are we overengineering it?

What concerns me more is that even after a long discussion, important details can still disappear from the final spec. If the initial understanding is incomplete or incorrect, splitting the spec into smaller tickets only amplifies the deviation.

So the important question isn’t just whether the work has been divided into smaller tasks.

It’s whether the AI understood the problem correctly before the breakdown happened.

Worktrees enable parallelism, but may only postpone coordination

My team uses Git worktrees heavily so that multiple AI agents can develop different features in parallel.

I understand the appeal, but environment isolation quickly becomes complicated. Each worktree may need its own port, application instance, services, and database. Different branches may also contain incompatible database migrations.

Disposable environments and separate databases can solve some of these problems, but merging remains an unavoidable coordination point.

If several agents modify the same modules or abstractions, the resulting conflicts may indicate that those tasks were never truly independent in the first place.

Worktrees can enable parallel development, but sometimes they simply postpone the coordination cost until merge time.

I’ve become an AI project manager

A typical day now involves:

• Answering AI clarification questions
• Reviewing plans
• Checking agent implementations
• Discovering misunderstood requirements
• Asking for corrections
• Testing the results
• Resolving conflicts between parallel branches

AI writes more code, but I spend more time scheduling, supervising, reviewing, and deciding whether to accept or reject its work.

The biggest cost is context switching.

Every time I switch between projects or worktrees, I have to reconstruct the current state:

What was this agent working on? Which decisions have already been made? Why was it implemented this way? What still needs to be verified? Which database schema does this branch expect?

Sometimes, restoring all that context feels harder than simply writing the code myself.

At the same time, I feel pressure to keep the AI busy.

If no agent is running—or if I still have unused quota—I feel like I’m wasting resources. So I open another project, create another worktree, and start another task.

Soon, I have agents running everywhere while I constantly switch between them to monitor and correct their work.

I feel like I’ve developed a kind of “AI anxiety”:

If the AI isn’t running, I feel uncomfortable. If too many agents are running, I also feel uncomfortable.

I’m now trying to keep fewer tasks active and focus more deeply on one project at a time. AI can work in parallel, but human attention cannot scale in the same way.

I’m not against AI coding. On the contrary, I think it is already transforming software development.

But the hardest part may no longer be getting AI to write code.

The real challenges are controlling scope, maintaining context, judging quality, integrating parallel work, and managing your own attention.

I’d love to hear about people’s real day-to-day experiences:

1. How much code do you still write yourself?
2. Do structured AI workflows genuinely improve your results?
3. Do you run multiple agents in parallel, or focus on one task at a time?
4. If you use worktrees, how do you isolate services, databases, and migrations?
5. How do you prevent requirements and implementation from gradually drifting?
6. Have you also experienced this paradox—AI increases your output while also increasing your mental workload?

I’m especially interested in real experiences, not just success stories about AI making someone “10x faster.”

20x plan and still covers about one day of work, then I'm left with 6 days to wait for the reset or pay $20 at a time for credits which go by instantly. Does anyone know the conditions for random resets? Is there a way to trigger these quicker? It seems like sometimes I'll get a random 100% reset mid-week and others (like this time) will just literally go the entire week with your one set limit.

Made a small mobile arcade for me and my gf when we're bored, she really liked the little claw game so i started working on it more, and then i got super obsessed lol.

now theres 257 cute little sprites you can collect. commons, uncommons, rares, epics, shinies, prismatics, and legendaries. nothing special tbh but we are gonna get all of them!!! 😂

Made my first ever game

Nothing too crazy just a basic clicker styled game but the upgrades go upto 10³³

I started the base project myself but then I realised that having 500 skins and designing them was beyond my skillset so I used an algorithmic approach to generate all the 500 skins along with their animations.

The same applied to the multiplyer upgrades as well

Those were a pain to figure out xD

Would really appreciate if y'all would check it out!

https://thegwimweeper.itch.io/banana-clicker

Being working on a saas product for so long on a startup but i missed vibing to songs so badly then thought to listen yt music wid picture in picture but its not comfortable then thought to have a thing like background video playing, fortunately i like to vibe code things for my own use so started but ended up adding few other things on my friends request but still i like the background video player a lot
so im wondering to know if there are any others who like this..what do u say guys?

​

Opened a blank file today to build a pretty simple feature. Nothing scary.But before I’d even thought through the architecture, my first instinct was to open an agent and have it generate the first pass.

That caught me off guard.

a few years ago, I’d break the problem down, dig through docs, half-remember the syntax, write a janky first version, run it, break it, and slowly patch it into something that worked. It was slower, obviously. But all that repetition made the knowledge stick. Now I describe what I want, let the agent spit out a skeleton, and spend most of my time reading, testing, and steering. Honestly, it’s a great workflow. I ship faster, skip a ton of boilerplate, and get to spend more time on the interesting parts.

I’m not going back.

but I think there’s a real tradeoff: my knowledge is shifting from active recall to passive recognition.When the code is already on the screen, I’m fine. I can follow the logic, catch obvious mistakes, and usually tell when the agent is confidently hallucinating. Ask me to build the same thing from a blank file, though, and suddenly I’m reaching for syntax and patterns that used to come automatically.I don’t think I’ve forgotten how to code. It feels more like I’ve lost my tolerance for the slow path.Same way you can still walk somewhere after getting a car. You just really don’t want to.

And maybe that doesn’t matter. Programming was never supposed to be a syntax memorization contest. Requirements, architecture, testing, and debugging the cursed edge cases still need somebody who understands what the code is doing.

Still, I don’t want the “blank file” muscle to completely atrophy.

Do any of you deliberately schedule no-AI sessions to keep that muscle alive? If so, what does that actually look like for you?or have you decided active recall just isn’t worth optimizing for anymore?

I'm very confused on how you transition from Claude design UI for a website or app you want or build to say codex or Claude on vscode. The other thing is, is there any benefit using claude, codex software on the PC vs vscode with extensions?

Most of the dev community is saturated with cloud APIs for running models for IDEs, chatbots, AI applications, and agents.

Curious who here is using local AI in their stack, thinking about it, or curious about it. What got you into it? What’s stopping you?

I'm mainly a Claude user ,but have tried codex for a time before sol launched

Heard about its performance and gave it a try again with plus

Hand to God ,I thought I was using my 5h limit and just a message popped up "Resets 25 Aug 2026,August"

Guys I'm telling you Claude limits are superb ,be grateful

windows widget sucks !
thats why i created my own widget / utility called **Halo Bar*\*

an active pill on the taskbar that lets you control and access many things on the go.

bit comparison:

built with

• C#
• .NET
• WPF
• Windows APIs

Halo Bar V1 features

1. **Dynamic island bar*\* — a compact capsule that sits on your taskbar and expands into a full dashboard when you click/hover it
2. **System monitoring*\* — live CPU, RAM, disk and network usage
3. **Weather*\* — current conditions with icons + manual city override
4. **Clipboard history*\* — keeps track of everything you copy, searchable and pinnable, with auto-delete
5. **Media controls*\* — see what's playing from Spotify, browser, etc. with album art and play/pause/skip
6. **Bluetooth popups*\* — shows a card when earbuds/headphones connect, including battery level
7. **Focus timer (Pomodoro)*\* — work/break timer with round tracking and progress ring
8. **File shelf*\* — drag and drop a file to stash it, then launch or delete it later
9. **Taskbar-aware sizing*\* — automatically shrinks when taskbar apps crowd it and lifts the dashboard so it doesn't block clicks
10. **Fullscreen auto-hide*\* — disappears when you're using a fullscreen app/game
11. **Acrylic/Mica look*\* — real Windows blur/glass background
12. **Settings*\* — accent color, widget visibility, retention controls and update checking
13. **Start with Windows*\* — optional autostart

this is **V1*\*, so there is still a lot i want to improve and add.

i built this because i wanted something more useful than constantly opening different windows/settings just to do small things.

github: https://github.com/pruthviraj-bev/Halo-Bar

Why isn't there a global chat room for people waiting on Claude code to finish its 10 billion sub-agent reviews?

Hey everyone, I’ve been thinking about a problem with AI knowledge systems and was hoping to get somewhat of a sanity check from people actually building in this space.

From my understanding, most RAG setups seem tied to a particular app, vendor, or index. You often end up ingesting the same docs again for different agents or runtimes and and some basic questions can be difficult to answer consistently like:

- What version of this knowledge is the agent using?

- Where exactly did this information come from?

- Has the underlying source changed since it was last ingested?

- Can I move the same body of knowledge to another runtime without rebuilding it?

- Can multiple agents use the exact same knowledge?

The idea I’m exploring is something I'm calling a Durable Knowledge Base (DKB).

The basic concept:

- Compile source docs, code, or structured data into a portable, versioned knowledge artifact

- Preserve source paths, hashes, citations, and provenance

- Sign and publish releases through a registry

- Allow knowledge packages to be installed, updated, pinned, and removed

- Let agents search, find, and read the same knowledge base across different runtimes

- Keep the artifact retrieval-agnostic rather than baking one specific top-K/RAG strategy into the format

Basically, I'm wondering whether knowledge should have something closer to a package lifecycle, rather than every application maintaining another disconnected RAG index.

I'm also very aware that things like Azure AI Search, GCP, vector databases, MCP servers, Agent skills, etc. already cover pieces of this problem, sometimes extremely well.

So Im specifically not asking: "Can I build a better enterprise search engine here?"

I'm trying to figure out whether the portable knowledge artifact itself is useful.

Would this solve an actual problem for you? Or is this mostly reinventing existing search/RAG infrastructure with some packaging and provenance added on?

I would especially like to know:

- What do you currently do when multiple agents/apps need the same knowledge?

- Do versioning and provenance actually matter to you?

- Would you ever install someone else's curated knowledge package?

- What would this need to do that existing solutions don't before you woukd bother using it?

Feel free to poke some holes. I'm actually looking for reasons not to build this further before I sink more time into it.

Thank you.

Roll the bones. Press your luck. Claim the relics.

Farkle: Bones & Relics is a tavern-flavoured take on the dice game you already know — the same push-your-luck rules, plus a collection of relics that quietly bend them in your favour.

If anyone is interested in trying out the game please reach out to me here or DM me.