AI Sous-chef team launches an app and bot powered by cloud AI in 2.5 months

The application received a list of ingredients, returned a recipe in the required format, and presented the user with a salad made from raw potatoes and eggplant. The instructions omitted the step for cooking those ingredients. According to the AI Sous-chef team, that was the feedback it received after launch. For developers, this is a familiar problem: a model's response passes technical checks, yet delivers a poor result for the user.

In a case study published on Habr, the team explains how it built an Android app and a Telegram bot with a shared backend in two and a half months. The article's practical value lies in the details: how prompt versions are selected, what checks are applied to responses, and why those checks are not yet enough.

Two clients, a shared backend, and prompts in files

The workflow is straightforward: users photograph their ingredients or enter them as text, confirm the recognized list, and receive meal suggestions. The React Native mobile app and the bot share a server built with Python and FastAPI. Ingredient recognition and recipe generation are split between two cloud models; requests are sent to Yandex's API.

Instructions are stored separately from the code, with a system file and a user file for each task. The required versions are specified in pin.json. For example, recognition can stay on v1 while recipes use another prepared version. A loader reads the files and substitutes values into expressions such as {{ products }}. If a file or a required value is missing, it raises an error.

This makes it possible to revise the wording without rewriting the function that calls the model. There is an operational detail, however: the version mapping is cached in process memory. Changing pin.json requires a restart or a cache clear. The instruction text itself is reread every time the loader is called.

There is also a more significant boundary. According to the authors' description, the ingredient list is inserted into the system instruction as well. Separate files do not, by themselves, separate user data from the rules governing the model's behavior. Its response to unrelated instructions embedded in the input text still needs to be tested.

JSON validation checks structure; recipes need a different assessment

When generating recipes, the application requests JSON through an API parameter, parses the response with json.loads, and checks the expected structure with model_validate. This helps detect responses the code cannot process. But the presence of the required fields says nothing about whether the cooking steps are complete.

After receiving the feedback about raw potatoes, the team began refining the prompt. The original response was not saved, so there is no verifiable before-and-after comparison. The authors do not claim that the problem has been solved.

The repository contains ten test scenarios, including empty input, a single ingredient, fractional quantities, ambiguous text, and other cases. They document extra ingredients, vague instructions, and formatting errors. But there is no single reliable metric yet: prompts, generation settings, and response handling all changed between tests.

Reproducibility is further limited by the use of latest in model addresses. The prompt version can remain unchanged while the model behind that address is updated. Comparable runs require saving the input, response, settings, and the most precise model identification available.

What you can apply to your own product

AI Sous-chef includes an AI_MODE=stub mode: instead of making cloud requests, the application receives predefined ingredients and recipes. These responses are useful for testing the interface and interactions between components. This mode does not measure generation quality because no generation takes place.

For product managers, another limitation of the first release is revealing: users could confirm the recognized list, but could not correct it. They could see an error yet had no way to remove an incorrect ingredient before proceeding. Editing the list became one of the next planned improvements.

According to the article, the main repository is published under GNU AGPL v3.0. It provides a way to study prompt loading, version selection, response validation, and replacing model calls with predefined data. Adapting the implementation requires accounting for the specific application's data structures and caching behavior.

For teams building a similar service, the case suggests a useful workflow: test response handling and content separately, save problematic examples, and compare changes under identical conditions. Keeping prompts in files simplifies maintenance. Evidence of quality still has to come from actual responses.