Dinner Decoder

Scan your fridge or pantry, find recipes around what you have, and keep your kitchen inventory in one place. Make deciding what's for dinner easier.

Comment

Inspiration

The idea came from a pretty normal moment: standing in the kitchen thinking I need to figure out what to eat for dinner tonight, and not having a good answer. I looked around to see if an app already did this, and found the options pretty sparse. That gap became Dinner Decoder.

What it does

You open the app, point your phone at your fridge, pantry, or countertop, and scan what you have. The app identifies the ingredients, filters out anything that isn't actually food, and tells you what you can cook from what's available. No calorie counting, no macro logging, no meal plan to fall off, just a real answer to what's for dinner.

How we built it

One of the earliest decisions was how to handle recipes. My original assumption was that I could connect the app to recipes that already exist online, since there are millions made by real people. I was advised against that because of licensing, scraping, and attribution issues, so I went a different direction and generated our own recipe data instead.

That created a different problem: how do you make sure an AI-generated recipe is actually something a person can cook? It's easy for a model to produce something that sounds plausible but has bad proportions, missing steps, ingredients that never get used, impossible cooking times, or instructions that contradict each other. I built a pretty strict recipe validation and linting process to catch those problems, along with filters so the ingredient recognition system focuses on actual food instead of trying to turn random objects in frame into ingredients.

The app was built with React and Expo for multiplatform development, and it's live on both the Apple App Store and Google Play.

Challenges we ran into

The biggest mistake I made was assuming a PRD and an MVP document were enough to manage AI agents through a large project. They're not. They're a starting point, but once a codebase gets large and multiple agents or sessions are involved, you need much stronger governance.

I learned this through context problems. The AI created a lot of notes, planning documents, and session summaries, which felt useful at first because everything was being documented. The problem was that the project changed quickly, and those documents didn't automatically stop being treated as truth once they were outdated. Something written three days earlier could be completely wrong after a redesign, but an agent might still pull that file into context and make decisions based on it. It wasn't always inventing something from nothing. Sometimes it was confidently repeating information that used to be true.

I realized context has to be maintained the same way code does. Old documents become a kind of technical debt. I needed to prune them, consolidate them, remove decisions that no longer applied, and keep a smaller set of current documents that actually represented the state of the project.

Agents can also start creating their own constraints if you're not careful. At one point Claude had effectively decided the project shouldn't use SVGs or animated SVGs, and kept referring to that as an established rule, even though it wasn't one I'd intentionally created. Somewhere along the way I probably accepted a suggestion or let a temporary decision become permanent, but it showed me how easily an AI can turn a local decision into project law.

The other big lesson was design. I waited too long to develop a strong visual system. The app got a warm green, food-focused direction that I like, but it still doesn't have the motion and polish I want. The early version was much closer to text, buttons, and recipe cards. By the time I understood what I wanted the product to feel like, I was already about three quarters of the way through building it, and adding a full motion system at that point was a major undertaking, not a small styling task.

Accomplishments that we're proud of

It's still probably the part that feels the most surreal: I can tell somebody I made an app, and they can actually search for it and download it. There's a big difference between thinking you might be able to make software and actually seeing something you built sitting in an app store.

I went through the whole process, from an idea, to specifications, to agents, to code, to debugging, to design problems, to release. Dinner Decoder isn't perfect and there's a lot I still want to improve, but it exists, and it's on both major app stores.

What we learned

I've changed my mind about the obsession with one-shotting things with AI. There's a lot of content out there about giving a model the perfect prompt and having it build an entire product in one go, and I don't think that's what quality actually looks like. Humans change their minds. We notice things after we see them. We realize a flow feels wrong, or find a better visual direction, or discover that a decision was fine for the MVP but wrong for the real product. Iteration is not a failure of the process. It is the process.

AI can write a lot of code and move fast, but taste still matters. Someone has to look at the result and say this technically works, but it's not what I want the product to become. My job wasn't just asking the AI for code. It was directing it, deciding what mattered, catching when the project was drifting, and changing course when necessary. I also learned how to orchestrate work across multiple AI tools instead of expecting one agent to do everything. I learned more about engineering through the failures, bugs, bad architectural choices, stale documents, broken flows, and design problems, than I would have from watching tutorials that only show the clean version someone else already figured out.

What's next

One of the biggest features I still want to add is internet recipe search for cases where Dinner Decoder can't find a strong internal match. There are millions of real recipes online that could help someone with a weird combination of ingredients or a partial match, and I want to figure out the licensing and technical side of doing that correctly.

I also want to keep improving the visual design: motion, onboarding, transitions, better hierarchy, and a more premium feel. The current version is the first real version of something I plan to keep building on.

Beyond this app, the experience made me want to build more things: more hackathons, more complicated systems, and getting better at directing AI-assisted development. The governance habits I had to build because of the problems on this project, cleaner context, active pruning, clearer design specs, and more deliberate rules for agents, are things I'm carrying into whatever's next.

What we learned

What's next for DinnerDecoder

Built With

Share this project:

Updates

Submission history