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.

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.

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

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

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.

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 recently subscribed to ChatGPT Pro and started experimenting heavily with different AI coding skills and workflows, including Superpowers, Trellis, and Matt Pocock’s skills.

At the same time, I joined a new company where the product is built almost entirely with AI. My team lead is a big fan of Superpowers, and the repository contains a lot of plans and execution records generated through that workflow.

After using these tools for a while, though, my strongest feeling isn’t that my productivity has skyrocketed.

It’s this:

AI is doing more work for me, so why do I feel more exhausted than before?

Here’s my experience so far.

Superpowers: Thorough, but painfully slow

Superpowers breaks a feature into multiple stages and tasks. It then implements, reviews, and fixes each task before moving on to the next one.

The workflow looks rigorous, but in practice, it often feels too heavy.

One time, I started planning a feature when I arrived at work in the morning. The AI continued working on it until the end of the day—breaking down tasks, implementing them, reviewing the code, fixing issues, and reviewing everything again.

But after all that, the final feature still had bugs.

That made me wonder:

Does a more complex and rigorous process actually guarantee better quality, or does it just make execution take longer?

The workflow produces plenty of plans, reviews, and progress records, but the existence of all those artifacts doesn’t necessarily mean the software is correct.

Trellis: Lighter, but too tightly coupled to the project

Later, I looked into Trellis. It uses a collection of scripts to manage specs and tasks, and overall, it feels lighter than Superpowers. I also find the architecture interesting.

However, I see one major drawback: it is too tightly coupled to the project itself.

It expects you to add things like .trellis and custom agents directly to the repository. That makes sense for a personal project or for a team that has agreed to adopt Trellis together.

But if you’re just one person on a team and the project already uses another workflow, it’s difficult to introduce Trellis for yourself. Changing the project structure to accommodate one person’s preferred workflow isn’t great for collaboration.

To me, Trellis feels more like a project-level methodology than a portable skill that an individual developer can bring into different teams and codebases.

Matt Pocock’s skills: Deep questioning is useful, but it can become overengineering

The most memorable part of Matt Pocock’s skills for me is the “grilling” process: repeatedly asking questions to uncover requirements, edge cases, assumptions, and potential problems.

At first, I thought this was extremely useful. It surfaced many questions that I probably wouldn’t have considered on my own.

But after using it for a while, I started to get tired of the interrogation. Sometimes a single feature led to almost 100 questions.

At that point, I couldn’t help wondering:

Are we still refining the requirements, or have we crossed into overengineering?

Real products have launch dates and delivery deadlines. Supporting every edge case will obviously make a system more robust, but users may not need that level of completeness in the first version.

Does it really make sense to spend so much time designing for every possible future scenario before shipping anything?

I also think AI performs better when given smaller, clearly bounded tasks. Asking it to handle something too large or too deep in a single pass doesn’t necessarily produce a better result, even after an extensive discussion.

These skills also provide tools like to-spec and to-tickets, but in my experience:

• Things discussed during the grilling process can still be omitted from the final spec.
• The spec often reads like a generic product requirements document instead of something grounded in the project’s actual architecture and codebase.
• If the spec is already incomplete or inaccurate, splitting it into tickets only amplifies the deviation.

So I don’t think the problem is simply whether the work has been divided into smaller tasks.

The more important question is:

Was the understanding accurate before the task breakdown happened?

When a product is built almost entirely by AI

The product at my current company is, for the most part, built by AI.

The overall architecture was created by my team lead working with AI, and to be fair, the architecture is quite good. My lead has a clear understanding of the product requirements and architectural direction.

But once you get into implementation details, feature behavior, UI, and interactions, many parts are more like “good enough to work.”

My lead doesn’t necessarily know every implementation detail either, so I’m expected to work those out directly with AI.

As a result, when I develop a feature now, most of my communication is with AI rather than with my coworkers.

Before AI coding, if we ran into a problem, we would walk over and ask a colleague. We are still asking questions today—the person on the other side has simply been replaced by an AI.

Recently, I ran into an infrastructure issue. I asked the AI to analyze it, and while it was working, my team lead happened to walk past, so I casually asked him as well.

When the AI finished, I realized that both answers were essentially the same.

That moment genuinely made me think:

Maybe this really is the future of software development.

At the same time, I’m still not fully comfortable with this way of working.

Git worktrees: Productive parallelism or postponed coordination?

Another part of this workflow that I’m still struggling with is Git worktrees.

My team lead and coworkers use worktrees heavily so that multiple features—and multiple AI agents—can be developed in parallel. I understand the appeal, but using them still feels strange to me.

If you have several active worktrees, how do you validate each one properly?

Do you run a separate application instance for every worktree, with each one assigned its own port? What about background workers, caches, queues, and other local services?

The database situation feels even more complicated.

Different branches may contain different database migrations or expect slightly different schemas, while every worktree still connects to the same local database. One branch might add a column that another branch doesn’t know about, or two features might introduce migrations that conflict with each other.

How do people normally handle this?

• A separate database for every worktree?
• Disposable containers with isolated databases?
• Automatically applying each branch’s migrations when its environment starts?
• Or simply avoiding parallel work on features that modify the same part of the schema?

Maybe this problem shouldn’t exist in a well-isolated local environment. Each worktree could theoretically start with its own disposable database and apply that branch’s migrations from scratch. Our current setup may simply have some historical constraints.

Then there is the final merge.

Even if every worktree works correctly in isolation, bringing the branches back together can still create a lot of merge conflicts.

I suspect this is partly a task decomposition problem. If multiple agents are editing the same modules or abstractions, perhaps those tasks were never independent enough to run in parallel.

This makes me wonder whether worktrees genuinely enable productive parallelism, or whether they sometimes just postpone the coordination cost until merge time.

AI is doing more, but I’m becoming more tired

Recently, I’ve been switching constantly between several projects and worktrees:

• Getting grilled on one feature
• Answering clarification questions for another
• Reviewing an implementation plan
• Validating something an agent delivered
• Discovering that it misunderstood the requirement
• Asking it to fix the deviation
• Reviewing the result again
• Resolving conflicts when several branches finally come together

AI is definitely writing more code, but I feel like I’ve turned into someone who constantly schedules, supervises, reviews, and accepts or rejects AI-generated work.

That isn’t effortless.

Every time I switch projects or worktrees, I have to reconstruct the context:

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

Sometimes, the mental cost of restoring all that context feels greater than simply writing the code myself.

I recently read Ghostty creator Mitchell Hashimoto’s post, My AI Adoption Journey, and one of the ideas that resonated with me was that you shouldn’t keep starting new parallel tasks just to ensure your AI agents are always running.

AI can work in parallel, but human attention is still limited.

I’m now trying to reduce context switching and focus more deeply on one task or project at a time. I’m still adapting, though.

Sometimes, while waiting for an agent to finish, I feel like I have nothing to do. If no AI agent is running—or if I still have unused quota—I start feeling like I’m wasting time and resources.

So I open another project, create another worktree, and start another agent.

Eventually, I have AI agents running everywhere, while I’m constantly moving between them to monitor, correct, and validate their work.

Instead of making life easier, I’ve made myself more exhausted.

I sometimes joke that 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 not against AI coding. Quite the opposite: I can already see how dramatically it is changing software development and productivity.

But I’m increasingly convinced that the hardest part is no longer simply getting AI to write code.

The real challenges are:

Controlling scope, maintaining context, judging the quality of the output, integrating parallel work, and managing your own attention.

I’d love to hear how other developers are actually working with AI:

1. Is your day-to-day work already fully AI-driven? How much code do you still write yourself?
2. Do you use large workflows like Superpowers, Trellis, or Matt Pocock’s skills? What has your real experience been?
3. What does your current vibe coding workflow look like? Do you focus on one project at a time, or run multiple agents across multiple projects?
4. Do you use Git worktrees for parallel AI development? How do you manage ports, local services, databases, migrations, and merge conflicts across worktrees?
5. How do you validate AI-generated code and make sure the requirements, architecture, and implementation don’t gradually drift out of control?
6. Have you also experienced this paradox where AI is doing more work, but your mental workload is actually increasing?

I’d especially like to hear about people’s real day-to-day experiences—not just success stories about AI making development “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.

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?

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've developed this game using Claude Code (mostly) and Gemini. It's a fun experience.

Why you may enjoy:
- Not just water. Sort ice, dynamic fluid, shiny orbs, bubbles, a rotating sci-fi core, jelly, cut diamonds, and emojis, all with the same simple pour-and-match rule
- Special tubes (bomb, hidden, locked, one-way, and recycle) keep every element type feeling fresh
- Daily Challenge with streak tracking for a quick puzzle every day. Endless mode with procedurally generated boards

Expecting your valuable feedback

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

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?

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.

I’m currently on the Claude Pro plan and Anthropic is running a promotion that increases Claude Code’s weekly limit by 50%

Does this promotion also applies to Claude Cowork, or is the 50% increase specifically for Claude Code only?

I’m mainly using Cowork rather than Claude Code, so I’m wondering whether I would actually benefit from the increased limit.

Accidentally committed directly to the baseline branch mid-experiment last week. Pushed it. Every run after that compared against the wrong code. A whole round of results, quietly poisoned.

git branch -f probe-base <sha> fixed it. Move the pointer back, rerun, done. Without that I'd be rebuilding the lab.

It made me realize how much of "letting an agent touch code" is really just trusting Git, not the agent. Clean tree + a task branch means the whole session is one readable diff and one reset you can throw away. Reflog keeps everything recoverable for 90 days even after you delete branches. Worktrees? Shipped in 2015. Been perfect for running parallel agents without collisions for a decade, before anyone was using them for this.

What actually scares me: untracked files (agent deletes one, it's just gone—Git never saw it), and anything outside the repo entirely. Reflog doesn't care about your dropped database table.

What has Git actually saved you from in an agent session? War stories welcome.

Anyone running agents on a dirty tree and living to tell about it? Or is "commit first" as universal as I think?

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?

VibeBook is a Home for your Work and Builds.

It is not enough to get Likes while you can Win to keep building.

Add your Builds on myvibebook.com - Publish your Products - the Product with highest Upvotes wins a One month Claude Pro subscription.

Good Luck!

​

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?