Recipes¶

Recipes are starter .limabean.yaml files for common kinds of VMs. Pick the closest one, write it into your repository and edit it:

limabean recipes                         # list them
cd ~/src/api
limabean recipes go-service              # writes .limabean.yaml here
limabean up

limabean recipes <name> --print shows one without writing it, and --overwrite replaces a project file that's already there. Every recipe is a plain project file: change the packs, size, ports and setup to fit, and commit it so everyone on the project gets the same VM. Its first line points your editor at the file's schema, so keys and pack names complete as you edit.

The recipes live in recipes/, and limabean's tests bring every one of them up, so their packs, presets and plugins are always real.

Recipe	For
`go-service`	A Go service with Postgres in Docker.
`grpc`	A gRPC service in Go, with buf and grpcurl.
`node-web`	A web frontend: Node, pnpm and a dev server (Vite, Next.js and the like).
`python-api`	A Python web API (FastAPI, Django, Flask) managed with uv.
`python-data`	Data work in Python: notebooks and libraries that want memory.
`rust`	A Rust crate or CLI.
`java-spring`	A Java service: Spring Boot, Quarkus or plain Gradle or Maven.
`rails`	A Ruby on Rails app with Postgres in Docker.
`kubernetes`	Kubernetes work: a kind cluster in Docker, with kubectl, helm and k9s.
`terraform`	Infrastructure with Terraform and the AWS CLI.
`claude-agent`	A locked-down sandbox for Claude Code agents.
`review`	Reviewing code you don't trust yet, with scanners at hand.
`minimal`	The smallest VM: core shell tools, plus the Python and Docker every VM has.

Languages and frameworks¶

go-service¶

For an HTTP or worker service in Go. Docker runs its Postgres (or anything else in compose.yaml) next to it, and its packs bring golangci-lint, gofumpt and psql.

# A Go service with Postgres in Docker.
# Start from it: limabean recipes go-service && limabean up
packs: [go, db]                   # go: toolchain, golangci-lint, gofumpt; db: psql
disk: 30                          # room for Docker images
ports: [8080]
setup: |
  if [ -f compose.yaml ] || [ -f docker-compose.yml ]; then docker compose up -d; fi
  go mod download

grpc¶

For a gRPC service in Go: the api pack adds buf and grpcurl, and both the HTTP and gRPC ports are listed.

# A gRPC service in Go, with buf and grpcurl.
# Start from it: limabean recipes grpc && limabean up
packs: [go, api]                  # api: buf, grpcurl
ports: [8080, 50051]
setup: |
  buf dep update || true
  go mod download

node-web¶

For a frontend with a dev server. Setup picks pnpm, bun or npm from the lockfile, and Claude gets Anthropic's frontend-design plugin.

# A web frontend: Node, pnpm and a dev server (Vite, Next.js and the like).
# Start from it: limabean recipes node-web && limabean up
packs: [node]                     # node, pnpm, bun
ports: [5173, 3000]               # Vite, Next.js
setup: |
  if [ -f pnpm-lock.yaml ]; then pnpm install
  elif [ -f bun.lock ] || [ -f bun.lockb ]; then bun install
  else npm ci; fi
claude:
  marketplaces:
    - marketplace: anthropics/claude-plugins-official
      plugins: [frontend-design@claude-plugins-official]

python-api¶

For a FastAPI, Django or Flask app whose dependencies uv manages.

# A Python web API (FastAPI, Django, Flask) managed with uv.
# Start from it: limabean recipes python-api && limabean up
packs: [python]                   # uv, ruff, yamllint
ports: [8000]
setup: |
  uv sync

python-data¶

For notebooks and data libraries: more CPUs and memory, and Jupyter's port. Start Jupyter with uv run jupyter lab --ip 0.0.0.0, then limabean open.

# Data work in Python: notebooks and libraries that want memory.
# Start from it: limabean recipes python-data && limabean up
packs: [python]
cpus: 4
memory: 8
disk: 30
ports: [8888]                     # Jupyter: uv run jupyter lab --ip 0.0.0.0
setup: |
  uv sync

rust¶

For a crate or CLI. More CPUs for parallel builds and a bigger disk for target/.

# A Rust crate or CLI.
# Start from it: limabean recipes rust && limabean up
packs: [rust]
cpus: 4                           # cargo builds in parallel
disk: 30                          # target/ grows quickly
setup: |
  cargo fetch

java-spring¶

For a JVM service. Setup warms Gradle's or Maven's cache through the project's wrapper.

# A Java service: Spring Boot, Quarkus or plain Gradle or Maven.
# Start from it: limabean recipes java-spring && limabean up
packs: [java]                     # Temurin JDK, gradle, maven
memory: 6                         # the JVM and Gradle's daemon
ports: [8080]
setup: |
  if [ -x ./gradlew ]; then ./gradlew --quiet dependencies
  elif [ -x ./mvnw ]; then ./mvnw --quiet dependency:go-offline
  fi

rails¶

For a Rails app: Ruby, Node for the asset pipeline, and Postgres in Docker.

# A Ruby on Rails app with Postgres in Docker.
# Start from it: limabean recipes rails && limabean up
packs: [ruby, node, db]           # node for the asset pipeline, db for psql
disk: 30
ports: [3000]
setup: |
  if [ -f compose.yaml ] || [ -f docker-compose.yml ]; then docker compose up -d; fi
  bundle install

Infrastructure¶

kubernetes¶

For platform work against a local cluster. Setup creates a kind cluster named dev once; kubectl, helm and k9s are ready for it.

# Kubernetes work: a kind cluster in Docker, with kubectl, helm and k9s.
# Start from it: limabean recipes kubernetes && limabean up
packs: [kubernetes, containers]   # kubectl, helm, kind, k9s; dive, skopeo
cpus: 4
memory: 8
disk: 40                          # node images and whatever you deploy
setup: |
  kind get clusters | grep -qx dev || kind create cluster --name dev

terraform¶

For infrastructure code. Your Mac's ~/.aws is mounted read-only, so profiles and SSO sessions from the Mac work; run aws sso login on the Mac.

# Infrastructure with Terraform and the AWS CLI.
# ~/.aws on your Mac is mounted read-only in the VM, so profiles work as
# they do on the Mac; run aws sso login on the Mac.
# Start from it: limabean recipes terraform && limabean up
packs: [infra]                    # terraform, tflint, aws-cli
setup: |
  terraform init -backend=false

Claude and untrusted code¶

claude-agent¶

For handing a repository to Claude Code. The network reaches only GitHub, the package registries and Anthropic, the VM's user has no sudo or Docker, and Claude gets the commit-commands and pr-review-toolkit plugins. Run it headless with limabean ssh <name> 'cd ~/code/... && claude -p "..."', or open it from Claude Desktop.

# A locked-down sandbox for Claude Code agents.
# It reaches only GitHub, package registries and Anthropic, and has no sudo
# or Docker. Set the token once on your Mac:
#   claude setup-token
#   limabean secrets set CLAUDE_CODE_OAUTH_TOKEN --vm <name>
# Start from it: limabean recipes claude-agent && limabean up
packs: [claude, go, node, python]  # Claude Code, and the languages it works in
network:
  allow: [github, npm, python, go, claude]
  locked: true
secrets: [CLAUDE_CODE_OAUTH_TOKEN]
claude:
  marketplaces:
    - marketplace: anthropics/claude-plugins-official
      plugins: [commit-commands@claude-plugins-official, pr-review-toolkit@claude-plugins-official]

review¶

For reading a repository you don't trust yet. No secrets at all, a network that reaches only GitHub and Anthropic, no sudo or Docker, and syft, grype and cosign to check its dependencies. Claude gets the security-guidance and code-review plugins.

# Reviewing code you don't trust yet, with scanners at hand.
# No secrets, a network that reaches only GitHub and Anthropic, no sudo or
# Docker, and syft, grype and cosign for the supply chain.
# Start from it: limabean recipes review && limabean up
packs: [supply-chain, claude]
network:
  allow: [github, claude]
  locked: true
claude:
  marketplaces:
    - marketplace: anthropics/claude-plugins-official
      plugins: [security-guidance@claude-plugins-official, code-review@claude-plugins-official]

Starting from nothing¶

minimal¶

For when you'd rather add packs as you go: limabean rebuild <name> --with go.

# The smallest VM: core shell tools, plus the Python and Docker every VM has.
# Start from it: limabean recipes minimal && limabean up
# Add what you need, e.g.: packs: [go]

Make your own¶

A recipe is only a starting point; the reference lists every key. Some changes that come up often:

Another language next to the main one: add its pack to packs, such as rust; limabean packs lists them all.
A sandbox: add network.allow with the presets setup needs, and locked: true. If you don't know the list, find it with learn mode.
Secrets: name them under secrets, and set each up once on your Mac with limabean secrets set NAME --vm <name> (secrets).
Claude plugins: add a marketplace and its plugins under claude.

Have one that others would use? Recipes are plain files in recipes/: open a pull request with yours.