Cooking with AI: How I Built a Homemade ERP for My Kitchen

The Dream That Wouldn't Cook

I've been a cook for as long as I can remember, but my real obsession was always systems. I studied computer science in college, but after graduation, I barely wrote a line of code. I'd sketch out meal plans and inventory sheets, but turning them into something that actually ran—that was beyond me. Every time I tried to build a little app to manage my pantry, I'd hit a wall. The blueprint was in my head, but my fingers couldn't translate it to a keyboard.

Then, a few years ago, I got tangled up in the corporate world of enterprise software. I worked on digital transformation projects for big food companies, then joined a company that made enterprise resource planning (ERP) systems, and later moved to a consulting firm. All that time, I was watching how businesses track ingredients, manage suppliers, and balance their books. Slowly, a model of how a kitchen should run took shape in my mind. I could see the flow: how a recipe turns into a shopping list, how a pantry count turns into a reorder, how a meal prep turns into a cost ledger. But I couldn't build it. Without code, the model was just a pretty picture.

Then AI came along, and everything changed.

From Recipe Cards to Real Systems

Now, after months of tinkering, I've got a system running in my kitchen. It's not fancy, but it works. Every recipe I cook generates a list of ingredients, and those ingredients update my pantry count automatically. When I run low on something, the system suggests a shopping list. It even tracks the cost of each meal—right down to the cost of the spices I used. The best part? I can just ask it, in plain English, "How much olive oil do I have left?" and it tells me. No clicking through menus, no spreadsheets.

But getting here wasn't a smooth ride. I hit more potholes than I can count, and a few times I wanted to delete everything and start over. Here's what I learned, the hard way, so you don't have to.

Pitfall #1: Obsessing Over the Interface

When I first started, I spent all my time on how the system looked. I arranged buttons, fiddled with field layouts, and made sure the color scheme was pleasing. I thought that was the real work. Then I realized—it's not. The heart of a kitchen system is how a recipe becomes a grocery list, how a grocery list becomes a pantry update, and how a pantry update becomes a cost figure. I had let each recipe module calculate its own costs, and the numbers never matched. I'd add up what I spent on groceries, and the system would say I spent something else. It was a mess.

So I tore it down and rebuilt it. Instead of having each recipe track its own costs, I made every recipe just spit out a list of ingredients. Then a single, central engine handled all the cost calculations. Each ingredient got a rule: when it's used, deduct this much from the pantry; when it's bought, add this much to the cost ledger. All the numbers flowed into one big table, and my meal cost report was just a view of that table. That's when things finally clicked.

The lesson? Don't get distracted by the shiny buttons. Focus on the flow of data. In a kitchen, that's the recipe-to-ingredient-to-cost pipeline. Keep it centralized, make it easy to change, and you're golden.

Pitfall #2: Mixing Too Many AI Models

Since I can't code, I used AI to write all the code for me. But early on, I made a big mistake: I used different AI models for different parts of the system. I thought, "This model is great for logic, that one is great for natural language—I'll use each where it shines." Wrong. The code they produced was like two different chefs with completely different styles. One used metric measurements, the other used imperial. One used one naming convention, the other used another. When I tried to fix a bug in one part, it broke the other. It was a nightmare.

Even worse, I let different models take turns editing the same piece of logic. The first model would write a function, then a second model would come in and rewrite it because it didn't understand the context. The result was code that looked fine piece by piece but fell apart when I put it together. Debugging was torture because every segment looked correct on its own.

I finally settled on one model—GLM5.2—and used it for the entire project. The code became consistent. I could predict how it would handle a new feature, and when something broke, I could trace the logic because the style was familiar. If I'd done that from the start, I'd have saved myself weeks of frustration.

Takeaway: when you're using AI to build something, don't get greedy. One good model is better than three great ones. Stick with it, and you'll have fewer surprises.

Pitfall #3: No Version Control

In the beginning, I didn't use Git. I saved files with names like "final_version2" and "really_final_v3" in a folder. Then one day, I made a big change to the core logic—the part that calculates costs—and it broke everything. I tried to go back to a working version, but there wasn't one. I had to rewrite the whole thing from scratch. That happened more than once, and each time, I lost days of work and a bit of my sanity. Plus, the AI tokens I burned rewriting code were money down the drain.

Eventually, I set up Git properly. I made a branch for each major feature, kept the main branch stable, and only merged code that I'd tested. When I broke something, I could revert in ten minutes. I also got into the habit of pushing my work to the main branch every evening, so I had a clean checkpoint to fall back on.

If you're building a system on your own, you have no safety net. Version control isn't optional—it's your lifeline. Without it, you're writing on a cliff edge, one wrong move away from losing everything.

Pitfall #4: The Hidden Trap of Conversational Interfaces

The coolest part of my system is that I can talk to it. I wrapped my modules in something called MCP (Model Context Protocol), which lets my AI assistant call functions directly. I can say, "What's the cost of tonight's dinner?" and it calculates it. But this introduced a sneaky bug.

At first, I had some calculations happening in the user interface—like the tax on groceries or the total of a shopping list. When I used the interface, the numbers were right. But when I asked the AI conversationally, the numbers were wrong. Why? Because the conversational layer just passes parameters to the backend and gets results. It doesn't run the front-end code. So the total was missing the tax, and suddenly my cost reports didn't match my receipts.

It took me ages to figure out. The interface showed one number, the conversation showed another. I sat there, staring at two different totals for the same meal, completely baffled.

Finally, I fixed it by moving all calculations into the backend. Now, the front end and the conversational layer just pass data back and forth—they don't do any math. I also added a double-check: the system calculates every number two different ways, and if they don't match, it stops and flags an error. That way, nothing slips through.

The lesson here is that if you're going to let people talk to your system, every calculation has to live in the backend. The conversational layer won't fill in missing pieces for you. In a way, building a talk-to-your-kitchen interface forced me to write cleaner code. That was a silver lining.

What AI Really Gives You

After all this, I've come to a realization: AI didn't make development easy. It just made it possible for one person to build something that used to require a team. The hard part—thinking through the business logic, the flow of ingredients, the cost rules—that's still on you. AI writes the code, but you have to know what the code should do.

These four pitfalls weren't one-time mistakes. I hit them over and over, and each time, I paid the price in time, energy, and self-doubt. But in the end, the system works. It's not perfect—some modules need polishing, the reports could be better, and sometimes it mishears what I say. But the other day, I asked it to generate a monthly cost report, and it did. All by itself.

That was the dream I'd had for years, finally real. And it tasted pretty good.