u/VineetKukreti

Granola is a genuinely good product. I liked the features, and I'm not going to pretend my homemade version is better, because it isn't. But when I wrote down what I actually needed from it, the list was short: record the meeting, give me a detailed summary, pull out a task list. That's a half slice of everything Granola does.

The deciding factor wasn't the tool at all. It was my side of the equation. I already run my own server and database for other things, so the marginal infrastructure cost of building this myself was zero. The only new cost is the Claude API calls doing the summarization. Against $14/month, forever, for a product where I'd mostly use one workflow, the math stopped making sense for me.

That's the part I think people skip in build-vs-buy debates. The question isn't "can I build this" — with LLM APIs the answer is usually yes. The real questions are: what fraction of the features do you actually use, do you already have the infra sitting there, and are you fine owning the maintenance when something breaks at a bad time. If I didn't already have a server, or if I wanted the rest of what Granola offers, paying would clearly be the right call. Building always looks free until you count your own hours.

What I ended up with does exactly three things and nothing else. It's boring. Boring is the point.

Curious where others here draw the line. Is there a monthly price low enough that you don't even consider building, or is it less about the price and more about how much of the product you actually use?

There's an SEO tool running inside my team right now called Simba Buddy. It's not public. It writes articles, does research, drafts LinkedIn posts and YouTube scripts, and handles analysis. My team uses it every day, and we've given a few clients access too. I don't use Ahrefs or SemRush anymore, and those were my default tools for years.

So on paper, building won. One tool, shaped exactly around how we work, two subscriptions gone.

Here's the cost that never shows up on an invoice: I'm the only person who knows how it works. Not "I'm the main maintainer." I mean if I step away for a month, everyone using it is operating a black box. If an API shifts underneath it, or output quietly degrades, my team can't fix it. Clients can't either. That's the real price of ownership, and I didn't fully see it until I was already carrying it.

AI coding assistants made building cheap. They did not make owning cheap. Mostly they made it easier to accumulate more things that only I understand.

My rule now is simple: if I do a task more than 10 times a week, I build a custom tool for it. Under that, the subscription stays, even when it annoys me. Frequency plus subscription cost is the whole formula. A weird workflow alone doesn't justify a build, because weird-but-rare tasks are exactly where custom tools die quietly and nobody notices for months.

Simba Buddy clears that bar easily. SEO work is daily, all day, so the maintenance burden earns its keep. Anything below the line, I'd rather pay someone else to own the black box.

Curious where everyone else lands. Are you building for each task, still riding the apps you subscribe to, or balancing both? And the question I care about most: for the stuff you've built, does anyone besides you actually know how it works?

I burned through half my Fable 5 allowance in 25 minutes. The same kind of session on Opus 4.8 takes me about 2 hours to hit that mark. So the cap isn't really the story. The burn rate is. Fable 5 eats tokens so much faster that "50% weekly" translates to way fewer working hours than you'd assume when you sign up.

Which is why I think "always use the strongest model available" is the most expensive habit in AI-assisted dev right now. For me, Fable 5 is worth it for maybe 20% of my week. The trick is knowing which 20%.

Where it clearly earned its slot: complex builds where I couldn't spec things out properly. I gave it a SimCity-style simulation project with barely any detail, and the level of detailing it produced was on another level. Opus 4.8 gave me a decent result on the same thing. Fable 5 was the clear winner. The gap shows up specifically when the project is complex AND your prompt is thin. That combination is where the extra capability actually converts into saved time instead of just saved ego.

So my routing rule since the cap:

* Regular dev tasks where I have enough information to hand over — clear requirements, known codebase, defined scope — Opus 4.8, every time. The flagship buys me almost nothing there except a drained quota.
* Genuinely complex tasks where I don't have much detail to give: that's what I reserve Fable 5 for. It fills gaps better than anything else I've used.

I burned through half my Fable 5 allowance in 25 minutes. The same kind of session on Opus 4.8 takes me about 2 hours to hit that mark. So the cap isn't really the story. The burn rate is. Fable 5 eats tokens so much faster that "50% weekly" translates to way fewer working hours than you'd assume when you sign up.

Which is why I think "always use the strongest model available" is the most expensive habit in AI-assisted dev right now. For me, Fable 5 is worth it for maybe 20% of my week. The trick is knowing which 20%.

Where it clearly earned its slot: complex builds where I couldn't spec things out properly. I gave it a SimCity-style simulation project with barely any detail, and the level of detailing it produced was on another level. Opus 4.8 gave me a decent result on the same thing. Fable 5 was the clear winner. The gap shows up specifically when the project is complex AND your prompt is thin. That combination is where the extra capability actually converts into saved time instead of just saved ego.

So my routing rule since the cap:

• Regular dev tasks where I have enough information to hand over — clear requirements, known codebase, defined scope — Opus 4.8, every time. The flagship buys me almost nothing there except a drained quota.
• Genuinely complex tasks where I don't have much detail to give: that's what I reserve Fable 5 for. It fills gaps better than anything else I've used.

I burned through half my Fable 5 allowance in 25 minutes. The same kind of session on Opus 4.8 takes me about 2 hours to hit that mark. So the cap isn't really the story. The burn rate is. Fable 5 eats tokens so much faster that "50% weekly" translates to way fewer working hours than you'd assume when you sign up.

Which is why I think "always use the strongest model available" is the most expensive habit in AI-assisted dev right now. For me, Fable 5 is worth it for maybe 20% of my week. The trick is knowing which 20%.

Where it clearly earned its slot: complex builds where I couldn't spec things out properly. I gave it a SimCity-style simulation project with barely any detail, and the level of detailing it produced was on another level. Opus 4.8 gave me a decent result on the same thing. Fable 5 was the clear winner. The gap shows up specifically when the project is complex AND your prompt is thin. That combination is where the extra capability actually converts into saved time instead of just saved ego.

So my routing rule since the cap:

• Regular dev tasks where I have enough information to hand over — clear requirements, known codebase, defined scope — Opus 4.8, every time. The flagship buys me almost nothing there except a drained quota.
• Genuinely complex tasks where I don't have much detail to give: that's what I reserve Fable 5 for. It fills gaps better than anything else I've used.

I've spent the last stretch basically living inside Opus 4.8. It's my default for the messy, multi-step stuff. The agent runs where one bad tool call quietly poisons the next three steps. So when Sonnet 5 landed with the "near Opus quality, costs less" pitch, my first reaction wasn't "finally, cheaper." It was "near is doing a lot of work in that sentence."

Honesty first: I haven't moved my real workflow onto it yet. I'm not going to tell you it saved me X hours, because I haven't run it in anger. What I can tell you is how I'm deciding whether to, because I think that decision matters more than any benchmark screenshot.

The pitch itself is a good one, and from what I've seen it holds up to the claim. If Sonnet 5 really gets you most of the way to Opus for a fraction of the token cost, that changes the math on anything high-volume: classification, extraction, first-draft generation, the stuff you run thousands of times a day. There, "near Opus" isn't a compromise. It's basically free money.

Where I don't touch it yet is the steps that cascade. If a model's output feeds straight into the next tool call with no human in between, a small quality gap doesn't stay small. It compounds. So the line I draw isn't "how good is the model," it's "who catches it when it's wrong." A person checks it next? Cheaper model, all day. It silently feeds step two of five? I'm keeping the expensive one until I've proven otherwise.

And proving it is the part people skip. Don't trust the benchmark, and don't trust the vibe of the first ten prompts. Pull 50 to 100 real tasks you've already run, replay them on both models, and compare the one thing you actually care about, usually tool-call success rate or how often you had to re-prompt. Benchmarks are averaged over someone else's work. Your pipeline has its own weird failure modes.

So my plan is boring: route the bulk to the cheap model, keep the top model on the steps that cascade, and let the replay decide where the line actually sits instead of guessing.

Question for the sub: for those of you who've actually put Sonnet 5 into a real pipeline, where did it hold up next to Opus, and where did it quietly fall down? Especially curious about multi-step agent and tool-use work, not one-shot chat.

Our inbox gets around 120 support emails a day. Two people used to skim all of them just to sort into "urgent / billing / feature request / spam" before anyone actually replied. That sorting step alone ate the first hour of everyone's morning.

So I put together a small classifier to do the sorting. I used BM Builder to stand it up because I didn't want to babysit a whole repo for something this small: describe the job, point it at the inbox, get a working tool. First version was running in an afternoon.

It was also kind of useless on day one.

The problem: I let the model pick the category label itself. Instead of 4 clean buckets I got "Billing", "billing issue", "payment problem", "Invoice question"... about 30 near-duplicates. Downstream routing fell apart because nothing matched anything cleanly.

The fix took ten minutes and it wasn't a smarter prompt. I forced the output into a fixed list. The model has to return one of exactly four strings, nothing else. Anything it's unsure about goes to a fifth bucket, "needs a human," instead of guessing. That one constraint took it from a demo to something the team actually leaves running.

Numbers after two weeks: about 92% land in the right bucket on their own, and the other 8% get flagged instead of silently misfiled. Gives the two of them back roughly that first hour, every morning.

The lesson I keep relearning: the AI part is rarely the hard part. The hard part is pinning down the output so the rest of your system can trust it. Constrain first, get clever later.

Where I'm still unsure is the low-confidence case. Do you route the "not sure" stuff to a human, or just take the top guess and let people correct it downstream? I keep going back and forth on where to draw that line. How are you handling it?

For about a year my side-project routine was: have an idea, describe it to an AI, get back something that technically ran but was missing half the features and fell over the moment I used it. Then I'd burn the weekend re-prompting it into shape. Usually I just gave up.

It took an embarrassing number of these before the obvious hit me: I was handing it one sentence and expecting a finished product. No scope, no plan, no context — so it guessed, and guessed wrong. Garbage in, broken MVP out.

What actually changed things was forcing a planning step *before* any code: write the idea out as a short PRD, a rough tech spec, a data model, and a prioritized list of what v1 actually needs. When the AI builds against that, the first pass is night-and-day better — because it finally knows what "done" means.

I ended up building a small local tool around this loop (a simulated "team" that interviews the idea, writes those docs, then has Claude Code build from them). It's open source — not going to link it in the body since that's not the point, but happy to drop it in a comment if anyone wants to poke at it.

Mostly I'm curious: has anyone else found the planning/spec step is what separates "AI made me a demo" from "AI made me something usable"? What's your process for briefing it?