I Built an MCP Server for My Meal Delivery App and the ROI Math Is Absurd

Seven years ago, CookUnity was a small meal delivery startup operating out of a kitchen in New York. My agency, Litebox, was basically their entire tech team. We built the infrastructure, watched them grow from scrappy to shipping thousands of meals a day across the country. I don’t say this to take credit. They had a great product and great chefs. We just helped them not fall over while they scaled.

Since then, Litebox pivoted from software development into a growth agency focused on dev tools startups. Different focus, same company. But I never stopped being a CookUnity customer.

I live in Miami now. I barely cook. CookUnity sends me six meals every Monday. I spend about five minutes a week picking them (low carb, no broccoli, a mix of whatever looks good across Latin, Asian, American). It’s one of those boring life optimizations that quietly saves you hours.

And then last weekend, I automated even that.

What I built and why

I built an MCP server for CookUnity. For those who don’t know what that means: MCP (Model Context Protocol) is Anthropic’s standard for letting AI models talk to external services. So instead of me opening the CookUnity app, scrolling through the menu, tapping six meals, and confirming my order, I can just tell my AI assistant “pick me six low-carb meals for next Monday, no broccoli” and it does the whole thing.

Browse the menu. Add meals to cart. Confirm the order. Skip a delivery when I’m on vacation. Check what’s coming next week. All of it. Through WhatsApp, through a terminal, through whatever interface your AI agent lives in.

The whole thing took about two hours to build.

Two hours. From zero to a published npm package with 15 tools that fully manage a meal delivery account.

How this actually worked

I’ll spare you the full technical saga, but the short version: CookUnity doesn’t have a public API. So I reverse-engineered their GraphQL endpoints by reading their frontend JavaScript, probing their schema with intentionally broken queries, and piecing together the mutations from error messages.

This is the part where I should tell you it was painful and complicated. It kind of was. Their Auth0 flow requires a cookie jar across three redirect hops. Their authorization header doesn’t use the Bearer prefix (which broke everything for an embarrassingly long time). And their createOrder mutation needs a products array that isn’t documented anywhere because GraphQL introspection is disabled.

But also, I vibecoded most of it. My AI assistant wrote the server, I debugged the weird parts, and the whole thing went from “I wonder if this is possible” to “my order just got confirmed via the command line” in a single sitting.

Published it to npm. Put it on GitHub. It works.

The ROI calculation that makes no sense

Here’s where it gets interesting. Or maybe absurd.

I spend five minutes a week choosing my meals. That’s about 4.3 hours a year. The MCP server took two hours to build. So in pure time savings, I break even in roughly six months.

But wait. I’m also burning Anthropic API credits every time my AI assistant talks to CookUnity’s API. So add a couple more weeks to the payback period for that.

Is this worth it?

Honestly? Probably not, if you’re being strict about the math.

But that’s not really the point.

What this is actually about

The point is that I built a fully functional integration with a commercial service (one with no public API, no documentation, no developer program) in two hours. And it works well enough that I’ll probably never open the CookUnity app again.

Five years ago, this would have been a two-week project minimum. You’d need to set up auth, figure out the API, write the client, build some kind of interface, handle edge cases, test it. A competent developer could do it, but it wouldn’t be a casual thing.

Now it takes an evening.

And the thing that’s hard to convey is how different this feels in practice. It’s not “AI wrote my code for me.” It’s more like pair programming with someone who has infinite patience for the boring parts (the boilerplate, the schema exploration, the retry logic) so you can focus on the parts that actually require a human brain. Like figuring out that CookUnity’s auth flow silently drops cookies if you don’t pass an Origin header.

The five minutes I save each week aren’t the point. The point is the kind of thing that’s now possible to build on a whim. Personal infrastructure that used to require a team and a couple of weeks now takes one person and one evening. The barrier to building custom tooling for your own life has collapsed.

The part I can’t stop thinking about

There’s something weirdly full-circle about this. I spent three years building CookUnity’s tech stack when they were just getting started. Now I’m building my own tiny integration with their service from the outside, using AI tools that didn’t exist when we were their dev team.

The company grew. The tools changed. And the thing that used to require an agency now takes one person and an AI two hours on a Saturday night.

I don’t know if that’s inspiring or terrifying. Maybe both.

But I do know my meals show up on Monday, I didn’t have to think about it, and the whole thing cost me less time than writing this post.