I ran dinner through make: a build system stitched onto a kitchen, built with Kiro

Tagged #KiroweenHackathon26. This post is written as part of the Kiroween 2026 hackathon.

Make Dinner takes the recipes for several dishes and gives back one schedule in which every dish lands hot at the same time. It is my entry in the Frankenstein category: a build system stitched onto a kitchen. This post covers what it does, how Kiro built it, and what went wrong along the way.

In short

  • You paste the recipes for several dishes and get one schedule in which every dish lands hot at the same time.
  • A language model reads the recipes. Build-system machinery plans the dinner, with no model call. Every plan exports as a Dinnerfile, which is a real Makefile.
  • Kiro built it from seven steering files and eight specs (230 tasks), with three custom agents, hooks that ran the scheduler's property tests after every file write, and the scheduler itself as an MCP server.
  • The most valuable thing Kiro did happened before any code: it found seven places where my own guarantees were wrong.

Live demo: https://make-dinner-kiro.onrender.com
Code: https://github.com/seunghyeon1004/make-dinner-kiro

Make Dinner: pick a dinner and you have a plan in one tap.
Make Dinner: pick a dinner and you have a plan in one tap.

The problem: four recipes, one stove

A recipe is written as if you had the whole stove, the whole oven and both hands to yourself. Cook one dish and that is true. Cook four for the same dinner and it is false four times over. You end up scheduling in your head while something burns, and the potatoes are done twenty minutes before the roast.

Programmers solved this problem decades ago, for a different kitchen. A build system has targets and prerequisites, a limit on how many jobs run at once, and incremental rebuilds when one input changes. Dinner has all of those. The gravy cannot start until the roast is out of its tin. You have four burners, one oven and two hands. And the roast always needs fifteen more minutes.

How Make Dinner works: three parts, one job each

Three technologies that do not belong together, each with one job.

  1. A language model reads. Claude turns messy recipe prose into steps: how long each takes, whether it needs a burner or the oven, whether it needs your hands or runs by itself, what it waits for, and how long its result can sit. Its output has to pass a schema and a set of sanity rules, and you can correct every step. The model never schedules anything.
  2. Build-system machinery plans. A dependency graph, resource-constrained scheduling (burners, ovens and cooks are the kitchen's -j), backward scheduling from the serving time, slack, the critical path, and rebuilds. No model is involved, so the same input always gives the same plan.
  3. A kitchen timer app shows it. A timeline with one row per cook, burner and oven, and a cooking mode for a phone standing on the counter.
The Sunday roast: 17 steps from four recipes, every dish ending at 1:30 PM. The marked steps are the critical path.
The Sunday roast: 17 steps from four recipes, every dish ending at 1:30 PM. The marked steps are the critical path.

Take away three burners and an oven and the plan does not pretend. The dinner takes two hours thirty-five instead of one fifty-five, and two results now wait longer than they should. The plan says so.

One burner, one oven: a longer dinner and two honest warnings.
One burner, one oven: a longer dinner and two honest warnings.

A Dinnerfile is a Makefile

I did not want the build system to be a metaphor. So every plan exports as a Dinnerfile, and GNU Make accepts it:

# step dish=chicken minutes=75 appliance=oven handsOn=false hold=0 title="Roast the chicken" chicken.roast: chicken.preheat chicken.prep @echo 'Roast the chicken' # chicken.roast
The plan as a Dinnerfile, in the app.
The plan as a Dinnerfile, in the app.

Running make -n -f Dinnerfile dinner prints every step in an order that works. Ask for gravy and you get only the steps the gravy needs, the roast included, because the gravy is made in the roasting tin. The app reads a Dinnerfile back without the model, and a test spawns the real make to check that it agrees.

GNU Make reading the Sunday roast.
GNU Make reading the Sunday roast.

What the AI does, and what it never does

Paste your own recipes and the model reads them into steps in about five seconds. Then it is out of the picture. If the text is not a recipe, the app says so.

Pasted recipes, read into steps. Each one can be edited before anything is scheduled.
Pasted recipes, read into steps. Each one can be edited before anything is scheduled.

When the roast needs fifteen more minutes

Cooking mode shows what to do right now and counts down what is running. When something slips you tap "+15 min", and the plan is rebuilt the way an incremental build works. What already happened is kept. Only the affected steps move. The other hot dishes are held back so they still land with the late one.

Cooking mode: the roast is running, with its countdown.
Cooking mode: the roast is running, with its countdown.
The build log after the rebuild: twelve steps moved, five are up to date, serving moved from 1:30 PM to 1:45 PM.
The build log after the rebuild: twelve steps moved, five are up to date, serving moved from 1:30 PM to 1:45 PM.

What the scheduler promises: twenty numbered guarantees

Scheduling with limited resources is NP-hard, so Make Dinner does not promise the best plan. It promises a valid one, and says what valid means in twenty numbered guarantees. No burner, oven or cook is ever over capacity. No step starts before the steps it waits for have ended. Hands-free steps never occupy a cook. A rebuild never moves a step earlier and changes nothing when nothing slipped. Each guarantee is a fast-check property that runs against generated dinners and kitchens and is checked by an oracle that shares no code with the scheduler.

How Kiro built Make Dinner

I drove Kiro from its CLI, and every session's transcript is in the repository under docs/kiro-evidence. The transcripts are rendered from the CLI's event stream, so each shell command appears with its exit code and its real output. A test run that never happened cannot appear in them.

Kiro featureWhat it did hereHow it went
SteeringSeven files written first, from a hand-written brief. One of them states the scheduler's promises as numbered guarantees and forbids weakening a test to make it pass.The single most useful thing I set up
SpecsEight features through spec mode: requirements, a design with schedules worked out by hand, then test-first tasks. 230 of 230 tasks ticked, each after its check passed.Found design errors before any code existed
Custom agentsA builder (sous-chef) that implemented every task, a checker (expediter) that re-verified ticked tasks and may only untick, and a read-only taster that can only call the MCP server.The builder stopped and asked at the right moments
HooksAfter every file the builder wrote: typecheck, plus the scheduler's property tests when core files changed. Full suites and lint when it stopped. Every firing is logged.294 lines in the hook log
MCPThe scheduler itself as an MCP server with seven read-only tools, registered for the workspace.Worked on the second try, see below
Vibe codingOnly the project scaffold and the agent and hook setup.Fine for tooling
Not usedKiro powers and Kiro Crew.

Specs that attacked their own design

Each spec prompt asked Kiro to check my guarantees against the algorithm and to report every conflict with a counterexample, not to adjust quietly. This is where the spec workflow paid for itself.

  • The scheduler spec found that one guarantee was empty for larger plans, and that the test I had described for another was weaker than its definition: a wrong answer of 19 would have passed.
  • The rebuild spec found five conflicts. Three of my guarantees were simply false the second time a plan was rebuilt.
  • The Dinnerfile spec ran scratch Makefiles against the real GNU Make and found that make -n, which is supposed to run nothing, will execute a recipe line that contains $(MAKE). The escaping in the export comes from that measurement.
From the rebuild spec, written by Kiro before any code: two of the five conflicts it found in my guarantees.
From the rebuild spec, written by Kiro before any code: two of the five conflicts it found in my guarantees.

With vibe coding I would have found these as bugs, late, or not at all. Here they were found on paper, and the hand-worked schedules in each design became the example tests.

Hooks that kept the builder honest

The builder agent's hooks ran the typecheck after every write and the property tests whenever scheduler code changed. A coverage test demands a property for every guarantee in the steering file. For two sessions that test stayed red, on purpose, because the properties did not exist yet, and the builder left it red rather than add placeholders.

The builder also ran a mutation check on its own work. It removed one scheduling pass to see which property would fail. None did. It reported that, and the gap became a new guarantee with its own property. The same thing happened again for the rebuild.

The hook log: every firing, with the exit codes of the checks it ran.
The hook log: every firing, with the exit codes of the checks it ran.

The scheduler as an MCP server

The scheduler is plain deterministic code, so an agent should call it, not reason about schedules in prose. I asked Kiro what happens to the Sunday roast with one burner and one oven. The first attempt failed in an instructive way: Kiro's MCP client dropped the empty lists and nulls from the plan object, and the server rejected the broken plan. The tools now also accept the plan as a JSON string, and the second attempt worked.

Kiro calling the make-dinner MCP server: 115 minutes with no warnings against 155 minutes with two.
Kiro calling the make-dinner MCP server: 115 minutes with no warnings against 155 minutes with two.

What went wrong

  • My first definition of waiting was wrong. On the first real recipe the roast feeds two steps, the rest and the gravy, and the plan warned that the roast was waiting when it was not. I changed the definition, and Kiro carried the change through the specs, the oracles and the hand-worked tables.
  • "Critical" was on 14 of 17 steps. A just-in-time schedule gives every hot step zero slack, so the mark said nothing. It was replaced by a real critical path, and my first rule for that picked the wrong chain. I fixed that one by hand.
  • The first property-test generators crashed on failure. fast-check ran out of memory while shrinking. Kiro found it and rewrote the generators.
  • Kiro did not always write the test first. It says so in its own reports, and showed by mutation that those tests can fail.
  • It was not cheap. A spec session cost 33 to 70 credits and the whole build about 1,100.
  • A mistake of mine. A clean-up command overwrote transcript files while sessions were still writing to them. Two were rebuilt from saved event streams and one lost its last message. The evidence folder says which.

What I learned

Write the promises down as numbered guarantees before anything else, and tell the agent it may never weaken a check. Ask the agent to attack the design before it writes code. Let hooks turn "it passes" into a line in a log. And give the agent permission to stop: mine stopped at the right moments, and each stop was cheaper than the bug it prevented.

The numbers on the final commit: 2,097 example tests, 106 property tests and 352 end-to-end tests, all passing.

Make Dinner in numbers

WhatNumber
Steering files7
Specs8, with 230 of 230 tasks ticked
Custom agents3: a builder, a checker and a read-only taster
MCP tools7, all read-only
Scheduler guarantees20, each one a property test
Tests on the final commit2,097 example tests, 106 property tests, 352 end-to-end tests
Hook log294 lines
Sunday roast1 hour 55 minutes; 2 hours 35 minutes with one burner and one oven, with two warnings
After tapping +15 min12 steps moved, 5 up to date, serving moved from 1:30 PM to 1:45 PM
Kiro credits33 to 70 per spec session, about 1,100 for the whole build

Try it

Open the live demo at https://make-dinner-kiro.onrender.com.

  1. Tap "Plan this dinner" on the Sunday roast. No login is needed.
  2. Take the burners down to one and watch the plan change.
  3. Open the Dinnerfile panel, download the file, and run make on it.
  4. Tap "Start cooking", start the first step, then tell it something needs more time.

The demo runs on a free server that sleeps, so the first load can take a minute. Reading your own pasted recipes is rate limited; the five sample dinners and Dinnerfile import always work. The code, the specs and every Kiro session transcript are at https://github.com/seunghyeon1004/make-dinner-kiro.

FAQ

Does the AI plan the dinner?

No. The language model only reads recipe text into steps, in about five seconds, and you can correct every step. The plan comes from build-system code with no model call, so the same input always gives the same plan.

Is a Dinnerfile a real Makefile?

Yes. GNU Make accepts it. Running make -n -f Dinnerfile dinner prints every step in an order that works, and a test spawns the real make to check that the app agrees with it.

Does Make Dinner find the fastest possible dinner?

No. Scheduling with limited resources is NP-hard, so it promises a valid plan and says what valid means in twenty numbered guarantees. When the kitchen is too small, the plan gets longer and carries warnings.

What happens when a dish runs late?

You tap "+15 min" in cooking mode. What already happened is kept, only the affected steps move, and the other hot dishes are held back so they still land with the late one.

Do I need an account to try it?

No login is needed. The five sample dinners and Dinnerfile import always work. Reading your own pasted recipes is rate limited.

Which Kiro features did the build use?

Steering, specs, custom agents, hooks and MCP. Vibe coding was used only for the project scaffold and the agent and hook setup. Kiro powers and Kiro Crew were not used.

Written as part of the Kiroween 2026 hackathon. Tagged #KiroweenHackathon26

댓글