Why Cache Invalidation Matters for AI Coding Agents—And How Skip Labs Solved It

There’s a famous joke in computer science: “There are only two hard things in Computer Science: cache invalidation and naming things.” Julien Verlaguet, founder and CEO of Skip Labs, is taking that challenge head-on.

After spending years as a lead programming language designer at Facebook and helping open-source the Skip programming language, Verlaguet noticed something striking: frontend development had undergone a revolution with reactive frameworks like React, while backend architectures remained stuck doing things manually. That observation led him to leave Facebook in 2022 and start Skip Labs—a company built around making reactive programming accessible to everyday software development.

But what exactly is reactive programming, and why should you care?

Understanding Reactive Programming (It’s Not What You Think)

One of the most valuable insights from Verlaguet’s conversation is clarifying what “reactive programming” actually means. The term is loaded—different people use it to mean different things. Some think streaming. Others think event-driven systems.

For Verlaguet and Skip Labs, reactive programming means something much more specific: spreadsheet semantics.

Think about how Excel works. You change a cell, and every formula that depends on it automatically updates. You don’t manually recalculate anything. That’s the mental model Skip brings to programming.

“When I say reactive programming, I mean something that works like a spreadsheet,” Verlaguet explains. “You change something and then the rest of the sheet updates.”

This is exactly how React.js works on the frontend. As a developer, you write your component as if the state is frozen and doesn’t change. When something updates, the framework handles the re-rendering for you. You define the dependencies, but the framework figures out what needs to change.

Skip generalizes this approach into a full programming language and development environment designed specifically for reactive systems.

Why This Matters for AI Coding Agents

Here’s where things get interesting: Verlaguet realized that coding agents are fundamentally reactive systems.

When an AI coding agent makes changes to a codebase, it needs to immediately update its understanding of what’s left to do. It needs to know which tests break, which dependencies are affected, and what the system looks like now. That’s a perfect use case for reactive programming.

Without a reactive system, you’d have to maintain caches by hand. And maintaining caches manually leads to cache invalidation bugs—exactly the problem the joke warns about.

“If you try to write it by hand, you’ll end up maintaining a bunch of caches,” Verlaguet notes. “When you do that, trying to do your cache validation by hand, it’s going to lead to a bunch of bugs.”

Skip eliminates this problem by making cache invalidation automatic. The system knows what depends on what, so when something changes, everything that depends on it updates automatically.

Skip Labs’ Product Strategy: Building on a Vision

Skip Labs isn’t just a programming language company—they learned that lesson early. “We didn’t want to be in the business of selling a programming language,” Verlaguet says. “I heard too many horror stories about anybody who tried that.”

Instead, they’re building products where the Skip language gives them a competitive edge. Their main product is Skipper, an AI coding agent that works in a closed loop. You describe what you want, Skipper generates code, and you can iterate on it. The reactive system under the hood ensures everything stays consistent.

They’ve also built a development environment for JavaScript that brings reactive programming to the frontend, and they experimented with a reactive SQLite clone (currently shelved, though the underlying technology lives on).

What’s fascinating about their approach is how they decide what to build next. Verlaguet breaks it down into two modes:

Vision-driven development happens when you’re going from zero to one. Someone on the team has an idea they believe is a game-changer, and they need to convince everyone else. This is how Skipper came about—a team member pitched it as a vision, and it stuck.

Feedback-driven development happens once you have something in market. But here’s the key insight: Verlaguet listens to people’s problems, not their solutions.

“Users have a very poor sense of what a good solution is,” he explains, “because they only care about their use of it. The solution they propose is usually an easy fix for what they want, but not necessarily a good fit for the whole product.”

This distinction is crucial for language and framework design, where you can’t just ask users “would you want this?” about things that don’t exist yet. You have to have vision and see if it sticks.

Building the Right Team

When asked about hiring, Verlaguet is refreshingly honest: his entire team comes from people he’s worked with before. “100% of my recruiting is through my network,” he admits.

While this might sound limiting, it reveals something important about building companies around new technology. You need people who understand the vision, who’ve proven they work well together, and who can handle the ambiguity of building something that doesn’t have an obvious market yet.

That said, Verlaguet acknowledges this approach won’t work for everyone. If you don’t have an existing network, you need a different strategy. But for teams building on cutting-edge technology, there’s real value in having people who already trust each other and have worked together successfully.

Scaling Without the Headaches

Interestingly, Skip Labs hasn’t hit major scaling issues yet with their products. The focus has been on getting the core technology right and building products that leverage it effectively.

The real scaling challenge with reactive systems isn’t usually the infrastructure—it’s the correctness and performance of the reactive runtime itself. When you’re automatically tracking dependencies and invalidating caches, you need the underlying system to be extremely efficient.

That’s where Skip’s incremental implementation of TypeScript comes in. By making their type checker incremental, they can give the AI agent fast feedback, which is essential for a good user experience.

The Bigger Picture

What Verlaguet is really doing is taking a problem that’s plagued software development for decades—cache invalidation—and solving it at the language level. Instead of asking developers to handle it manually (and inevitably mess it up), Skip makes it automatic.

This is the kind of foundational work that can shift how we build software. It’s not a quick fix or a clever hack. It’s a different way of thinking about how systems should work.

The vision is bold, the technology is solid, and the applications are starting to emerge. Whether it’s AI coding agents, reactive frontends, or future products we haven’t imagined yet, Skip Labs is building the infrastructure for a different approach to software development.

Want to hear the full story? Listen to the complete episode with Julien Verlaguet on Code Story to dive deeper into his journey from Facebook programming language designer to founder, his thoughts on building technology-first companies, and the fascinating details of how Skip actually works under the hood.