Designing Interaction Paradigms
For (Non) Deterministic Actions
COMPANY
Sift
MODEL
B2C
ROLE
Cofounder, Design Engineer
DEVICE
Mobile
TECH STACK
Cursor, Swift UI, Open Router, Python, Firebase, Linear, Figma
Introduction
Home cooking is inefficient; for your time, your money, and your consumption. Sift reimagines how we discover and plan meals, shop, and cook, through AI-powered meal planning. By building menus from the ingredients-up, rather than from recipes-down, Sift optimizes value while maintaining flexibility.
My cofounder and I have been exploring this concept for some time, and it is just about ready for beta launch. Although I started by designing and developing the full platform from scratch, I've recently been leaning on a backend developer to level up our AI architecture while I design and develop the product experience.
Optimized Ingredients
Sift plans around Minimal Purchasable Quantities (MPQs)* to make the most of every ingredient.
No more leftover herbs.
Integrated Planning
Natural language meal discovery and planning keeps grocery lists and recipes adaptable and in sync.
No more cross-referencing.
Personalized to You
Sift learns your preferences and cookbook over time, turning Sunday planning into "that's just what I wanted!"
No more starting from scratch.
*We define the Minimal Purchasable Quantity (MPQ) as the smallest unit of an ingredient that you can purchase at a typical grocery store (i.e., 1 bunch parsley, 1 dozen eggs).
Designing an Efficient Meal Planning Workflow
The magic lies in Sift's AI-powered meal planning. We've developed an LLM architecture that generates meals optimized across minimal purchasable quantities (MPQs), while factoring in variety, user preferences, and any preset recipes.
Basic
"GENERATE MEAL PLAN"
1 dinner
Steak with Chimichurri
2 lunches
Bean Salad with Parsley
No leftover parsley
Variety
Preset Recipe
"USE MY SAVED RECIPE"
1 dinner
My saved Lasagna recipe
1 breakfast
Southwestern Scramble
No leftover onion
Uses preset recipe
User Preferences
"MAKE SIMPLE & CHEAP"
4 lunches
Weeknight Gyro
4 breakfasts
Yogurt Bowl
No leftover yogurt
Cost-effective
Ultimately, the goal is for this system to get so good that the user accepts a meal plan on first try. But in the meantime, the editing workflow is paramount. The user needs to quickly finalize their plan while editing in ways like, "let's make this cheffy-er."
The question becomes…
How can we make meal planning (drafting, editing) efficient, while remaining non-deterministic?
Favoring Natural Language Inputs with Chat
Unsurprisingly, we started with a simple chat interface. We figured this would allow the user to create their meal plan in any which way, tapping into the power of natural language.
To provide some helpful UI without limiting the user, we parsed recipe data from the LLM into card components that the user could expand and scroll to peruse their meals.
Let's just say, we thought we nailed it! The recipe components made it easier to review plans, while the chat interface enabled users to edit and provide feedback in freeform ways.
However, as we started to use the platform more, we found even ourselves dreading the tedium of getting to a final meal plan. Editing required scrolling up and down to recall recipes, waiting for responses, and frequent context loss from the LLM.
Pros
No restrictions on inputs
No restrictions on editing requests
Dynamic request changes (i.e., generate 4 dinners → show me Italian recipes)
Cons
Redundant typing of starting inputs
Unclear data points attached to edits (i.e., change salmon recipe → which one?)
Context loss when trying to integrate new recipes into plans across multiple messages
While prioritizing natural language editing, we made the actual back-and-forth workflow clunky and frustrating.
Natural Language
Workflow Efficiency
Differentiating Deterministic and Non-Deterministic Actions
As we took a step back, we realized that we actually were requiring certain starting inputs in order to generate a meal plan. The user needed to send the number of meals, and then they could add their own preferences. With this in mind, we started to tease out the deterministic actions from the non-deterministic.
Non-Deterministic Actions
INITIAL GENERATION
Misc. Preferences
Ingredients
Other
Diet
Cuisines
Cost
Culinary Level
EDITING
Misc. Preferences
Other
vs
Deterministic Actions
INITIAL GENERATION
# Breakfasts
# Lunches
# Dinners
Serving Sizes
EDITING
Retry
Replace
Keep
= options that could arguably be made deterministic through sliders, selections, etc., albeit at the risk of limiting the user.
Based on this set of actions, we needed to bring the user efficiently and creatively to their meal plan by balancing natural language for non-deterministic actions with UI components for the deterministic actions.
Call it luck or too many hours on Mobbin, but as we scribbled different ideas, we gradually arrived at something that looked quite like the Canvas-Chat paradigm used on many desktop AI applications (i.e., Lovable, Cursor, Flora AI).
Canvas
The main output
Deterministic
Actions
Chat
The editing function
Non-Deterministic
Actions
AI-Powered Meal Planning in a Canvas-Chat Interface
Using a double-pane layout inspired by Amie, we achieved a Canvas-Chat pattern on mobile. For Plan, the top pane represents the working meal plan, while the chat is always accessible and works on the Canvas as appropriate.
Users can perform determinate actions on the Canvas so they always retain agency. Importantly, having a single source of truth supports our backend LLM architecture, eliminating issues with context loss across messages.
… There's More!
We are really excited about this paradigm and the sub-patterns that have emerged as we adapt it across the app. Please let us know if you have any thoughts, questions, or want to learn more!