You're the Chef, AI is Your Line Cook.

A mental model

I locked myself in a room for 13 days until I shipped a new feature for Compass Calendar. It took 10 PRs, 167 commits, and a lot of prompting. Along the way, I developed a mental model for coding with AI effectively.

Here are my notes.

You’re the chef. The AI is the line cook.

The chef and line cook have distinct but complementary roles. The chef owns the quality — they adjust seasoning, presentation, and ensure nothing leaves the kitchen that doesn’t meet standards. The line cook handles the nitty-gritty — they prep, follow recipes, and work fast so the chef can focus on the bigger picture.

This is the dynamic you want with AI.

You are responsible for:

• The vision - What problem are we solving? What is the right path there?

• Conventions - Does the code meet production standards? Is it consistent with the rest of the codebase?

• QA - Running the code, checking edge cases, and ensuring it actually solves the problem

The AI is responsible for:

• Implementation speed — Writing the boilerplate, tests, and first drafts quickly

• Following your recipe — Turning your spec into code while preserving conventions

• Feedback — Catching obvious issues and suggesting improvements

You both need to understand each other’s work well enough to collaborate effectively. The chef needs to know how to prep ingredients. The line cook needs to understand how the dish will be presented.

But — and this is critical — you must resist the temptation to do each other’s jobs.

Don’t micromanage every line of code the AI writes. Trust the AI to execute, but don’t abdicate your responsibility for solutions and quality.

The moment you start just accepting whatever AI generates without review, you’ve stopped being the chef. You’ve become a food runner.

That’s the mental model. Now let’s see what it looks like in practice.

Here’s the actual workflow I used across those 10 PRs. Notice the six handoffs—each one is a deliberate checkpoint where responsibility shifts.

Workflow

👨‍💻: Write the first draft of an issue

🤖: Refine the issue

👨‍💻: Start prompt, linking the issue

🤖: Write the first draft of an implementation build

👨‍💻: Refine the plan

👨‍💻: Create the files according to your conventions. This could be skipped if you have good local rules

🤖: Implements the plan and writes tests

👨‍💻: Review the tests.

• Do this before reviewing the code. It’ll help you be more flexible about the implementation, while also ensuring that you understand what’s happening. This is an active review, where you read each test, run it locally, and poke around to validate that it’s not cutting corners

👨‍💻: Create a commit. Do this yourself to ensure you’re aware of accruing tech debt

👨‍💻: Prompt it to tweak the implementation

🤖: Updates implementation, ensuring the tests still pass

👨‍💻: Create a commit and push

🤖: Review PR.

• Let the AI review this from a clean context slate. You want to ensure your changes actually meet the issue’s spec.

👨‍💻: Make tweaks based on the PR review

👨‍💻: Merge

Bonus Tips

• Give up quickly: If the AI’s first implementation isn’t 70% of the way there, start over; either do it yourself or refine the spec and re-prompt for a better plan. Prompting your way from 70% to 100% is a lot more painful than re-prompting and getting to 90% on the next shot.

• Minimize the layers of that stack you’re changing in each commit. Do separate commits for the schema, API route, fetch calls, and components.

• Favor more files over big files. You’re not introducing new complexity to the codebase by creating new files; you’re simply making the existing complexity more apparent. For example, instead of dashboard.tsx, do:

  • dashboard.tsx

  • dashboard.test.tsx

  • dashboard-header.tsx

  • dashboard-header.test.tsx

  • dashboard-grid.tsx

  • dashboard-grid.test.tsx

  • dashboard-sidebar.tsx

  • dashboard-sidebar.test.tsx

• Resist the temptation to multitask. The context-switching isn’t worth it. Better to stand up, stretch, walk, or jot things down in a journal while still keeping the code open.

Conclusion

The chef/line cook dynamic isn’t about you doing less work—it’s about you doing the right work.

The AI can’t be the chef (yet). It doesn’t have taste. It doesn’t feel the weight of tech debt accumulating. It doesn’t get the angry email at 2 am because something broke.

But it can be an exceptional line cook—if you let it.

Accept your role. Trust your line cook. And ship.

---

P.S. I was a food runner at a fast-food restaurant as a kid. In college, I worked as a line cook in Germany for a year. This dynamic feels familiar. I’m happy to be in the chef’s role this time.