Recipes need structure.

Recipes need structure.

I'm here to tell you a better way to structure recipes, and it's going to make your cooking experience a whole lot easier.

We blindly followed the "Ingredients list / Method steps" structure from cookbooks into the digital age, and I'm here to tell you there's a better way.

The problem with our current structure:

We can't remember all ingredient quantities when reading a method.

Ingredients are listed without context, and there are no categories for when shopping, meaning it's not optimised at all for the person actually doing the job.

This leads to constant scrolling on ad-riddled websites, in a self-induced game of memory. And yes, you could gather everything Mise en place before cooking, but look at me dead in the eyes when I say this: You don't have unlimited time. You never will.

The plan?: Some structure

Recipes are currently living in the wild west. Any ingredient order goes. Steps can be convoluted. This all ends now.

We're making a system for the everyday chum. The hard working tax payer that's cooked this before, wants to speed-run it the second time, and deserves better than a 3000 word essay to skip past while lingering in aisle 3.

Let's make a format that:

  • Requires no scrolling
  • Is optimised for the worker (shopping/prepping/cooking)
  • Assumes you've read the recipe once before
  • Works as a speed-run card

Starting with ingredients

We're going to restructure the ingredients list in 3 easy steps:

Tables > lists:
Every grocery store is in logical sections. Why aren't our ingredient lists? Add column headers to match how you move through the store.

Colour-coding same-step ingredients:
Ingredients that are added together, share the same colour. This allows the method to shrink from a long "Add oil, tomato paste, salt, pepper etc...", to simply: "Add Yellow".

Rows for components:
If it can sit in its own bowl on the bench, it can be represented independently. This answers questions like:

  • "What is the sauce made of?"
  • "Can I make the curry paste ahead of time with what I have?"

Finishing with the method

Once ingredients are structured properly, a speedy method becomes a breeze.

  • Refer to collections/colours, not individual ingredients
  • Shorten action wording
  • Include tools if required

Why this is better

You shop in aisles, you cook in steps. You don't want to scroll back and forth, and you've cooked enough by your age to fill in the blanks.

This also scales well. Cooking parts in parallel, or distributing components to a friend becomes infinitely easier.

Example & comparison:

This is the Ricotta Mushroom Gnocchi from the amazing Nagi at RecipeTinEats.

Bonus points:

This is a slight tangent from the cognitive compression of this article, but for some recipes you can colour ingredient groups in rainbow order (ROY G BIV), matching the order they would be presented in the method, potentially ridding yourself of the need to read the method alltogether.

Use an LLM to do the work for you:
Target audience: Computer people, or anyone that works with markdown files.

Copy the recipe to your clipboard, paste into the "{insert full recipe here}" section. The response will be in Markdown with inline HTML, and look like this when previewed.


# Prompt for cooking
Transform the following recipe into a speed-run cooking card optimised for shopping, prep, and fast execution.

---

Core principles:
- Eliminate scrolling between ingredients and method.
- Optimise for execution, not teaching.
- Group ingredients by where I buy them and by recipe sub-assemblies.
- Assume I have already read the original recipe at least once.

---

Output format requirements:
- Output **raw Markdown** inside a fenced code block (```markdown ... ```).
- Use a **single Markdown table** for ingredients.
- Ingredients may contain inline HTML <span> elements for background colour highlighting.
- Use soft pastel background colours for highlights (not text colour).
- Do NOT explain colours in the output.
- This Markdown is intended to be pasted into **VS Code, GitHub, or Obsidian** so the colours render properly.
- Do not visually render Markdown in the chat; return raw Markdown only.

---

Recipe header:
Include in this order:
- Recipe title
- Servings
- Original recipe link

---

Ingredients table structure:
- Columns represent supermarket locations (default: Veg & Deli, Spices, Fridge & Aisles).
- Rows represent logical recipe sub-assemblies (Curry Paste, Sauce, Main, Garnish, Rice, etc.).
- The leftmost column contains the assembly name.
- Ingredients appear only in the row for the assembly they belong to.
- Empty cells are acceptable.

---

Colour coding rules:
- Assign each ingredient a background highlight colour.
- Ingredients added at the same time share the same colour.
- Colours may repeat across different rows if they are added together.
- Use inline HTML like:
  <span style="background-color:#FFF3B0">ingredient</span>

---

Method (compressed):
- Reduce steps aggressively.
- Prefer assembly-level language over ingredient names (e.g., "Blend curry paste", "Add sauce", "Finish with garnish").
- Refer to ingredients by colour when helpful (e.g., “Add Yellow”, “Add Red”).
- Use short, mechanical actions (e.g., “Fry 5m”, “Simmer 10m”, “Cover”).
- Include tools only if they matter (Thermomix, wok, rice cooker).

---

Hard rules:
- Do NOT invent ingredients, quantities, or steps.
- Do NOT include tips, substitutions, or variations.
- Do NOT include narrative or descriptive prose.
- Do NOT optimise for beginners.
- Optimise for speed, scanning, and low cognitive load.

---

Recipe input:

{insert full recipe here}

---

Deliverable:
Return **raw Markdown** (inside a fenced code block) of the transformed speed-run recipe, ready to copy/paste into Markdown preview with colours.