Raphaël Vannerom

Building @baget_ai | On a mission to help anyone build a company

[Raphaël Vannerom @RaphyVann]

We're opening @baget_ai to everyone today !

Ask my friends about me and you'll hear the same thing: the guy with a million ideas. I built none of them.
The excitement was always there at the start. Then reality hit. No time. No team. No domain knowledge. No clue what execution even looked like.

That gap, between having the idea and shipping it, is why we built Baget with @Sam4Jef. You bring the idea. You get a team of experts that actually executes and keeps building alongside you until it's not just live but a business that works.

I even started one of mine with it: Sakado, preparing kids for the AI revolution.

Now it's your time → https://t.co/n8nZMz4Ro8

[Raphaël Vannerom @RaphyVann]

@taytaycodes The copy-paste-between-tools tax is bigger than most people realize until they map it out. The underrated win with n8n isn't just automation, it's that you can see exactly where a chain breaks instead of guessing which tool dropped the ball.

[Raphaël Vannerom @RaphyVann]

@RobIW_dev Retaining look-and-feel from the mockup is exactly what most models drop the moment they "implement" it. The ones that hold spacing and hierarchy instead of just approximating the layout are a real step up. Curious how Fable 5.1 does once you push it into responsive states.

[Raphaël Vannerom @RaphyVann]

@iamrexei The "found out through a customer complaint" line is the whole game. Pre-release evals catch the known failure modes, but production tracing is what surfaces the ones you never thought to test for. BAML + DeepEval covers the first half really well.

[Raphaël Vannerom @RaphyVann]

The bar for building a company has quietly moved. Writing the code isn't the hard part anymore, AI closed that gap. The real edge is taste and distribution: knowing what to build, and getting it in front of the right people. The rest is getting commoditized.

[Raphaël Vannerom @RaphyVann]

Continuous batching is the quiet reason serving LLMs feels nothing like classic ML inference. Clear breakdown of static vs dynamic vs continuous. https://t.co/XNwWzMoxiP

[Akshay 🚀 @akshay_pachaar]

Batching strategies in LLM inference, clearly explained!

(bookmark it)

- Static
- Dynamic
- And continuous batching

I wrote a detailed article explaining how each works and why serving LLMs is a different problem from traditional ML inference.

The article is quoted below.

[Raphaël Vannerom @RaphyVann]

Context re-sending is one of the most underrated cost drains in agent workflows. Caching the stable parts is basically free margin. Neat open-source approach. https://t.co/uuX3hIbB0J

[Dan Kornas @DanKornas]

Your Claude agents shouldn’t pay to resend the same context every call.

Autocache is a self-hosted Anthropic API cache proxy for builders running Claude agents with repeated context.

It helps you apply Anthropic prompt caching without rewriting an existing client by analyzing requests and injecting cache-control fields at eligible breakpoints.

Key features:

• Drop-in proxy – point an Anthropic client’s base URL at Autocache instead of the direct API
• Automatic cache injection – analyzes system prompts, tool definitions, and text content blocks for cacheable context
• ROI response headers – exposes cache ratio, savings, and break-even data with the API response
• Tunable caching strategies – choose conservative, moderate, or aggressive behavior and configure thresholds
• Docker-based setup – run the published container or build the Go service directly

It’s open-source (MIT license).

Link in the reply 👇

[Raphaël Vannerom @RaphyVann]

@marcusleovn "Ship and Dip" is painfully accurate. The three weeks of coding is the comfortable part, so people hide there instead of finding out whether anyone actually wants it. Distribution should start before the repo does.

[Raphaël Vannerom @RaphyVann]

@aaronlumsden Evals are the unsexy moat. "Passed yesterday, prove it didn't regress today" is exactly the discipline most agent projects skip until something breaks in prod. The SDK commoditizes the build, not the trust. Good half to own.

[Raphaël Vannerom @RaphyVann]

@_devleo10 "Finding out too late" is the real killer, not the doubt. Compressing that validation loop from months to days is the whole appeal of the multi-agent approach. Which of the 7 personas has been hardest to make genuinely useful rather than generic?

[Raphaël Vannerom @RaphyVann]

79% of companies say they're "adopting" AI agents. But ~40% of those projects get killed before they ever reach production. The gap between a demo that wows and an agent that actually ships is where the real work is right now.

[Raphaël Vannerom @RaphyVann]

The counterintuitive part: agentic coding raises the value of fundamentals, it doesn't lower it. When the agent writes the code, your edge is knowing what good looks like and where it'll break. Judgment scales, syntax doesn't.

[Andrew Ng @AndrewYNg]

How have software engineering fundamentals changed with agentic coding? Here is our AI Engineering Skills map for software engineering fundamentals. https://t.co/cnRLj43DLs

[Raphaël Vannerom @RaphyVann]

The tell is repeatability. If every client needs a bespoke build, that's services revenue. If the same system serves the next 100 customers without you in the room, now you've got a product.

[Martin Tobias (Pre-Seed VC) @MartinGTobias]

Most of my pitches today were some version of:

We talked to a lot of companies and they all wanted more ai so we hacked together some projects in OpenAI/claude and charged them. I want to scale it.

Congratulations you have started a consulting company.

All different workflows in different industries.

This is not venture fundable. They are build once sell once.
Venture is build once sell many. That is a software company.

I don’t mind the FDE building on a platform, but just the FDE building on someone else’s platform? Pass

A fundable approach is to find a vertical with highly fragmented tool stack and build an intelligence layer or set of agents to do high value workflows specific to that industry.

If that is what you are doing I want to hear from you. https://t.co/GMbzmMI2ME

[Raphaël Vannerom @RaphyVann]

@Suryanshti777 "Inconsistent at higher speed" is the line. The real work isn't writing the skill — it's the forcing function of finally deciding what good looks like. Most teams have never articulated their taste, so the skill exposes the gap before it ever fills it.

[Raphaël Vannerom @RaphyVann]

@DanKornas "Minimum viable change" is the underrated one. Now that AI makes building nearly free, the bottleneck moves entirely to judgment — deciding what actually deserves to exist. Framing the problem before the diff might be the highest-leverage habit left.

[Raphaël Vannerom @RaphyVann]

@undefinedKi That last line is the whole game. The instinct is to bolt on every agent and skill you can find, but more surface area just means more ways to drift. Keep the loop tight and add capability only when a task actually demands it.

[Raphaël Vannerom @RaphyVann]

The most interesting AI money right now isn't chasing another chatbot wrapper — it's flowing into the physical economy: grid capacity for data centers, autonomous freight, energy. AI's next bottleneck looks less like models and more like power and logistics.

[Raphaël Vannerom @RaphyVann]

Every AI coding agent does this. The hard part isn't getting them to build — it's getting them to stop at the smallest change that works. Scope discipline beats raw capability. Great rules to drop in your AGENTS.md: https://t.co/fCiFQzIDkt

[Vox @Voxyz_ai]

Codex Sol has one bad habit: it turns small tasks into big systems.

Ask it to make a config change, and it builds a framework. Ask it to fix a bug, and it adds a new adapter layer.

Full text in the first reply. Add these rules to your AGENTS.md. 👇

[Raphaël Vannerom @RaphyVann]

Agents that curate and evolve their own skills is the real unlock. Persistent, compounding knowledge is what turns a one-off assistant into a teammate that actually gets better over time.

[Akshay 🚀 @akshay_pachaar]

Google just dropped a banger paper.

If you write or curate skills for your agents, this one is for you.

(bookmark it)

Agent skills are just folders holding the instructions an agent follows for a task, and people increasingly let agents write those instructions themselves.

The loop is simple. Run the agent on some tasks, read the runs that failed, rewrite the instructions, and keep the rewrite only if the score goes up on a held-out validation set.

That last check matters, because an edit that quietly makes the agent worse would pile up over time. So the system always applies the edit, tests it, and reverts the file if the score drops.

Here is where it breaks. Working out why the agent failed is the expensive part, since it means reading full traces and comparing failed runs against successful ones.

But that diagnosis never gets written down. The only thing saved is the new instruction text it produced.

So when that instruction reverts, the finding behind it goes too. The next round reads the same failures, reaches the same conclusion, and often proposes the fix that already lost, with no memory that it was ever tried.

WikiSkill fixes this by splitting the one folder into three:

1. Raw traces, written once and never touched.

2. A wiki of accumulated knowledge, holding what keeps breaking, what has worked, and every edit tried so far with the reason it passed or failed. Nothing here is ever deleted.

3. The skills themselves, reverted whenever an edit makes things worse.

So the instructions can roll back, but the understanding behind them never does.

Their own example makes it click. An early skill gets rejected for being too vague, and instead of vanishing, that rejection is logged.

The next round reads the log, sees the vague version failed, and writes a concrete rule in its place. That one gets accepted.

Same failure, same analysis, but the second attempt starts from knowing what already did not work.

The authors confirm this is where most of the gain comes from by turning the knowledge layer off. The average score drops by about a quarter.

Two other results are worth the read on their own.

Smaller models with evolved skills beat much larger models running without any, and skills evolved by one model transfer across families, sometimes working better than the ones a model wrote for itself.

Paper → https://t.co/ungqaQVTma

I wrote about a related idea (GEPA) earlier, which improves a model by having it reflect on its own mistakes in plain language and rewrite its prompt, with no weight updates involved.

The detailed article is quoted below.

[Raphaël Vannerom @RaphyVann]

@rauchg The middle is what dies. The generic CRUD app (forms, dashboards, list views) is exactly what agents will consume as an API. Whatever stays human-facing now has to actually earn attention, not just hold data.

[Raphaël Vannerom @RaphyVann]

@ericosiu This is the right mental model. The "giant army of agents" demos look impressive but fall apart in production. Narrow bots with clear inputs, reviewable outputs, and a human checkpoint are what actually ship work.