Two years ago RAG was the default answer to "how do I make an LLM know my data." Chunk it, embed it, retrieve top-k, stuff it in context. Every tutorial, every framework, every "AI wrapper" startup pitch deck had the same diagram.

I don't think that default holds anymore, and I've been rebuilding around it for the past few months.

Three things broke the old assumption for me:

1. Context windows got cheap. When you can dump 200k+ tokens for pennies, "retrieve only the relevant chunk" stops being the obvious optimization - it becomes a lossy compression step you're paying latency and accuracy for, not saving cost on.

2. Chunking is still the weakest link nobody wants to admit. Semantic chunking, sentence-window, parent-child - every trick papers over the same problem: you're guessing where meaning boundaries are before you know the query. Agentic/iterative retrieval (let the model decide what to fetch next, over multiple turns) beats static top-k retrieval on every eval I've run, just at higher latency cost.

3. Fine-tuning got more accessible again. For narrow, stable domains, a lightly fine-tuned small model + light retrieval now often beats a heavy RAG pipeline on a frontier model - cheaper per query and more consistent.

Happy Friday!

Looking back on your week, what was something you're proud of?

I started using Claude early in university, long before I became a founder.

At first, I was skeptical. Like a lot of developers, I thought: there s no way an AI can actually understand a real codebase.

Then I started using it seriously.

In the second half of the year, I wanted to use some kind of lead magnet that I sent to people in exchange for their email address.

My questions are for observing purposes:

Genuinely curious, because I am on the making side of this and I want to know what we are getting wrong.

We build real-time face and voice models, so demos are most of how anyone judges us. The tell I have become allergic to in our own material is the cut. If a video edits right at the moment the product would have had to respond, the edit is doing the work the product could not. Anyone who has built something real-time spots it immediately, because you know exactly what got removed.

The other one is a demo where nothing goes wrong. Real usage has friction, so a flawless run starts to read as rehearsed rather than good.

So what is yours? The moment in a demo where you quietly stopped believing it.

I ve been thinking about a product-design problem that seems simple at first, but gets complicated very quickly:

When should an AI agent just do the thing and when should it stop and ask for confirmation?

The more actions an agent can take, the more useful it becomes.

But the more autonomy you give it, the more important trust becomes.

Every outbound tool now claims it can write emails that sound handwritten. Scrape a LinkedIn profile, pull recent posts, mention a specific detail, and the email reads like a real person spent five minutes on it. Reply rates on individual campaigns can look great for a while. But inboxes across the internet are filling up with the exact same pattern of "I saw you posted about X" openers, and spam filters are getting better at catching bulk sends that mimic personal writing.

I ran outreach fully manual for a while before building any automation around it. No AI, no templates copied across contacts, just reading each person's profile and writing something specific to them. That got a reply rate around 25%, which is high for cold email by most benchmarks. When I started automating parts of it to scale past what one person can write by hand, the reply rate didn't hold. Not because the automation was bad, but because the moment personalization becomes systematic, it starts pattern-matching to every other automated email a prospect has already seen that week.

Genuinely trying to understand this before we launch something later this year. Every founder story says we launched on PH and got X users, but for every one of those there are probably a hundred launches that got 40 upvotes and disappeared by evening.

Curious what actually separates the two outcomes. Is it mostly about hunter reputation and launch-day coordination (rallying your own network to upvote early) or does the product genuinely need to be compelling enough to travel on its own once real strangers see it?

While building my own product, I realised that how difficult it is to decide when something is actually ready to launch.

There always seems to be one more thing to improve.

One more feature that could make the experience better.

One more bug to fix.

Retention is the hardest problem in SaaS and everyone seems to find the answer from a completely different direction. For some products it's habit formation - streaks, daily emails, contribution graphs. For others it's network effects - the product literally doesn't work if you leave. For others it's switching costs - data gravity, integrations, workflows that are now muscle memory.

What's the one thing you shipped that measurably moved your retention number? Was it something you planned, or did you discover it accidentally by watching what your best users actually did?