"Anyone can cook."

Source: Pixar fandom wiki

Gusteau’s manifesto in my favourite Pixar movie, Ratatouille, could just as well be "Anyone can code" were the film set in late 2025. The spirit of the message would be no less correct, and no less threatening to the established order.

The film’s arc mirrors exactly what we are facing in software right now. LLMs and agentic coding tools are making good on a promise that’s been science fiction for so long that we’re having a hard time believing it. And like the characters in Gusteau’s kitchen, we have choices to make about how we respond.

When I look at the cast, I don’t just see a rat and a bunch of chefs. I see the archetypes of our modern tech landscape—and one pairing in particular that captures exactly what it feels like to work with an LLM.

Linguini and Remy: the prompt engineer and the model

Linguini has the desire for greatness and the willingness to experiment, but none of the technique or skill. He’s clumsy, gets in his own way, and struggles to translate vision into execution. He is the non-technical teammate with product sense and ambition who used to get bogged down in syntax, grammar, and the opaque "rules of software" the moment they tried to build something themselves.

Remy represents capability. Raw talent, insatiable curiosity, the ability to taste a dish and know exactly what’s missing. But he can’t interact with the human world directly. He needs someone to be his hands.

The pairing works; they go together like Cheval Blanc 1947 and “some fresh, clear, well-seasoned perspective.” Linguini provides intent, context, and the ability to operate in the world. Remy provides the skill that Linguini lacks. Neither can run the kitchen alone. But together, they turn a garbage boy and a rat into a head chef.

If you’ve ever watched a non-technical founder iterate on a product with Claude or Codex, you’ve seen this dynamic play out. The human knows what they want, has taste, and understands the problem. The model has the capability to translate that into working code. The human learns to communicate better; the model executes what the human can’t. They form a feedback loop that gets better over time.

If "anyone can code" is becoming true, this is exactly how it happens.

The rest of the kitchen

Colette: the senior dev who knows the “right way”

Colette is the embodiment of a seasoned software developer. Highly skilled. Battle-tested. She knows the "right way" to do things and is understandably suspicious of anything that might lower standards or cut corners.

She’s also the one who struggles most to see where creativity and thinking outside the box could achieve a better outcome—not just a correct one. She’s earned her place through discipline and hard work, which makes it harder to accept that the rules might be changing.

If we’re being honest, a lot of us live in Colette’s headspace when we see code written by non-traditional folks with the help of an LLM.

Chef Skinner: the unprepared exec

Chef Skinner is the CEO who never saw this coming. He’s too busy squeezing the last drops of value out of a failing brand, repackaging old dishes as "new" without actually innovating.

He represents the exec who reacts to LLMs with fear and an impetus to protect the brand: "We can’t let people generate code; it’ll hurt quality." Or, "Let’s slap ‘AI’ on our existing product and hope nobody notices."

He’s not thinking about what’s possible with a new ingredient in the kitchen. He’s thinking about how to protect the logo on the sign and maintain the status quo.

Horst: "Give them what they ordered"

Horst is the grizzled veteran who knows how to run a tight ship. At one point, in the middle of the chaos, he blurts out:

"I don’t know, why don’t we… GIVE THEM WHAT THEY ORDERED?!"

He is tantalizingly close to the right insight. But I would swap "ORDERED" with "NEED."

That’s the tension in most client relationships as I see it: we frequently give customers the software they ordered and miss the much bigger gap between what they ordered and what they need. There’s a huge opportunity cost hiding in that delta, and we don’t always stop long enough to calculate it.

Horst is also the one who bails when Linguini tells the truth about the rat in the kitchen. Vision is on offer, but he can’t see it. He walks out, and misses out on what turns out to be a very successful business venture.

Anton Ego: the purist

Anton is the purveyor of ancient wisdom and strongly held opinions. He’s made a career out of pronouncing what counts as "real" cooking.

In our world, he’s the methodology critic: Agile, XP, Scrum, TDD—pick your flavour. He’d be just as skeptical that "anyone can code" as he was that "anyone could cook," because his entire identity is built on the assumption that only a select few can truly do it properly.

We all have a bit of Ego sitting in the back of our minds.

The wave we’re riding

We’ve seen hints of this moment before. Low-code/no-code tools promised to empower colleagues who wanted to move faster and achieve better outcomes. We were quick to point out the limitations compared to custom software: technical debt, multi-vendor lock-in, messy automation, and a pile of weird dishes left for the consultants to clean up.

Sometimes we were right. Sometimes we were just channeling Colette with our arms crossed.

But this new wave is different in scale and impact. LLMs and agentic coding tools aren’t just clicky UI builders or visual workflow tools. They can translate a plain-language idea into working code, wire together systems that used to require multiple specialists, and iterate based on feedback in a way that feels eerily like pairing with a senior dev who never sleeps.

It’s audacious, and it’s working. The "anyone can cook" moment is happening, whether we choose to taste the dish or not.

The choice

We have a choice at this point in time.

We can hold tightly to the status quo like Colette and Skinner, insisting that nothing counts as "real software" unless it passes our particular techniques, uses our favourite frameworks, or adheres to our rituals.

We can be like Horst and walk out when someone reveals there’s a rat in the kitchen—a weird new tool, a non-traditional developer using an LLM, or a business partner building something on their own.

We can sit in judgment like early-film Ego, secure in the certainty that we know what "real" software development looks like.

Or we can pay attention to what’s actually happening.

Here’s the pattern I keep seeing: we say we want to "give clients what they need," but when faced with LLM-powered teams who can build what they want faster to validate their idea sooner, we suddenly become the snooty demi-chef de partie. We fall back to what we know—serving exactly what was ordered, plus a side-dish of our preferred framework and a dessert of dogmatic methodology.

Then we’re surprised when the dish misses the mark and the critics leave us with a bad review.

There’s a certain hubris in delivering software this way. I’m not suggesting we throw out years of experience or abandon practices that keep systems from collapsing. But it is ironic that, in a moment where "anyone can code," I see so many responding by protecting the kitchen instead of inviting more people into it.

What Ego learns

The most poignant moment in the film is the transformation of Anton Ego at the end.

Confronted with the undeniable evidence that challenges everything he believed, he doesn’t double down. He doesn’t write a scathing review about how the dish wasn’t "real" cooking. He writes one of the most honest admissions in any story about expertise being humbled:

Not everyone can become a great artist. But a great artist can come from anywhere.

He was served a dish that moved him—"rocked him to his core," as he puts it—and he had the humility to admit it—even though it meant revising his entire worldview.

Becoming a better Linguini

Our job is to master the Linguini role: the provider of intent. We need to get over the ego of doing it all by hand (Colette) and embrace the leverage of the tool (Remy). Because we actually have an advantage over the ‘real’ Linguinis: we know what good code tastes like.

This means developing taste. Our advantage as those with pre-AI programming knowledge is not the monopoly on syntax, grammar, or software skills. It is our ability to tell the difference between a dish that merely compiles and one that actually solves the problem, delights the user, and sustains the business.

It means learning to communicate intent. The Linguini-Remy partnership only works in the film because Linguini learns to guide, to course-correct, to provide context. The better we become at this, the more capable the pairing becomes.ai

And it means helping others cook. Instead of guarding the kitchen, we can help the Linguinis in our organizations tell better stories, avoid dangerous combinations, and understand why some ingredients don’t belong together.

Our long-held monopoly on coding knowledge is being broken apart, and that’s ultimately a good thing. If anyone can code now, our job isn’t to keep people out of the kitchen.

Our job is to help them cook something worth serving.

Dave Mosher is a Principal Consultant at Test Double, and has experience in legacy modernization, agentic coding, and explaining CORS poorly to people who didn’t ask.

GIFs source: Giphy