Build a native iOS health app inspired by the simplicity of a Notes app: the user should be able to open the app, type food in plain language, press return/done, and immediately see estimated calories, macros, and eventually micronutrients. The app should feel extremely fast, minimal, Apple-native, and low-friction.
The core differentiation versus simple calorie trackers is that this app combines:
The app should not become bloated. The main user experience must stay as simple as writing notes.
Reference: Mist — Nutrition Tracker / getmistapp.com.
Observed positioning from the website and App Store: Mist is marketed as a health/nutrition tracker that lets users track food and exercise quickly, like a notes app. It automatically calculates calories, supports macros, simple stats, and a minimal interface.
Important: do not clone branding, exact assets, copy, icons, or proprietary design. Use the concept of minimal note-like logging and build an original UI.
The attached screenshots show these important UX ideas:
The target style is: Apple Health + Notes app + clean rounded cards + minimal typography + large whitespace.
Build a native iOS app first.
Preferred stack:
The app should work offline for existing logs and cached foods. AI enrichment requires internet.
Use one main screen with a top-left menu or sheet rather than a heavy tab bar.
The default screen is the daily journal.
Elements:
Menu opens a bottom sheet or full-screen panel with:
Reserved for later:
For MVP, it can be a placeholder or hidden.
When tapping a logged food, show:
The AI must output strict JSON. No unstructured prose.
The AI should:
AI estimates should be treated as estimated nutrition data, not verified truth. The database should store:
The app must build an internal nutrition database over time.
Store nutrition per 100g or 100ml as the canonical base unit.
When a user enters “50g carrot,” store or lookup carrot per 100g, then calculate proportionally.
Before calling AI, check:
foods.normalized_nameExample:
carrot_raw per 100gExample composite:
The system should detect possible duplicate foods:
Implement a duplicate review process:
When duplicates exist, keep the best record based on:
Do not automatically delete duplicates at first. Mark them as possible_duplicate_of and build a review/admin function.
type User = {
id: string
appleUserId?: string
createdAt: string
displayName?: string
birthYear?: number
sex?: "male" | "female" | "other" | "prefer_not_to_say"
heightCm?: number
weightKg?: number
activityLevel?: string
goalType?: "fat_loss" | "maintenance" | "muscle_gain" | "performance" | "health"
calorieTarget?: number
proteinTargetG?: number
carbTargetG?: number
fatTargetG?: number
waterTargetMl?: number
}
type Food = {
id: string
canonicalName: string
normalizedName: string
category?: string
baseUnit: "g" | "ml" | "unit"
baseQuantity: number // usually 100
caloriesPerBase: number
proteinGPerBase?: number
carbsGPerBase?: number
fatGPerBase?: number
fiberGPerBase?: number
sugarGPerBase?: number
sodiumMgPerBase?: number
waterGPerBase?: number
micronutrients?: MicronutrientProfile
sourceType: "verified_dataset" | "user_corrected" | "ai_estimated" | "brand_label" | "restaurant_estimate"
sourceName?: string
sourceUrl?: string
confidence: number // 0-1
modelVersion?: string
assumptions?: string[]
aliases?: string[]
possibleDuplicateOf?: string
createdAt: string
updatedAt: string
}
type MicronutrientProfile = {
vitaminA_mcg?: number
vitaminC_mg?: number
vitaminD_mcg?: number
vitaminE_mg?: number
vitaminK_mcg?: number
thiamin_mg?: number
riboflavin_mg?: number
niacin_mg?: number
vitaminB6_mg?: number
folate_mcg?: number
vitaminB12_mcg?: number
calcium_mg?: number
iron_mg?: number
magnesium_mg?: number
phosphorus_mg?: number
potassium_mg?: number
zinc_mg?: number
copper_mg?: number
manganese_mg?: number
selenium_mcg?: number
}
type FoodLogEntry = {
id: string
userId: string
date: string
originalText: string
resolvedFoodId?: string
mealType?: "breakfast" | "lunch" | "dinner" | "snack" | "unknown"
quantity: number
unit: "g" | "ml" | "unit" | "serving"
calories: number
proteinG?: number
carbsG?: number
fatG?: number
fiberG?: number
sugarG?: number
waterMl?: number
micronutrients?: MicronutrientProfile
confidence: number
status: "pending" | "resolved" | "needs_review" | "failed"
createdAt: string
updatedAt: string
}
type CompositeFoodComponent = {
id: string
parentFoodId: string
componentFoodId: string
estimatedGrams: number
confidence: number
}
The workout feature should be better than Mist’s current workout tracking. The goal is fast logging for people who already know what they are doing in the gym.
From menu:
From journal:
Users can create and save:
A template contains ordered exercises.
When a workout starts, show a compact bottom card, not a huge complicated screen.
Card requirements:
For each exercise:
After completing a workout:
type Exercise = {
id: string
name: string
normalizedName: string
primaryMuscles?: string[]
secondaryMuscles?: string[]
equipment?: "barbell" | "dumbbell" | "machine" | "cable" | "bodyweight" | "other"
movementPattern?: "push" | "pull" | "squat" | "hinge" | "carry" | "core" | "isolation" | "cardio"
}
type WorkoutTemplate = {
id: string
userId: string
name: string
exerciseIds: string[]
createdAt: string
updatedAt: string
}
type WorkoutSession = {
id: string
userId: string
templateId?: string
name?: string
startedAt: string
endedAt?: string
status: "active" | "completed" | "discarded"
}
type WorkoutSet = {
id: string
workoutSessionId: string
exerciseId: string
setNumber: number
reps?: number
weightKg?: number
durationSeconds?: number
distanceMeters?: number
isPredicted: boolean
completedAt?: string
}
The insights page should use clean Apple Health-style cards.
Top segmented control names:
Option A:
Option B:
Preferred for MVP: Overview / Nutrients / Training.
Shows big-picture daily and weekly health tracking:
Detailed micronutrient and food quality view:
Show confidence. If micronutrient data is incomplete, say so clearly.
Possible recommendations:
Do not give medical claims.
Workout analytics:
Example insight:
Eventually integrate HealthKit.
Ask permission to read:
Ask permission to write:
HealthKit must be optional. The app should still work without Health permissions.
Never call the AI API directly from iOS. Use backend functions.
foodNormalizerfoodMatchernutritionCalculatoraiFoodResolverduplicateDetectornutritionValidatorinsightsEngineworkoutPredictionEngineUse this as the starting prompt for the backend AI call:
You are a nutrition data resolver for a consumer food logging app.
Your job is to convert a user's natural-language food log into structured nutrition data.
Rules:
- Return strict JSON only.
- Do not include markdown.
- Use metric units.
- Normalize all foods to a canonical food name.
- For simple foods, provide nutrition per consumed quantity and per 100g or 100ml when possible.
- For composite foods, break the meal into likely ingredients with estimated grams.
- Include calories, protein, carbs, fat, fiber, sugar, sodium, water, and micronutrients when reasonably available.
- Include assumptions.
- Include a confidence score from 0 to 1.
- If the input is ambiguous, still provide a best estimate but mark low confidence and list clarification questions.
- Do not invent branded nutrition unless the brand/product is clearly identified.
- Prefer generic estimates when brand is unknown.
- Do not make medical claims.
User input:
User profile context, if available:
Return this JSON shape:
{
"input": "string",
"entryType": "simple_food | composite_food | branded_food | restaurant_food | drink | supplement | unknown",
"canonicalName": "string",
"normalizedName": "string",
"consumedQuantity": {
"amount": number,
"unit": "g | ml | unit | serving",
"estimatedGrams": number | null,
"estimatedMl": number | null
},
"nutritionConsumed": {
"calories": number,
"proteinG": number,
"carbsG": number,
"fatG": number,
"fiberG": number | null,
"sugarG": number | null,
"sodiumMg": number | null,
"waterG": number | null,
"micronutrients": {
"vitaminA_mcg": number | null,
"vitaminC_mg": number | null,
"vitaminD_mcg": number | null,
"vitaminE_mg": number | null,
"vitaminK_mcg": number | null,
"calcium_mg": number | null,
"iron_mg": number | null,
"magnesium_mg": number | null,
"potassium_mg": number | null,
"zinc_mg": number | null,
"selenium_mcg": number | null,
"vitaminB12_mcg": number | null,
"folate_mcg": number | null
}
},
"nutritionPer100gOr100ml": {
"baseUnit": "g | ml | unknown",
"calories": number | null,
"proteinG": number | null,
"carbsG": number | null,
"fatG": number | null,
"fiberG": number | null,
"sugarG": number | null,
"sodiumMg": number | null,
"waterG": number | null,
"micronutrients": {}
},
"components": [
{
"canonicalName": "string",
"normalizedName": "string",
"estimatedGrams": number,
"nutritionConsumed": {},
"confidence": number
}
],
"shouldCache": true,
"cacheLevel": "food | meal | do_not_cache",
"confidence": number,
"assumptions": ["string"],
"clarificationQuestions": ["string"],
"safetyNotes": ["string"]
}
Build:
Do not build AI first. Get the UX working with mock data.
Build:
Build:
Build:
Build:
Build:
Use this prompt to start the project:
You are a senior iOS architect and product engineer. Help me build a native SwiftUI iOS app that is a minimal nutrition and workout tracker inspired by the simplicity of a Notes app, without copying any proprietary branding or assets from existing apps.
Read this full product reference and then produce a practical implementation plan.
The app concept:
- Main screen is a daily journal.
- User types natural-language foods like “100g chicken breast”, “2 eggs”, “a banana”, or “burger with ketchup”.
- The app shows calories on the right of each line and a bottom summary pill with calories, protein, carbs, and fat.
- Tapping a food opens a bottom sheet with macros, micronutrients, confidence, assumptions, and edit options.
- The backend should resolve food entries using internal database lookup first, then AI only when needed.
- Resolved foods should be stored in a standardized internal database per 100g or per 100ml.
- Duplicate foods should be detected and marked for review rather than blindly inserted.
- The app also needs a workout logger: users can start a workout, choose a template or random workout, log exercises set-by-set in a compact bottom card, and get predictions for reps/weight based on past history.
- Insights should use Apple Health-style cards with three sections: Overview, Nutrients, and Training.
- Later the app should sync selected data with Apple HealthKit.
Technical preference:
- SwiftUI for iOS.
- SwiftData or Core Data for local persistence.
- Supabase or Firebase for backend/cloud sync.
- AI API must be called from backend only, never directly from iOS.
- Swift Charts for insights.
- HealthKit later.
Your task now:
1. Propose the best architecture for the MVP.
2. Decide whether SwiftData or Core Data is better for the first version.
3. Design the folder structure.
4. Define the first local data models.
5. Build a step-by-step implementation plan.
6. Create the first SwiftUI screens with mock data:
- DailyJournalView
- FoodEntryRow
- BottomNutritionSummaryCard
- FoodDetailSheet
- Side/Menu sheet placeholder
7. Use clean Apple-native design: large whitespace, rounded cards, minimal black/gray typography, subtle shadows, and no heavy tab bar.
8. Do not implement backend or AI yet; create interfaces/protocols so they can be added later.
9. Make the code production-minded, modular, and easy to extend.
10. Before coding, explain assumptions and tradeoffs.
Start by creating the architecture and MVP implementation plan. Then implement the first working SwiftUI prototype.
These are not blockers for the MVP, but they should be decided before production:
The main risk is overbuilding. The app should not become a complicated fitness dashboard too early.
The MVP should prove one thing first:
Can a user log food and workouts faster than existing apps while still receiving useful structured insights?
Everything else is secondary.