ChatGPT Diet Plan: What It Does Well and Where It Guesses

ChatGPT writes a competent diet plan structure and unreliable diet plan numbers. The meal pattern, the variety and the constraint handling are genuinely good. The calories and macros attached to each food are recalled rather than looked up. Here is how to use the half that works and verify the half that does not.

Split the task in two

A diet plan is really two jobs, and a language model is excellent at one of them.

Structure is the arrangement: how many meals, what goes in each, how to hit a protein target across a day, what to eat when you have twenty minutes, how to swap an ingredient you dislike, how to repeat a pattern across a week without eating the same thing daily. This is pattern work over a very large amount of written nutrition advice, and ChatGPT is good at it. Better than most people expect, and better than most free plan generators, because it responds to your actual constraints instead of a dropdown.

Numbers are the calorie and macro figures attached to each food. These are produced the same way the surrounding prose is produced. No database is consulted, nothing traces to a row you can inspect, and asking the same question twice can give you two answers.

Use it for the first. Verify the second. Most of the frustration people have with AI diet plans comes from not separating these.

What it genuinely does well

Constraint handling. Tell it you are vegetarian on weekdays, allergic to shellfish, cannot stand cottage cheese, cook for thirty minutes on weeknights and longer on Sunday, and it will respect all five at once. A dropdown-driven generator cannot do that, and this is the single strongest reason to use a chat assistant for planning at all.

Swaps. Ask what to put in place of the salmon and you get three options with a sensible note on how each changes the fat content. The direction of the advice is usually right even when the figures are not.

Repeatable structure. Ask for three day templates you can rotate rather than seven distinct days, and it will do that well. That is also the pattern people actually sustain, and it is far more useful than a picture-perfect seven-day plan nobody repeats.

Explaining itself. Ask why it put the carbohydrate around training and you get a reasonable explanation. Useful for learning, as long as you treat it as a well-read friend rather than a clinician.

Rewriting on demand. Tell it the Tuesday dinner is too involved for a Tuesday and it rebuilds that slot while holding the day's targets. That iteration loop is the thing generator apps are worst at, because they regenerate everything or nothing, and it is the reason people keep coming back to a chat for planning even knowing the numbers are soft.

Where it guesses

Per-food macros. Generic staples land close. Branded and own-brand products do not, because a supermarket's own granola is not reliably in any training set. You will still get a confident number, and it will be a generic granola figure wearing your brand's name.

Portions described in words. "A bowl of rice" becomes a gram weight somewhere, invisibly. Whatever it picks is an average and yours is not the average.

Cooked against raw. Dry rice roughly triples in weight when cooked; pasta roughly doubles. "100 g of rice" is an ambiguous question and you will get an answer to whichever version it chose, silently. That is a factor of three, not a rounding error.

Totals that drift from their own line items. This one surprises people. Ask for a day's plan with per-meal subtotals and a daily total, then add the subtotals yourself. They often do not match, because the total is generated as text rather than computed. It is the easiest error to catch and the most commonly missed.

A prompt that produces something checkable

The usual "act as a nutritionist and build me a meal plan" gets you fluent output with no way to audit it. This gets you something you can verify:

Build me three day templates I can rotate, at 2,150 kcal and at least
175 g protein.

Constraints: vegetarian Monday to Friday, no shellfish, I dislike
cottage cheese, 30 minutes to cook on weeknights.

Rules for your answer:
- Give every food a gram weight. No "a bowl" or "a serving".
- State per-meal subtotals and a daily total, and make the total the
  sum of the subtotals.
- For every food, say whether the weight is raw or cooked.
- List any figure you are unsure about in a separate "verify these"
  section at the end.

That last line is the useful one. Asking it to flag its own uncertainty produces a short list of the entries most worth checking, and it is usually the branded items, which is correct.

Verify before you eat it

Three checks, five minutes.

Add up the subtotals. If the daily total does not equal the sum of the meals, the arithmetic was generated rather than done.

Run the 4/4/9 check on the day. Protein and carbohydrate supply roughly 4 kcal per gram, fat roughly 9. Multiply the day's macros out and compare with the day's calorie figure. Within about 10% is normal, since fibre and label rounding account for small gaps. A larger gap means the macros and the calories were produced independently.

Spot-check three foods against labels you own. Pick the three branded items, do not show it the packet, and ask for the per 100 g values. You hold the ground truth. This is the most informative test available and it takes two minutes.

The same checks applied to single foods rather than whole plans are in can ChatGPT count calories.

Watching the numbers drift, concretely

It helps to see the shape of the error rather than read about it.

Ask for a day at 2,000 kcal and you will get four meals whose stated subtotals add to something near 2,000. Now take one line, say 150 g of chicken thigh, and ask what that is per 100 g. Then ask again in a fresh chat. If the two per-100 g figures differ, every portion built on that figure differs too, and the day's total inherits all of it.

Now do the same for the branded item in the plan, the protein bar or the cereal. That is where the gap is widest, because a specific product's formulation is not something a model can recall reliably. It will not tell you it is uncertain. It will give you a number shaped exactly like the confident ones.

The compounding matters more than any single entry. A day is fifteen to twenty items. If the errors were random they would partly cancel. They are not random: the things that get under-counted are cooking oil, dressings, milk in coffee, and anything eaten standing up. A day that is quietly 300 kcal light reads as a completely normal day in the chat, and four weeks of that is the difference between losing weight and wondering why you are not.

Using it for a week rather than a day

One practical note that improves the output more than any prompt wording.

Do not ask for seven distinct days. Ask for three or four day templates built from about twenty foods, and rotate them. Three reasons, and only the first is about accuracy.

It reduces the surface area for error, because twenty foods is twenty figures to spot-check rather than a hundred. It matches how people actually eat, since nobody cooks seven different dinners. And it makes the plan repeatable, which is the property that decides whether you are still following it in week three.

Ask for the twenty foods as a list with per 100 g values, separately from the plan itself. Then you can verify that list once, against labels for the branded items, and every plan built on it afterwards inherits numbers you already checked. That is the closest you get to a database without having one.

When a diet plan stops being a diet plan

Worth being direct about. A calorie and macro arrangement is not a therapeutic diet, and a chat assistant cannot tell the difference between someone who wants to lose a stone and someone managing a diagnosis.

If you have coeliac disease, kidney disease, diabetes you are dosing insulin for, a diagnosed food allergy, a history of disordered eating, or you are pregnant or breastfeeding, a plan from any AI needs a qualified human to review it before you follow it. These diets are managing things a calorie total does not represent, and the failure modes are not "you lost weight slightly slower than expected".

The allergy case deserves its own line: an assistant that has read "no shellfish" will comply nearly always, and nearly always is the wrong standard. Read the ingredient list on anything unfamiliar yourself, every time.

What actually fixes the numbers

The structural fix is to stop asking a model to remember food composition and give it a tool that queries a catalog. The assistant searches, gets a row with an identifier and macros per 100 g, and scales that row to your gram weight. The figures in the plan then came from a database and you can ask which row produced each one.

That is what this nutrition MCP server does, and one limitation stated plainly: it authenticates with an API key header and we have verified it with Claude Code and Cursor. We have not verified it inside ChatGPT, and browser sign-in is not enabled here. So today it is a Claude Code or Cursor setup. The tools and arguments are in the docs, the plan is on MCP pricing, and the planning workflow in detail is in meal planning with a real nutrition database.

If you are building software rather than planning your own week, you want HTTP endpoints instead, which is a REST plan.

What we have not measured

We have not built plans with ChatGPT, eaten them as written, and measured the gap between planned and actual intake. We have no error figure for its per-food macros and we are not going to quote one from elsewhere as though it were ours.

The checks above are arithmetic and you can run them yourself in five minutes, which is the point. When we do run a comparison it will be published with its method and its raw data, so you can disagree with the conclusion rather than take it on trust.

Related

• Can ChatGPT count calories?
• Meal planning with a real nutrition database
• Nutrition MCP server: what the tools do
• A weekly grocery list built from a calorie target