Engineering recipes

Put your best work on repeat.

Turn the way your team builds software into recipes that humans and AI can execute, validate, and improve.

Define it once. Validate every run. Improve it together.

Hand-painted pop-up storybook of an open recipe book rising into layered engineering workstations connected by a turquoise execution path.

A Recipe in practice

Create a typed API endpoint

One reusable engineering process—goal, inputs, ordered steps, rules, validation, and outputs—ready for people and AI alike.

Example recipe

Create a typed API endpoint

  • Resource: widgets
  • Method: POST
  1. Goal

    Ship a typed POST endpoint for widgets.

  2. Inputs

    Resource name, HTTP method, and project conventions.

  3. Steps

    Derive the route and handler, create the handler, add success and validation-failure tests.

  4. Validation

    Confirm types, tests, and handler behavior before shipping.

  5. Output

    A completed work package ready to review and merge.

One Recipe, two experiences

The same process. Two ways to run it.

A canonical Recipe can drive AI execution and stand alone as a clear human SOP—without forking the source of truth.

AI execution

Let an engine walk the graph

Feed the Recipe to an execution engine. It follows ordered steps, applies rules, and pauses where validation or human judgment is required.

  • Derive the route and handler name from inputs
  • Create the handler against your codebase
  • Add success and validation-failure tests
  • Validate output before the work package is complete

Human SOP

Read it like a playbook

The same Recipe reads as a supervised standard operating procedure—goals, decisions, and checks written for the person doing the work.

  • Know the goal before touching the codebase
  • Follow ordered steps without tribal knowledge
  • Apply rules and instructions at decision points
  • Validate results the same way every run

Recipe anatomy

Everything a repeatable process needs

Recipes capture how your team actually builds—not a vague prompt, and not a brittle script with no memory.

01

Goal

The outcome the Recipe exists to produce—clear enough to judge success.

02

Inputs

Parameters that shape the run, such as resource name and HTTP method.

03

Steps

An ordered path from intent to completed work—derive, create, test, validate.

04

Rules

Instructions and constraints that keep every run aligned with team standards.

05

Validation

Checks that prove the output is correct before trust increases.

06

Outputs

The completed work package—code, tests, and evidence you can review.

Storybook open book with layered terraces and a turquoise path representing a reusable engineering package.

Engineering Packages

Related Recipes, packaged to share

Engineering Packages group related Recipes into a reusable unit of expertise—installable, versioned, and ready for the places your team already works.

Trust progression

Autonomy earned by evidence

Teams increase autonomy when validation and run history justify it—from supervised runs to delegated work to unattended execution.

Supervised

Humans stay in the loop. Every step is visible; gates pause for judgment.

Delegated

Proven Recipes run with fewer interruptions, while validation still protects the outcome.

Unattended

High-trust Recipes execute without babysitting—backed by evidence, not hope.

Run where work happens

Author in the registry. Execute beside the code.

The web app is for browsing and authoring. The same execution runtime is designed for desktop, CLI, and CI—with room for additional environments as the platform grows.

Desktop

Local execution with filesystem and tooling access to the developer’s environment.

CLI

Headless runs for local workflows, scripts, and automation without a UI.

CI

The same runtime packaged for pipelines and ephemeral environments.

Beyond

Built for future execution environments—without changing the Recipe itself.

Put your best work on repeat.

Capture the way your team builds software. Validate every run. Improve the Recipe together.