diff --git a/.agents/skills/author-recipes-and-cookbooks/SKILL.md b/.agents/skills/author-recipes-and-cookbooks/SKILL.md
index ee6c730..4957aa6 100644
--- a/.agents/skills/author-recipes-and-cookbooks/SKILL.md
+++ b/.agents/skills/author-recipes-and-cookbooks/SKILL.md
@@ -7,7 +7,7 @@ description: Author and maintain DevHub templates published at `developers.datab
 
 ## Overview
 
-Use this skill to add or update DevHub templates with consistent structure, metadata, and writing quality. Treat each template as both an execution prompt for AI coding agents and a learning walkthrough for human developers.
+Use this skill to add or update DevHub templates with consistent structure, metadata, and writing quality. Treat each template as an execution prompt for AI coding agents — an inspirational gallery of what's possible, not a step-by-step manual guide.
 
 ## The Three Internal Kinds
 
@@ -15,7 +15,7 @@ Internally the catalog is built from three kinds of content that compose into ea
 
 - **Recipe** — an atomic, copy-pasteable agent prompt for one outcome (e.g. "Create a Lakebase instance"). The smallest unit; everything else is built from these.
 - **Cookbook** — composes multiple recipes into a longer end-to-end guide, plus its own meta content (intro, narrative, ordering). No app source.
-- **Example** — a cookbook _plus_ a full deployable codebase that lives in the [app-templates](https://github.com/databricks/app-templates) repo at `app-templates/<slug>/`. Bundles recipes and cookbook narrative around runnable app code.
+- **Example** — a cookbook _plus_ a full deployable `examples/<slug>/template/` codebase. Bundles recipes and cookbook narrative around runnable app code.
 
 So: recipes are the atoms, cookbooks compose recipes with additional context, and examples are cookbooks with shipped code.
 
@@ -27,11 +27,11 @@ User-facing, all three kinds are presented as one thing: **template**. The site
 
 The internal kind names (`recipe`, `cookbook`, `example`) **live only in code, file paths, and this skill** — they never appear in shipped UI, markdown content, or generated indexes.
 
-| Internal kind | Source location                                                                                   | Route at runtime    | When to use                                                                |
-| ------------- | ------------------------------------------------------------------------------------------------- | ------------------- | -------------------------------------------------------------------------- |
-| `recipe`      | `content/recipes/<slug>/{content,prerequisites,deployment}.md` + entry in `recipes`               | `/templates/<slug>` | One atomic outcome, copy-pasteable in a single agent prompt.               |
-| `cookbook`    | Entry in `cookbooks` (composes recipes) + manual page `src/pages/templates/<slug>.tsx`            | `/templates/<slug>` | End-to-end walkthrough composed from multiple recipes.                     |
-| `example`     | `content/examples/<slug>/content.md` + full app source at `app-templates/<slug>/` (separate repo) | `/templates/<slug>` | Full deployable codebase that bundles cookbooks/recipes plus runnable app. |
+| Internal kind | Source location                                                                        | Route at runtime    | When to use                                                                |
+| ------------- | -------------------------------------------------------------------------------------- | ------------------- | -------------------------------------------------------------------------- |
+| `recipe`      | `content/recipes/<slug>/{goal,prerequisites}.md` + entry in `recipes`                  | `/templates/<slug>` | One atomic outcome, copy-pasteable in a single agent prompt.               |
+| `cookbook`    | Entry in `cookbooks` (composes recipes) + manual page `src/pages/templates/<slug>.tsx` | `/templates/<slug>` | End-to-end walkthrough composed from multiple recipes.                     |
+| `example`     | `content/examples/<slug>/goal.md` + full app source under `examples/<slug>/template/`  | `/templates/<slug>` | Full deployable codebase that bundles cookbooks/recipes plus runnable app. |
 
 All three are registered in `src/lib/recipes/recipes.ts`, share a flat `/templates/<slug>` URL hierarchy, and must have globally unique slugs (the content-entries plugin asserts this at build time). Choose the kind that matches the **shape of the work**, not the customer-facing label.
 
@@ -39,38 +39,31 @@ All three are registered in `src/lib/recipes/recipes.ts`, share a flat `/templat
 
 1. One atomic, self-contained step for an agent → author a `recipe`.
 2. A multi-recipe walkthrough that ships a coherent end-to-end use case (no full app source) → author a `cookbook` composing existing recipes.
-3. A full deployable app (source tree in `app-templates/<slug>/`, README runbook, optional pipelines and seed) → author an `example`.
+3. A full deployable app (`template/` source tree, README runbook, optional pipelines and seed) → author an `example`.
 4. Reuse existing recipes whenever you can. New recipes are the most valuable; new cookbooks/examples should compose them.
 
 ## Author A `recipe`
 
-1. Create `content/recipes/<slug>/content.md`. Optionally add `prerequisites.md` and `deployment.md` siblings.
+1. Create `content/recipes/<slug>/goal.md`. Optionally add `prerequisites.md`.
 2. The slug must equal the folder name and be globally unique across the catalog.
-3. Open `content.md` with:
-   - `## <Template Title>`
-   - one concise outcome sentence
-4. Organize steps as numbered H3 sections (`### 1. ...`, `### 2. ...`).
-5. Keep each step executable:
-   - exact commands in fenced `bash` blocks
-   - placeholders like `<PROFILE>` and `<workspace-url>` for user-specific values
-   - explain only what is needed to run the step safely
-6. Close with `#### References` containing only high-signal links.
-7. Register the recipe in `src/lib/recipes/recipes.ts`:
+3. Write `goal.md` as a concise outcome description — what the agent should build, what the user will have when done. Keep it short (5-10 lines). Agent skills handle the implementation details.
+4. Optionally add `prerequisites.md` for workspace-specific requirements the agent should verify before starting (e.g., "Lakebase Postgres available", "Genie enabled", "AWS workspace"). Do NOT include "Databricks CLI authenticated" — the localBootstrap recipe already handles that.
+5. Register the recipe in `src/lib/recipes/recipes.ts`:
    - add it to `recipes` with `id`, `name`, `description`, `tags`, `services`
    - set `prerequisites` only when strictly required
    - place it in `recipesInOrder`
-8. Keep registry metadata aligned with the markdown (name, scope, intent must match).
+6. Keep registry metadata aligned with the markdown (name, scope, intent must match).
 
-### Prerequisites Belong In `prerequisites.md` — Never In `content.md`
+### Prerequisites Belong In `prerequisites.md` — Never In `goal.md`
 
-Prerequisites have a single home: `content/<recipes|examples>/<slug>/prerequisites.md`. The route plugin renders that file under a `## Prerequisites` H2 above the content body and the agent-prompt composer attaches it ahead of the steps. Putting prerequisite text inside `content.md` duplicates the section, breaks step numbering when the duplicate is removed later, and produces noisy "Copy as Markdown" payloads.
+Prerequisites have a single home: `content/<recipes|examples>/<slug>/prerequisites.md`. The route plugin renders that file under a `## Prerequisites` H2 on the detail page.
 
 Rules:
 
-- **Do not** add `### Prerequisites`, `:::info[Prerequisites]`, `### N. Follow the prerequisite templates first`, or any equivalent block to `content.md`. Move that content into `prerequisites.md` instead.
-- `content.md` step numbering starts at `### 1.` with the first real action — never with a "do these other templates first" preamble.
+- **Do not** add prerequisites to `goal.md`. Keep goal focused on the outcome.
 - When a recipe depends on completing another template first, list it as a bullet inside `prerequisites.md` with a link to `/templates/<slug>` (relative — see [Link Style](#link-style-use-relative-urls-for-devhub-pages)).
-- Workspace-feature checks (CLI auth, Lakebase enabled, Apps enabled, Genie enabled, etc.) belong in `prerequisites.md` as `databricks` CLI commands the user can run to verify each capability — not as prose in `content.md`.
+- Workspace-feature checks (Lakebase enabled, Apps enabled, Genie enabled, etc.) belong in `prerequisites.md` as `databricks` CLI commands the agent can run to verify each capability.
+- Do NOT include "Databricks CLI authenticated" checks — the localBootstrap recipe injected into every agent prompt already handles CLI auth verification.
 
 ## Author A `cookbook`
 
@@ -80,11 +73,10 @@ Rules:
    - add an entry to `cookbooks` with `id`, `name`, `description`, `recipeIds`
    - rely on `createCookbook()` to derive `tags` and `services`
 4. Create `src/pages/templates/<slug>.tsx` following the existing pattern:
-   - import `CookbookDetail`, `cookbooks`, `useAllRecipeSections`, `useCookbookIntro`, and `composeCookbookMarkdown`
-   - import each recipe markdown module from `@site/content/recipes/<slug>/content.md`
-   - select the cookbook with `cookbooks.find((c) => c.id === "<slug>")`
-   - build `rawMarkdown` from `cookbook.recipeIds` joined with `\n\n---\n\n`
-   - render the recipes in `recipeIds` order, separated with `<hr />`
+   - import `CookbookDetail` and `useCookbookMarkdown`
+   - import the cookbook's `goal.md` from `@site/content/cookbooks/<slug>/goal.md`
+   - use `useCookbookMarkdown("<slug>")` to get the `cookbook` and `rawMarkdown`
+   - render just `<Goal />` as children of `<CookbookDetail>`
 5. Keep the page declarative — no logic beyond composition.
 
 ## Author An `example`
@@ -93,80 +85,79 @@ An example is a full working codebase plus narrative markdown. It bundles cookbo
 
 ### 1. Create The Example Code
 
-Example code lives in the [app-templates](https://github.com/databricks/app-templates) repo (not in `devhub/`). Create `app-templates/<slug>/` with:
+Create `examples/<slug>/` with:
 
 ```
-app-templates/<slug>/         # full runnable tree (AppKit app + optional pipelines/seed/provisioning)
-  README.md                   # canonical provisioning, SQL, seed, and deploy runbook
-  databricks.yml              # bundle config with REPLACE_ME placeholders
-  app.yaml                    # runtime env from bundle resources
-  package.json                # app dependencies
-  appkit.plugins.json         # plugin manifest
-  server/                     # Express backend
-  client/                     # React frontend
-  config/queries/             # SQL query files
-  provisioning/sql/           # baseline SQL (Unity Catalog, Postgres, etc.)
-  pipelines/                  # Lakeflow pipelines (optional)
-    <pipeline-name>/
-      databricks.yml
-      resources/*.yml
-      src/**/*.sql or *.py
-  seed/                       # seed script for demo data (optional)
-    seed.ts
-    package.json
+examples/<slug>/
+  template/                    # full runnable tree (AppKit app + optional pipelines/seed/provisioning)
+    README.md                  # canonical provisioning, SQL, seed, and deploy runbook
+    databricks.yml             # bundle config with REPLACE_ME placeholders
+    app.yaml                   # runtime env from bundle resources
+    package.json               # app dependencies
+    appkit.plugins.json        # plugin manifest
+    server/                    # Express backend
+    client/                    # React frontend
+    config/queries/            # SQL query files
+    provisioning/sql/          # baseline SQL (Unity Catalog, Postgres, etc.)
+    pipelines/                   # Lakeflow pipelines (optional)
+      <pipeline-name>/
+        databricks.yml
+        resources/*.yml
+        src/**/*.sql or *.py
+    seed/                        # seed script for demo data (optional)
+      seed.ts
+      package.json
 ```
 
 Key conventions:
 
-- All runnable assets (app, optional `pipelines/`, `seed/`, `provisioning/sql/`) live at the root of the example folder so `databricks apps init --template https://github.com/databricks/app-templates/tree/main/<slug>` works. `README.md` must describe the full path from zero to deployed app.
+- The app directory MUST be named `template/` (not `app/`) so `databricks apps init --template` works.
+- All runnable assets (app, optional `pipelines/`, `seed/`, `provisioning/sql/`) live **under** `template/`. Do not leave `pipelines/` or `seed/` at the example root — `template/README.md` must describe the full path from zero to deployed app.
 - Use `REPLACE_ME` placeholders for workspace-specific values (host, warehouse ID, catalog name, Lakebase project, etc.).
 - Never commit workspace-specific values, `.databricks/`, `node_modules/`, or `.env`.
 - Pipeline SQL files use schema-qualified names (e.g., `silver.users`); rely on the pipeline YAML `catalog` setting for catalog resolution.
 - Add `.npmrc` pointing to `https://npm-proxy.dev.databricks.com/` if the app uses `@databricks/appkit`.
 - SQL files in `config/queries/` run against the **Databricks SQL Warehouse** (Spark SQL dialect), NOT Lakebase Postgres. Use `CURRENT_DATE()` not `NOW()`, `DATE_ADD(d, n)` not `d + INTERVAL`, `SUM(CASE WHEN ... THEN 1 ELSE 0 END)` not `COUNT(*) FILTER (WHERE ...)`. Reference Unity Catalog three-part names (e.g., `catalog.schema.table`).
 
-### `README.md` (canonical runbook)
+### `template/README.md` (canonical runbook)
 
-This file is the single source of truth for operators and coding agents. The example detail page on DevHub points users here via clone + `cd` into the example folder; it must be complete enough to deploy without guessing.
+This file is the single source of truth for operators and coding agents. The example detail page on DevHub points users here via clone + `cd` into `template/`; it must be complete enough to deploy without guessing.
 
 Include, as appropriate:
 
 1. **Architecture** — short diagram or bullet flow (OLTP → sync → pipelines → app, etc.).
 2. **Components** — what lives in `client/`, `server/`, `pipelines/`, `seed/`, `provisioning/sql/`.
 3. **Provisioning** — numbered order of operations. For each step, state clearly what is:
-   - **Runnable SQL** — point to files under `provisioning/sql/`.
+   - **Runnable SQL** — point to files under `template/provisioning/sql/`.
    - **Manual / UI only** — Lakehouse Sync, Sync Tables, Genie space, catalog creation with storage root, etc.
    - **CLI / bundles** — which directory to `cd` into, `databricks bundle deploy` targets, dependencies between pipelines and app.
-4. **Seeding** — exact commands from `seed/` (`cd seed`, `npm install`, `DATABASE_URL=... npm run seed`). Note Postgres prerequisites (e.g. `REPLICA IDENTITY FULL`).
-5. **Deploy** — from the example root: install, build, `databricks bundle deploy`. Link pipeline deploys before/after as required.
-6. **Optional** — `databricks apps init --template https://github.com/databricks/app-templates/tree/main/<slug>` for users who scaffold instead of cloning.
+4. **Seeding** — exact commands from `template/seed/` (`cd seed`, `npm install`, `DATABASE_URL=... npm run seed`). Note Postgres prerequisites (e.g. `REPLICA IDENTITY FULL`).
+5. **Deploy** — from `template/`: install, build, `databricks bundle deploy`. Link pipeline deploys before/after as required.
+6. **Optional** — `databricks apps init --template https://github.com/databricks/devhub/tree/main/examples/<slug>` for users who scaffold instead of cloning.
 
-Do **not** maintain a separate long-form `provisioning/README.md` next to the SQL — duplicate instructions drift. Keep narrative in `README.md` only.
+Do **not** maintain a separate long-form `provisioning/README.md` next to the SQL — duplicate instructions drift. Keep narrative in `template/README.md` only.
 
-For examples with no Unity Catalog DDL, still add `provisioning/sql/` with a comment-only file (e.g. `00_no_unity_catalog_ddl.sql`) so every example has a predictable place for SQL.
+For examples with no Unity Catalog DDL, still add `template/provisioning/sql/` with a comment-only file (e.g. `00_no_unity_catalog_ddl.sql`) so every example has a predictable place for SQL.
 
 ### 2. Create The Example Markdown
 
-Create `content/examples/<slug>/content.md`:
+Create `content/examples/<slug>/goal.md`:
 
-- Start with `## <Template Title>`.
-- Brief motivation (1-2 paragraphs): what it demonstrates and why.
-- Data flow or architecture description.
-- What the user needs to adapt: which resources to create, which placeholders to fill in, manual steps (Lakehouse Sync, Sync Tables, etc.).
-- Add a sentence under **What to Adapt** that **provisioning, seeding, and deployment** are documented in the repository's **`README.md`** — do not duplicate the runbook in this markdown.
-- Keep it short and actionable.
+- Write a concise outcome description (5-10 lines): what the example builds, what you'll have when done.
+- Optionally add `prerequisites.md` for workspace-specific requirements.
+- Keep it focused on the "what", not the "how" — agent skills and `template/README.md` handle implementation details.
 
 ### 3. Register The Example
 
 Update `src/lib/recipes/recipes.ts`:
 
 - Add an entry to `examples` using `createExample()`.
-- Set `id`, `name`, `description`, `templateUrl`, `initCommand`, `templateIds`, `recipeIds`.
+- Set `id`, `name`, `description`, `githubPath`, `initCommand`, `templateIds`, `recipeIds`.
 - `templateIds` references cookbooks the example builds upon.
 - `recipeIds` references standalone recipes not already pulled in via a cookbook.
 - `createExample()` derives `tags` and `services`.
-- `initCommand` format: `git clone --depth 1 https://github.com/databricks/app-templates.git` then `cd app-templates/<slug>`. Optional CLI scaffold: `databricks apps init --template https://github.com/databricks/app-templates/tree/main/<slug>`.
-- `templateUrl` is `https://github.com/databricks/app-templates/tree/main/<slug>`.
+- `initCommand` format: `git clone --depth 1 https://github.com/databricks/devhub.git` then `cd devhub/examples/<slug>/template`. Optional CLI scaffold: `databricks apps init --template https://github.com/databricks/devhub/tree/main/examples/<slug>`.
+- `githubPath` is `examples/<slug>`.
 
 ### 4. Add Preview And Gallery Images (Optional)
 
@@ -204,7 +195,7 @@ Screenshot guidance:
 - Light mode: `--db-bg` + `--db-card` surfaces, navy text, orange accents.
 - Dark mode: `--db-navy` + `--db-navy-light` surfaces, `--db-lava-light` accents, near-white text. Avoid pure-black CSS defaults.
 - Use orange (`--db-lava` / `--db-lava-light`) sparingly — primary CTAs, active state, single accents. Avoid saturating whole regions.
-- AppKit defaults already wire these tokens into Tailwind; copy from an existing example's `client/tailwind.config.ts` so new examples are on-brand by default.
+- AppKit defaults already wire these tokens into Tailwind; copy from an existing example's `template/client/tailwind.config.ts` so new examples are on-brand by default.
 
 ### 5. Verify The DevHub Build
 
@@ -212,9 +203,9 @@ Run `npm run fmt && npm run typecheck && npm run build && npm run test` from the
 
 ### 6. Test With A Dry Run
 
-**Two directories, two purposes.** `app-templates/<slug>/` (in the separate app-templates repo) is committed source code with `REPLACE_ME` placeholders. `../../demos/<slug>/` (outside the repo) is the scratch workspace for installing, configuring, and deploying.
+**Two directories, two purposes.** `examples/` is committed source code with `REPLACE_ME` placeholders. `../../demos/<slug>/` (outside the repo) is the scratch workspace for installing, configuring, and deploying.
 
-NEVER `npm install`, deploy, or write workspace-specific values inside `app-templates/<slug>/`. ALWAYS work from the demos folder outside the repo.
+NEVER `npm install`, deploy, or write workspace-specific values inside `examples/`. ALWAYS work from the demos folder outside the repo.
 
 NEVER reuse existing workspace resources (Lakebase projects, Genie spaces, apps, UC catalogs) unless the developer explicitly says to. Always create fresh resources for the dry run to avoid corrupting or overwriting existing data.
 
@@ -225,7 +216,7 @@ The demos folder must be **outside the git repo** because `databricks bundle dep
 ```bash
 # 1. Copy the template tree into demos (outside the repo)
 mkdir -p ../../demos/<slug>
-cp -r <app-templates-repo>/<slug>/* ../../demos/<slug>/
+cp -r examples/<slug>/template/* ../../demos/<slug>/
 
 # 2. Fill in workspace-specific values
 #    Edit ../../demos/<slug>/databricks.yml — replace REPLACE_ME with real IDs
@@ -242,7 +233,7 @@ npm run build
 #    - Unity Catalog table (if analytics queries need warehouse-accessible data)
 
 # 5. Seed data (if the example has a seed script)
-cd <app-templates-repo>/<slug>/seed
+cd <devhub-repo>/examples/<slug>/template/seed
 npm install
 DATABASE_URL="postgresql://..." npm run seed
 
@@ -256,9 +247,9 @@ databricks apps get <app-name> --profile <PROFILE>
 
 #### Fixing issues found during dry run
 
-- **Code bug** (build fails, runtime error, wrong SQL dialect) — fix in `app-templates/<slug>/` in the app-templates repo, then re-copy to `../../demos/<slug>/` and retry.
-- **Instruction gap** (missing step, unclear placeholder) — fix in `content/examples/<slug>/content.md` or the relevant recipe under `content/recipes/`.
-- **Seed data issue** — fix in `app-templates/<slug>/seed/seed.ts`.
+- **Code bug** (build fails, runtime error, wrong SQL dialect) — fix in `examples/<slug>/` in the repo, then re-copy to `../../demos/<slug>/` and retry.
+- **Instruction gap** (missing step, unclear placeholder) — fix in `content/examples/<slug>/goal.md` or the relevant recipe under `content/recipes/`.
+- **Seed data issue** — fix in `examples/<slug>/template/seed/seed.ts`.
 
 #### Cleanup
 
@@ -295,11 +286,11 @@ These rules are enforced mechanically by `scripts/validate-content.mjs`, which f
 
 All templates share a flat URL hierarchy:
 
-| Internal kind | Public URL          | Route source                                                                  |
-| ------------- | ------------------- | ----------------------------------------------------------------------------- |
-| `recipe`      | `/templates/<slug>` | Generated by content-entries plugin from `content/recipes/<slug>/content.md`  |
-| `cookbook`    | `/templates/<slug>` | Manual page in `src/pages/templates/<slug>.tsx`                               |
-| `example`     | `/templates/<slug>` | Generated by content-entries plugin from `content/examples/<slug>/content.md` |
+| Internal kind | Public URL          | Route source                                                               |
+| ------------- | ------------------- | -------------------------------------------------------------------------- |
+| `recipe`      | `/templates/<slug>` | Generated by content-entries plugin from `content/recipes/<slug>/goal.md`  |
+| `cookbook`    | `/templates/<slug>` | Manual page in `src/pages/templates/<slug>.tsx`                            |
+| `example`     | `/templates/<slug>` | Generated by content-entries plugin from `content/examples/<slug>/goal.md` |
 
 Slugs must be globally unique. The plugin throws at build time if any collision exists.
 
@@ -339,24 +330,22 @@ Allowed exceptions (the validator skips these):
 2. Verify every markdown import path resolves.
 3. For cookbooks: verify `recipeIds` order matches the rendered JSX order.
 4. Verify prerequisites are only used on recipes.
-5. Verify no `content.md` file contains a `Prerequisites` heading, admonition, or "follow these templates first" step — that content lives only in `prerequisites.md`.
+5. Verify no `goal.md` file contains prerequisite content — that lives only in `prerequisites.md`.
 6. Verify title, description, and tags are specific (not generic) and do **not** contain the words "recipe", "cookbook", or "guide".
 7. Verify commands are runnable and do not skip required auth/profile context.
 8. Verify no slug collisions across recipes, cookbooks, and examples.
-9. Verify the output reads cleanly as both:
-   - a prompt for an AI coding agent
-   - a human step-by-step walkthrough
+9. Verify the output reads cleanly as a prompt for an AI coding agent.
 10. Run `npm run validate:content && npm run fmt && npm run typecheck && npm run build && npm run test`.
-11. For examples: verify `app-templates/<slug>/` contains only `REPLACE_ME` placeholders — no real workspace hosts, warehouse IDs, Lakebase project names, or Genie space IDs.
-12. For examples: verify `app-templates/<slug>/README.md` covers provisioning (manual vs SQL), seeding, pipeline deploys, and app deploy end-to-end.
+11. For examples: verify `examples/<slug>/` contains only `REPLACE_ME` placeholders — no real workspace hosts, warehouse IDs, Lakebase project names, or Genie space IDs.
+12. For examples: verify `examples/<slug>/template/README.md` covers provisioning (manual vs SQL), seeding, pipeline deploys, and app deploy end-to-end.
 13. For examples: verify the dry-run deploy succeeded and the app is functional before considering the example complete.
 
 ## References
 
-- Read `content/recipes/set-up-your-local-dev-environment/content.md` for atomic-template structure and tone.
-- Read `content/examples/agentic-support-console/content.md` for example-template markdown style.
+- Read `content/recipes/set-up-your-local-dev-environment/goal.md` for atomic-template goal structure and tone.
+- Read `content/examples/agentic-support-console/goal.md` for example-template goal style.
 - Read `src/lib/recipes/recipes.ts` for all type contracts (`Recipe`, `Cookbook`, `Example`).
 - Read `src/pages/templates/app-with-lakebase.tsx` for the cookbook composition pattern.
 - Read `src/components/examples/example-detail.tsx` for example detail rendering.
-- Read `app-templates/agentic-support-console/README.md` (in the [app-templates](https://github.com/databricks/app-templates) repo) for a full example runbook (provisioning, SQL, seed, pipelines, deploy).
+- Read `examples/agentic-support-console/template/README.md` for a full example runbook (provisioning, SQL, seed, pipelines, deploy).
 - Read `plugins/content-entries.ts` for slug parity and uniqueness validation.
diff --git a/api/content-markdown.ts b/api/content-markdown.ts
index 7d4fbb4..b75d33d 100644
--- a/api/content-markdown.ts
+++ b/api/content-markdown.ts
@@ -233,7 +233,6 @@ function readCookbookMarkdown(rootDir: string, slug: string): string {
     goal,
     intro: goal ? undefined : readCookbookIntro(rootDir, slug),
     recipes: recipeInputs,
-    mode: "agent",
   });
 }
 
diff --git a/content/examples/rag-chat/content.md b/content/examples/rag-chat/content.md
deleted file mode 100644
index 3551c04..0000000
--- a/content/examples/rag-chat/content.md
+++ /dev/null
@@ -1,21 +0,0 @@
-### 2. Create the Lakebase Postgres prerequisites
-
-The template's AppKit Lakebase plugin requires an existing Postgres **branch** and **database**. `databricks postgres create-project` automatically provisions a default branch named `production` and a default database on it, so one command is all you need. Pick a short lowercase project id and export the resolved resource names — the next step's `databricks apps init` command reads them as shell variables.
-
-```bash
-PROJECT_ID=rag-chat
-
-databricks postgres create-project "$PROJECT_ID"
-
-export BRANCH_NAME="projects/$PROJECT_ID/branches/production"
-export DATABASE_NAME=$(databricks api get "/api/2.0/postgres/$BRANCH_NAME/databases" -o json | \
-  python3 -c "import json,sys; print(json.load(sys.stdin)['databases'][0]['name'])")
-
-echo "Branch:   $BRANCH_NAME"
-echo "Database: $DATABASE_NAME"
-```
-
-`create-project` is long-running; the CLI waits for it to finish by default. **If it reports `already exists`:**
-
-- **Prefer picking a different `PROJECT_ID`** (e.g. append a short suffix) and re-export `BRANCH_NAME` / `DATABASE_NAME` from the new id. Lakebase projects can hold data that other apps and pipelines depend on, so do **not** run `databricks postgres delete-project` on an existing project without explicit confirmation from the user that nothing else uses it.
-- **Eventual-consistency exception:** if you just deleted a project with this id in the same session and `databricks postgres list-projects` no longer shows it, wait 30–60s and retry `create-project` — the control plane is briefly inconsistent after deletion.
diff --git a/content/recipes/ai-chat-model-serving/content.md b/content/recipes/ai-chat-model-serving/content.md
deleted file mode 100644
index bf18756..0000000
--- a/content/recipes/ai-chat-model-serving/content.md
+++ /dev/null
@@ -1,216 +0,0 @@
-## Streaming AI Chat with Model Serving
-
-Build a streaming AI chat experience in a Databricks App using Vercel AI SDK with Databricks Model Serving and OpenAI-compatible endpoints.
-
-### 1. Install AI SDK packages
-
-```bash
-npm install ai@6 @ai-sdk/react@3 @ai-sdk/openai @databricks/sdk-experimental
-```
-
-> **Version note**: This template uses AI SDK v6 APIs (`TextStreamChatTransport`, `sendMessage({ text })`, transport-based `useChat`). Tested with `ai@6.1`, `@ai-sdk/react@3.1`, and `@ai-sdk/openai@3.x`.
-
-> **Note**: `@databricks/sdk-experimental` is included in the scaffolded `package.json`. It is listed here for reference if adding AI chat to an existing project.
-
-> **Optional**: For pre-built chat UI components, initialize shadcn and add AI Elements:
->
-> ```bash
-> npx shadcn@latest init
-> ```
->
-> This basic template works without AI Elements. They are optional prebuilt components.
-
-### 2. Configure environment variables for AI Gateway
-
-Configure your Databricks workspace ID and model endpoint:
-
-For local development (`.env`):
-
-```bash
-echo 'DATABRICKS_WORKSPACE_ID=<your-workspace-id>' >> .env
-echo 'DATABRICKS_ENDPOINT=<your-endpoint>' >> .env
-echo 'DATABRICKS_CONFIG_PROFILE=DEFAULT' >> .env
-```
-
-For deployment in Databricks Apps (`app.yaml`):
-
-```yaml
-env:
-  - name: DATABRICKS_WORKSPACE_ID
-    value: "<your-workspace-id>"
-  - name: DATABRICKS_ENDPOINT
-    value: "<your-endpoint>"
-```
-
-> **Workspace ID**: AppKit auto-discovers this at runtime. For explicit setup, run `databricks api get /api/2.1/unity-catalog/current-metastore-assignment --profile <PROFILE>` and use the `workspace_id` field.
-
-> **Model compatibility**: This template uses OpenAI-compatible models served via Databricks AI Gateway, which support the AI SDK's streaming API. The AI Gateway URL uses the `/mlflow/v1` path (not `/openai/v1`).
-
-> **Find your endpoint**: Run `databricks serving-endpoints list --profile <PROFILE>` to see available models. Common endpoints include `databricks-meta-llama-3-3-70b-instruct` and `databricks-claude-sonnet-4`, but availability varies by workspace.
-
-### 3. Configure authentication helper
-
-Create a helper function that works for both local development and deployed apps:
-
-```typescript
-import { Config } from "@databricks/sdk-experimental";
-
-async function getDatabricksToken() {
-  // For deployed apps, use service principal token
-  if (process.env.DATABRICKS_TOKEN) {
-    return process.env.DATABRICKS_TOKEN;
-  }
-
-  // For local dev, use CLI profile auth via Databricks SDK
-  const config = new Config({
-    profile: process.env.DATABRICKS_CONFIG_PROFILE || "DEFAULT",
-  });
-  await config.ensureResolved();
-  const headers = new Headers();
-  await config.authenticate(headers);
-  const authHeader = headers.get("Authorization");
-  if (!authHeader) {
-    throw new Error(
-      "Failed to get Databricks token. Check your CLI profile or set DATABRICKS_TOKEN.",
-    );
-  }
-  return authHeader.replace("Bearer ", "");
-}
-```
-
-This function uses the Databricks SDK auth chain, which reads ~/.databrickscfg profiles and handles OAuth token refresh. For deployed apps, set DATABRICKS_TOKEN directly.
-
-> **User identity in deployed apps**: Databricks Apps injects user identity via request headers. Extract it with `req.header("x-forwarded-email")` or `req.header("x-forwarded-user")`. Use this for chat persistence and access control.
-
-### 4. Add `/api/chat` route with streaming
-
-Create a server route using the AI SDK's streaming support:
-
-```typescript
-import { createOpenAI } from "@ai-sdk/openai";
-import { streamText, type UIMessage } from "ai";
-
-app.post("/api/chat", async (req, res) => {
-  const { messages } = req.body;
-
-  // AI SDK v6 client sends UIMessage objects with a parts array.
-  // Convert to CoreMessage format for streamText().
-  const coreMessages = (messages as UIMessage[]).map((m) => ({
-    role: m.role as "user" | "assistant" | "system",
-    content:
-      m.parts
-        ?.filter((p) => p.type === "text" && p.text)
-        .map((p) => p.text)
-        .join("") ??
-      m.content ??
-      "",
-  }));
-
-  try {
-    const token = await getDatabricksToken();
-    const endpoint = process.env.DATABRICKS_ENDPOINT || "<your-endpoint>";
-
-    // Configure Databricks AI Gateway as OpenAI-compatible provider
-    const databricks = createOpenAI({
-      baseURL: `https://${process.env.DATABRICKS_WORKSPACE_ID}.ai-gateway.cloud.databricks.com/mlflow/v1`,
-      apiKey: token,
-    });
-
-    // Stream the response using AI SDK v6
-    const result = streamText({
-      model: databricks.chat(endpoint),
-      messages: coreMessages,
-      maxOutputTokens: 1000,
-    });
-
-    // v6 API: pipe the text stream to the Express response
-    result.pipeTextStreamToResponse(res);
-  } catch (err) {
-    const message = (err as Error).message;
-    console.error(`[chat] Streaming request failed:`, message);
-    res.status(502).json({
-      error: "Chat request failed",
-      detail: message,
-    });
-  }
-});
-```
-
-### 5. Render the streaming chat UI
-
-Use `useChat` from the AI SDK with `TextStreamChatTransport` for streaming support:
-
-```tsx
-import { useChat } from "@ai-sdk/react";
-import { TextStreamChatTransport } from "ai";
-import { useState } from "react";
-
-export function ChatPage() {
-  const [input, setInput] = useState("");
-
-  const { messages, sendMessage, status } = useChat({
-    transport: new TextStreamChatTransport({ api: "/api/chat" }),
-  });
-
-  return (
-    <div className="flex flex-col h-full">
-      <div className="flex-1 overflow-y-auto space-y-4 p-4">
-        {messages.map((m) => (
-          <div key={m.id} className={m.role === "user" ? "text-right" : ""}>
-            <span className="text-sm font-medium">
-              {m.role === "user" ? "You" : "Assistant"}
-            </span>
-            {m.parts.map((part, i) =>
-              part.type === "text" ? (
-                <p key={`${m.id}-${i}`} className="whitespace-pre-wrap">
-                  {part.text}
-                </p>
-              ) : null,
-            )}
-          </div>
-        ))}
-        {status === "submitted" && <div className="p-4">Loading...</div>}
-      </div>
-      <form
-        onSubmit={(e) => {
-          e.preventDefault();
-          if (input.trim()) {
-            void sendMessage({ text: input });
-            setInput("");
-          }
-        }}
-        className="border-t p-4 flex gap-2"
-      >
-        <input
-          value={input}
-          onChange={(e) => setInput(e.target.value)}
-          placeholder="Ask a question..."
-          className="flex-1 border rounded px-3 py-2"
-          disabled={status !== "ready"}
-        />
-        <button type="submit" disabled={status !== "ready"}>
-          {status === "submitted" || status === "streaming"
-            ? "Sending..."
-            : "Send"}
-        </button>
-      </form>
-    </div>
-  );
-}
-```
-
-### 6. Deploy and verify
-
-```bash
-databricks apps deploy --profile <PROFILE>
-databricks apps list --profile <PROFILE>
-databricks apps logs <app-name> --profile <PROFILE>
-```
-
-Open the app URL while signed in to Databricks, send a message, and verify streaming responses appear token-by-token from the AI Gateway endpoint.
-
-#### References
-
-- [Model Serving Overview](https://docs.databricks.com/aws/en/machine-learning/model-serving/)
-- [Serving Endpoints](https://docs.databricks.com/aws/en/machine-learning/model-serving/create-foundation-model-endpoints)
-- [AI Elements docs](https://elements.ai-sdk.dev/docs)
diff --git a/content/recipes/ai-chat-model-serving/goal.md b/content/recipes/ai-chat-model-serving/goal.md
index fd5b08e..8f2e9da 100644
--- a/content/recipes/ai-chat-model-serving/goal.md
+++ b/content/recipes/ai-chat-model-serving/goal.md
@@ -1,5 +1,3 @@
-Build a streaming AI chat experience in a Databricks App using Vercel AI SDK with Databricks Model Serving and OpenAI-compatible endpoints.
-
 When done, you will have:
 
 - A real-time streaming chat interface in your Databricks App
diff --git a/content/recipes/ai-chat-model-serving/prerequisites.md b/content/recipes/ai-chat-model-serving/prerequisites.md
index 9aca76a..e168cfb 100644
--- a/content/recipes/ai-chat-model-serving/prerequisites.md
+++ b/content/recipes/ai-chat-model-serving/prerequisites.md
@@ -5,6 +5,5 @@ Complete these prerequisite templates first:
 
 Then verify these Databricks workspace features are enabled. If any check fails, ask your workspace admin to enable the feature.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **An OpenAI-compatible chat endpoint in Model Serving.** Run `databricks serving-endpoints list --profile <PROFILE>` and confirm at least one OpenAI-compatible chat endpoint is listed (e.g. `databricks-gpt-5-4-mini`, `databricks-meta-llama-3-3-70b-instruct`, or `databricks-claude-sonnet-4`). Endpoint availability varies by workspace and region; note the one you plan to set as `DATABRICKS_ENDPOINT`.
 - **Databricks Apps enabled.** Run `databricks apps list --profile <PROFILE>` and confirm the command succeeds (an empty list is fine). A permission or `not enabled` error means Apps is not available to this identity in this workspace.
diff --git a/content/recipes/embeddings-generation/content.md b/content/recipes/embeddings-generation/content.md
deleted file mode 100644
index 5de1fd0..0000000
--- a/content/recipes/embeddings-generation/content.md
+++ /dev/null
@@ -1,63 +0,0 @@
-## Generate Embeddings with AI Gateway
-
-Generate text embeddings from a Databricks AI Gateway endpoint using the Databricks SDK.
-
-### 1. Find an embedding endpoint
-
-```bash
-databricks serving-endpoints list --profile <PROFILE>
-```
-
-Common embedding endpoints: `databricks-gte-large-en` (1024d), `databricks-bge-large-en` (1024d).
-
-### 2. Configure environment
-
-`.env`:
-
-```bash
-DATABRICKS_EMBEDDING_ENDPOINT=databricks-gte-large-en
-```
-
-`app.yaml`:
-
-```yaml
-env:
-  - name: DATABRICKS_EMBEDDING_ENDPOINT
-    value: "databricks-gte-large-en"
-```
-
-### 3. Embedding helper
-
-Create `server/lib/embeddings.ts`:
-
-```typescript
-import { getWorkspaceClient } from "@databricks/appkit";
-
-const workspaceClient = getWorkspaceClient({});
-
-export async function generateEmbedding(text: string): Promise<number[]> {
-  const endpoint =
-    process.env.DATABRICKS_EMBEDDING_ENDPOINT || "databricks-gte-large-en";
-  const result = await workspaceClient.servingEndpoints.query({
-    name: endpoint,
-    input: text,
-  });
-  return result.data![0].embedding!;
-}
-```
-
-No additional dependencies — uses `@databricks/appkit` already in your project.
-
-### 4. Verify
-
-```bash
-databricks serving-endpoints query <embedding-endpoint> \
-  --json '{"input": "Hello, world!"}' \
-  --profile <PROFILE>
-```
-
-Response includes a `data` array with `embedding` (float array).
-
-#### References
-
-- [Query embedding models](https://docs.databricks.com/aws/en/machine-learning/model-serving/query-embedding-models)
diff --git a/content/recipes/embeddings-generation/goal.md b/content/recipes/embeddings-generation/goal.md
index f59d640..cce7658 100644
--- a/content/recipes/embeddings-generation/goal.md
+++ b/content/recipes/embeddings-generation/goal.md
@@ -1,5 +1,3 @@
-Generate text embeddings from a Databricks AI Gateway endpoint using the Databricks SDK.
-
 When done, you will have:
 
 - A configured embedding endpoint in your app environment
diff --git a/content/recipes/embeddings-generation/prerequisites.md b/content/recipes/embeddings-generation/prerequisites.md
index 08a4240..06e9b94 100644
--- a/content/recipes/embeddings-generation/prerequisites.md
+++ b/content/recipes/embeddings-generation/prerequisites.md
@@ -1,4 +1,3 @@
 Verify these Databricks workspace features are enabled before starting. If any check fails, ask your workspace admin to enable the feature.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **An embedding endpoint in Model Serving.** Run `databricks serving-endpoints list --profile <PROFILE>` and confirm at least one embedding endpoint is listed (for example `databricks-gte-large-en` or `databricks-bge-large-en`, both 1024-dimension). Endpoint availability varies by workspace; note the endpoint name you plan to set as `DATABRICKS_EMBEDDING_ENDPOINT`.
diff --git a/content/recipes/foundation-models-api/content.md b/content/recipes/foundation-models-api/content.md
deleted file mode 100644
index 34317f2..0000000
--- a/content/recipes/foundation-models-api/content.md
+++ /dev/null
@@ -1,117 +0,0 @@
-## Query AI Gateway Endpoints
-
-Access Databricks foundation models through AI Gateway endpoints with built-in governance, monitoring, and production-readiness features.
-
-### 1. Understand AI Gateway endpoints
-
-**AI Gateway** is a governance layer on top of model serving endpoints that provides permissions, rate limiting, payload logging, and AI guardrails. Currently in beta, AI Gateway is becoming the default way to access foundation models in Databricks.
-
-**Note**: AI Gateway is built into all Foundation Model API endpoints. If you need to access non-AI Gateway endpoints, use the Databricks SDK's `servingEndpoints.query()` method directly.
-
-### 2. Check if AI Gateway is available
-
-All Foundation Model API endpoints have AI Gateway built-in. To verify, check if a known FM endpoint has the `ai_gateway` configuration:
-
-```bash
-databricks serving-endpoints get <your-endpoint> --profile <PROFILE> --output json | grep -q '"ai_gateway"' && echo "✓ AI Gateway available" || echo "✗ No AI Gateway"
-```
-
-### 3. Choose your model
-
-List available AI Gateway endpoints in your workspace:
-
-```bash
-databricks serving-endpoints list --profile <PROFILE>
-```
-
-Common AI Gateway endpoint names:
-
-- `databricks-meta-llama-3-3-70b-instruct`
-- `databricks-gemini-3-1-flash-lite`
-- `databricks-dbrx-instruct`
-
-> **Note**: When using this template with a coding agent, specify which endpoint to use based on what's available in your workspace. Endpoint names may vary.
-
-> **Important**: Endpoint availability varies by workspace. Always run `databricks serving-endpoints list` to check what's available before configuring your app.
-
-### 4. Configure environment variables
-
-For local development (`.env`):
-
-```bash
-DATABRICKS_ENDPOINT=<your-endpoint>
-```
-
-For deployment (`app.yaml`):
-
-```yaml
-env:
-  - name: DATABRICKS_ENDPOINT
-    value: "<your-endpoint>"
-```
-
-### 5. Query AI Gateway endpoints
-
-```typescript
-import { getWorkspaceClient } from "@databricks/appkit";
-
-// {} tells the SDK to use default auth chain (env vars / profile).
-// Do NOT omit. getWorkspaceClient() with no argument will throw.
-const workspaceClient = getWorkspaceClient({});
-const endpoint = process.env.DATABRICKS_ENDPOINT || "<your-endpoint>";
-
-async function queryModel(messages: any[]) {
-  const result = await workspaceClient.servingEndpoints.query({
-    name: endpoint,
-    messages: messages,
-    max_tokens: 1000,
-  });
-
-  return result;
-}
-```
-
-**For streaming responses:** For OpenAI-compatible models, use the Vercel AI SDK's `createOpenAI` provider with AI Gateway:
-
-```typescript
-import { createOpenAI } from "@ai-sdk/openai";
-import { streamText } from "ai";
-
-const databricks = createOpenAI({
-  baseURL: `https://${process.env.DATABRICKS_WORKSPACE_ID}.ai-gateway.cloud.databricks.com/mlflow/v1`,
-  apiKey: token,
-});
-
-const result = streamText({
-  model: databricks.chat(endpoint), // e.g., "databricks-gpt-5-4-mini"
-  messages,
-  maxOutputTokens: 1000,
-});
-
-// AI SDK v6: pipe the text stream to the Express response
-result.pipeTextStreamToResponse(res);
-```
-
-> **Auth for streaming**: The streaming example above requires a bearer token for `createOpenAI()`. See the [Streaming AI Chat template](#streaming-ai-chat-with-model-serving) for the full auth helper pattern using `@databricks/sdk-experimental`.
-
-> **Note**: This pattern works with OpenAI-compatible models (`databricks-gpt-5-4-mini`, `databricks-gpt-oss-120b`). Native Databricks models use the MLflow unified API.
->
-> **Workspace ID**: AppKit auto-discovers this at runtime. For explicit setup, run `databricks api get /api/2.1/unity-catalog/current-metastore-assignment --profile <PROFILE>` and use the `workspace_id` field.
-
-See the [Streaming AI Chat template](/templates/ai-chat-app#streaming-ai-chat-with-model-serving) for a complete implementation.
-
-### 6. Test the endpoint
-
-Query an AI Gateway endpoint:
-
-```bash
-databricks serving-endpoints query <your-endpoint> \
-  --json '{"messages": [{"role": "user", "content": "Hello"}], "max_tokens": 100}' \
-  --profile <PROFILE>
-```
-
-#### References
-
-- [AI Gateway Overview](https://docs.databricks.com/aws/en/ai-gateway/overview-beta)
-- [AI Gateway and Serving Endpoints](https://docs.databricks.com/aws/en/ai-gateway/overview-serving-endpoints)
-- [Vercel AI SDK](https://sdk.vercel.ai/docs) - For streaming implementations
diff --git a/content/recipes/foundation-models-api/goal.md b/content/recipes/foundation-models-api/goal.md
index 0068164..1b64187 100644
--- a/content/recipes/foundation-models-api/goal.md
+++ b/content/recipes/foundation-models-api/goal.md
@@ -1,5 +1,3 @@
-Access Databricks foundation models through AI Gateway endpoints with built-in governance, monitoring, and streaming support.
-
 When done, you will have:
 
 - A configured AI Gateway endpoint for chat inference in your app
diff --git a/content/recipes/foundation-models-api/prerequisites.md b/content/recipes/foundation-models-api/prerequisites.md
index 192380e..a82070d 100644
--- a/content/recipes/foundation-models-api/prerequisites.md
+++ b/content/recipes/foundation-models-api/prerequisites.md
@@ -1,4 +1,3 @@
 Verify these Databricks workspace features are enabled before starting. If any check fails, ask your workspace admin to enable the feature.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **AI Gateway (currently in Beta).** AI Gateway is built into all Foundation Model API endpoints, but it is still a **Beta** feature — behavior and APIs can change. Confirm availability by listing endpoints and checking the config: `databricks serving-endpoints list --profile <PROFILE>` should return at least one `databricks-*` foundation-model endpoint, and `databricks serving-endpoints get <endpoint-name> --profile <PROFILE> -o json | grep -q '"ai_gateway"' && echo ok` should print `ok`. Endpoint availability varies by workspace and region.
diff --git a/content/recipes/genie-conversational-analytics/content.md b/content/recipes/genie-conversational-analytics/content.md
deleted file mode 100644
index 79ee0c9..0000000
--- a/content/recipes/genie-conversational-analytics/content.md
+++ /dev/null
@@ -1,275 +0,0 @@
-## Genie Conversational Analytics
-
-Embed a Databricks AI/BI Genie chat interface so users can explore data through natural language. Configure a Genie space, wire up the server and client plugins, declare app resources, and deploy.
-
-> **Choose your path:**
->
-> - **New app** — follow steps 1 → 2 → 8.
-> - **Adding Genie to an existing AppKit app** — follow steps 1 → 3 → 4 → 5 → 6 → 7 → 8.
-
-### 1. Create a Genie space and set your profile
-
-Open your Databricks workspace, navigate to **AI/BI Genie**, and create a new Genie space connected to your data tables.
-
-List your spaces to get the `space_id`:
-
-```bash
-databricks genie list-spaces -o json --profile <PROFILE>
-```
-
-Use the `space_id` value wherever a space ID is required (scaffold `--set`, `.env`, and `databricks.yml`).
-
-**Tip: Avoid repeating `--profile` on every command**
-
-Add your profile to the bundle's `databricks.yml` under the target — then `bundle deploy` and `apps` commands pick it up automatically:
-
-```yaml
-targets:
-  default:
-    workspace:
-      profile: <PROFILE>
-```
-
-This is more reliable than `export DATABRICKS_CONFIG_PROFILE` since it persists across shells and works for agents running commands in subshells.
-
-### 2. New app: scaffold with the Genie feature
-
-If you are starting a new app, scaffold it with the Genie feature flag. This generates all server, client, resource, and environment wiring automatically.
-
-Run this from a neutral directory (not inside another app folder) — `apps init` creates the project folder in your current working directory:
-
-```bash
-databricks apps init \
-  --name <app-name> \
-  --version latest \
-  --features=genie \
-  --set 'genie.genie-space.id=<your-space-id>' \
-  --run none
-```
-
-`--run none` skips launching the app locally after scaffolding. Use the `space_id` from step 1 for `<your-space-id>`.
-
-**App name:** Use at most 26 characters, **lowercase letters, digits, and hyphens only** (no underscores). Example: `my-genie-app`, not `my_genie_app`.
-
-**Warning: Fix generated `databricks.yml` before deploying**
-
-The scaffold generates a `genie_space_name` variable and references it as `name: ${var.genie_space_name}`, but never assigns a value in `targets:`. `bundle deploy` will fail with _no value assigned to required variable genie_space_name_.
-
-Assign both variables in your `targets:` block:
-
-```yaml
-variables:
-  genie_space_id:
-    description: Genie Space ID
-  genie_space_name:
-    description: Genie Space name
-
-targets:
-  default:
-    variables:
-      genie_space_id: <your-space-id>
-      genie_space_name: <your-space-display-name>
-```
-
-The `genie_space` resource block should reference both variables:
-
-```yaml
-genie_space:
-  name: ${var.genie_space_name}
-  space_id: ${var.genie_space_id}
-  permission: CAN_RUN
-```
-
-Skip to step 8 to deploy.
-
----
-
-### 3. Existing app: add Genie server plugin
-
-The following steps match what `apps init --features=genie` generates. Apply them to an existing scaffolded AppKit app.
-
-> **Tip:** The code below may be outdated. To get the latest, clone `https://github.com/databricks/appkit` and look in the `template/` directory. Search for `{{if .plugins.genie}}` to find all genie-conditional files and blocks.
-
-In `server/server.ts`, add `genie` to the import and plugins array:
-
-```typescript
-import { createApp, server, genie } from "@databricks/appkit";
-
-createApp({
-  plugins: [server(), genie()],
-}).catch(console.error);
-```
-
-The `genie()` plugin reads `DATABRICKS_GENIE_SPACE_ID` (the **space ID**, not the display name) from the environment and registers it under the `default` alias. To register multiple spaces, pass explicit aliases:
-
-```typescript
-genie({
-  spaces: {
-    sales: "<sales-space-id>",
-    support: "<support-space-id>",
-  },
-});
-```
-
-### 4. Existing app: create the Genie page component
-
-Create `client/src/pages/genie/GeniePage.tsx`:
-
-```tsx
-import { GenieChat } from "@databricks/appkit-ui/react";
-
-export function GeniePage() {
-  return (
-    <div className="space-y-6 w-full max-w-4xl mx-auto">
-      <div>
-        <h2 className="text-2xl font-bold text-foreground">Genie</h2>
-        <p className="text-sm text-muted-foreground mt-1">
-          Ask questions about your data using Databricks AI/BI Genie.
-        </p>
-      </div>
-      <div className="h-[600px] border rounded-lg overflow-hidden">
-        <GenieChat alias="default" />
-      </div>
-    </div>
-  );
-}
-```
-
-The `alias` prop must match a key in the server-side `spaces` configuration. When using the default single-space setup, use `"default"`.
-
-For custom chat UIs, use the `useGenieChat` hook instead of the `GenieChat` component:
-
-```tsx
-import { useGenieChat } from "@databricks/appkit-ui/react";
-
-function CustomGenieChat() {
-  const { messages, status, sendMessage, reset } = useGenieChat({
-    alias: "default",
-  });
-  // Build your own UI with messages, status, sendMessage, and reset
-}
-```
-
-### 5. Existing app: add the route
-
-In `client/src/App.tsx`, add the import, nav link, and route:
-
-```tsx
-import { GeniePage } from "./pages/genie/GeniePage";
-
-// Add inside the <nav> element
-<NavLink to="/genie" className={navLinkClass}>
-  Genie
-</NavLink>
-
-// Add in the router children array
-{ path: "/genie", element: <GeniePage /> },
-```
-
-### 6. Existing app: declare the Genie resource in `databricks.yml`
-
-The Genie space must be declared as an app resource with the `dashboards.genie` API scope. Without the scope, on-behalf-of user execution fails at runtime.
-
-Add the `genie_space_id` variable, the `user_api_scopes`, and the genie resource under your app. The `name: genie-space` on the resource is the key that `app.yaml` references via `valueFrom`:
-
-```yaml
-variables:
-  genie_space_id:
-    description: Genie space ID (from list-spaces or About)
-
-resources:
-  apps:
-    app:
-      # Merge into your existing app config
-      user_api_scopes:
-        - dashboards.genie
-      resources:
-        - name: genie-space
-          genie_space:
-            name: genie-space
-            space_id: ${var.genie_space_id}
-            permission: CAN_RUN
-
-targets:
-  default:
-    variables:
-      genie_space_id: <your-space-id>
-```
-
-### 7. Existing app: map the environment variable in `app.yaml`
-
-Add the Genie space ID mapping so the deployed app receives the value at runtime:
-
-```yaml
-env:
-  - name: DATABRICKS_GENIE_SPACE_ID
-    valueFrom: genie-space
-```
-
-The `valueFrom` value must match the resource `name` in `databricks.yml`.
-
-For local development, add the space ID to `.env`:
-
-```bash
-DATABRICKS_GENIE_SPACE_ID=<your-space-id>
-```
-
----
-
-### 8. Deploy and verify
-
-From inside the app project folder (the directory containing `databricks.yml`):
-
-```bash
-cd <app-name>
-
-# Build the client
-npm run build
-
-# Deploy bundle resources and sync files to workspace
-# Copy the upload path printed in the output — you'll need it below
-databricks bundle deploy
-
-# Put the app in RUNNING state and wait for compute to be ready
-# The loop polls every 5 seconds — press Ctrl+C if it hangs more than 2 minutes
-databricks apps start <app-name>
-until databricks apps get <app-name> -o json | grep -q '"ACTIVE"'; do sleep 5; done
-
-# First deploy requires --source-code-path: paste the path from bundle deploy output above
-databricks apps deploy <app-name> \
-  --source-code-path <path-from-bundle-deploy-output>
-```
-
-`bundle deploy` prints the workspace upload path (`Uploading bundle files to ...`) — copy that value for `--source-code-path`. `apps start` puts the app into RUNNING state; the `until` loop waits for compute to be ACTIVE. `apps deploy` deploys the source and starts the app server.
-
-For subsequent deploys, `--source-code-path` is not needed — the app remembers the path:
-
-```bash
-npm run build
-databricks bundle deploy
-databricks apps deploy <app-name>
-```
-
-Check app status and get the URL:
-
-```bash
-databricks apps get <app-name>
-```
-
-Open `<app-url>/genie` while signed in to Databricks and ask a natural-language question about your data to verify the integration.
-
-If compute is **STOPPED**, run `databricks apps start <app-name>` and wait for `compute_status.state: ACTIVE` before deploying.
-
-### 9. Troubleshoot common issues
-
-**Missing genie scope error.** If the app logs show `does not have required scopes: genie`, confirm `user_api_scopes` includes `dashboards.genie` in `databricks.yml` and redeploy. Users who authenticated before the scope was added may need to re-authorize the app.
-
-**Genie space not found.** Verify the space ID matches the value on the Genie space **About** tab. Confirm the target variable in `databricks.yml` is set to the correct ID.
-
-**`valueFrom` mismatch.** The `valueFrom` value in `app.yaml` must exactly match the resource `name` in `databricks.yml`. A mismatch causes `DATABRICKS_GENIE_SPACE_ID` to be empty at runtime.
-
-#### References
-
-- [Genie plugin docs](/docs/appkit/v0/plugins/genie)
-- [AI/BI Genie documentation](https://docs.databricks.com/en/genie/index.html)
-- [GenieChat component API](/docs/appkit/v0/api/appkit-ui/genie/GenieChat)
diff --git a/content/recipes/genie-conversational-analytics/goal.md b/content/recipes/genie-conversational-analytics/goal.md
index 2ea9039..63bdff0 100644
--- a/content/recipes/genie-conversational-analytics/goal.md
+++ b/content/recipes/genie-conversational-analytics/goal.md
@@ -1,5 +1,3 @@
-Embed a Databricks AI/BI Genie chat interface in your app so users can explore data through natural language.
-
 When done, you will have:
 
 - A configured AI/BI Genie space connected to your data tables
diff --git a/content/recipes/genie-conversational-analytics/prerequisites.md b/content/recipes/genie-conversational-analytics/prerequisites.md
index 47b2a54..5aec144 100644
--- a/content/recipes/genie-conversational-analytics/prerequisites.md
+++ b/content/recipes/genie-conversational-analytics/prerequisites.md
@@ -1,6 +1,5 @@
 Verify these Databricks workspace features are enabled before starting. If any check fails, ask your workspace admin to enable the feature.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **AI/BI Genie enabled.** Run `databricks genie list-spaces --profile <PROFILE>` and confirm the command succeeds. A `not found` or permission error means Genie is not available to this identity.
 - **At least one Genie space configured.** The command above must return at least one space; you will use its `space_id` below. If none exist, open your Databricks workspace, navigate to **AI/BI Genie**, and create a space connected to the data tables you want to query.
 - **Databricks Apps enabled.** Run `databricks apps list --profile <PROFILE>` and confirm the command succeeds (an empty list is fine). The template deploys an AppKit app that hosts the Genie chat UI.
diff --git a/content/recipes/genie-multi-space/content.md b/content/recipes/genie-multi-space/content.md
deleted file mode 100644
index 3e8c725..0000000
--- a/content/recipes/genie-multi-space/content.md
+++ /dev/null
@@ -1,287 +0,0 @@
-## Genie Multi-Space Selector
-
-Upgrade a single-space Genie app to let users switch between multiple AI/BI Genie spaces from a dropdown. Each space gets a named alias; switching spaces remounts `<GenieChat>` and clears stale conversation state automatically.
-
-### 1. List all Genie spaces you want to include
-
-List your spaces:
-
-```bash
-databricks genie list-spaces -o json --profile <PROFILE>
-```
-
-**Tip: Avoid repeating `--profile` on every command**
-
-Add your profile to the bundle's `databricks.yml` under the target — then `bundle deploy` and `apps` commands pick it up automatically:
-
-```yaml
-targets:
-  default:
-    workspace:
-      profile: <PROFILE>
-```
-
-This is more reliable than `export DATABRICKS_CONFIG_PROFILE` since it persists across shells and works for agents running commands in subshells.
-
-Note the `space_id` and `title` for each space. Decide on a short lowercase alias for each (e.g. `sales`, `support`) — these become the keys in the server `spaces` map and in the `SPACES` array on the client. They must match exactly.
-
-### 2. Update the server plugin
-
-Replace the single-space `genie()` call in `server/server.ts` with a `spaces` map. Use one environment variable per space following the pattern `DATABRICKS_GENIE_SPACE_<ALIAS>`:
-
-```typescript
-import { createApp, genie, server } from "@databricks/appkit";
-
-createApp({
-  plugins: [
-    server(),
-    genie({
-      spaces: {
-        sales: process.env.DATABRICKS_GENIE_SPACE_SALES ?? "",
-        support: process.env.DATABRICKS_GENIE_SPACE_SUPPORT ?? "",
-      },
-    }),
-  ],
-}).catch(console.error);
-```
-
-Each key becomes the alias for all API routes (`/api/genie/<alias>/messages`) and the `<GenieChat alias="..." />` prop. Add one entry per space.
-
-### 3. Update configuration files
-
-#### `.env` (local development)
-
-Keep `DATABRICKS_GENIE_SPACE_ID` — AppKit requires it at startup even when using a custom `spaces` map. Point it at any of your spaces. Add one variable per UI space:
-
-```bash
-DATABRICKS_GENIE_SPACE_ID=<any-space-id>
-DATABRICKS_GENIE_SPACE_SALES=<sales-space-id>
-DATABRICKS_GENIE_SPACE_SUPPORT=<support-space-id>
-```
-
-#### `app.yaml`
-
-Keep the `DATABRICKS_GENIE_SPACE_ID → genie-space` mapping — AppKit validates it on startup. Add one `valueFrom` per UI space:
-
-```yaml
-command: ["npm", "run", "start"]
-env:
-  - name: DATABRICKS_GENIE_SPACE_ID
-    valueFrom: genie-space
-  - name: DATABRICKS_GENIE_SPACE_SALES
-    valueFrom: genie-space-sales
-  - name: DATABRICKS_GENIE_SPACE_SUPPORT
-    valueFrom: genie-space-support
-```
-
-#### `databricks.yml`
-
-Keep `genie_space_id` and `genie-space` — AppKit requires `DATABRICKS_GENIE_SPACE_ID` to be set at runtime. This resource does **not** appear in the UI dropdown; only aliases in the server `spaces` map do. Add a new variable and resource for each UI space:
-
-```yaml
-variables:
-  genie_space_id:
-    description: Default Genie space ID (required by AppKit)
-  genie_space_sales_id:
-    description: Sales Genie space ID
-  genie_space_support_id:
-    description: Support Genie space ID
-
-resources:
-  apps:
-    app:
-      user_api_scopes:
-        - dashboards.genie
-      resources:
-        - name: genie-space
-          genie_space:
-            name: genie-space
-            space_id: ${var.genie_space_id}
-            permission: CAN_RUN
-        - name: genie-space-sales
-          genie_space:
-            name: genie-space-sales
-            space_id: ${var.genie_space_sales_id}
-            permission: CAN_RUN
-        - name: genie-space-support
-          genie_space:
-            name: genie-space-support
-            space_id: ${var.genie_space_support_id}
-            permission: CAN_RUN
-
-targets:
-  default:
-    variables:
-      genie_space_id: <any-space-id>
-      genie_space_sales_id: <sales-space-id>
-      genie_space_support_id: <support-space-id>
-```
-
-Repeat the variable and resource block for every space you want in the UI.
-
-### 4. Inject a build version stamp
-
-`GenieChat` stores the active conversation ID in two places that can become stale across space switches or redeployments:
-
-- **URL**: stored as `?conversationId=<id>`, read on every mount to replay history. When the user switches spaces, the new `GenieChat` instance reads this param and tries to fetch the old conversation through the new space's alias, resulting in `NOT_FOUND`.
-- **localStorage**: `appkit:genie:*` keys for related state. After a redeployment, stored IDs may no longer exist in the Genie backend, resulting in `NOT_FOUND`.
-
-Stamping every build with a timestamp lets the page detect a new deployment and clean up before `GenieChat` mounts.
-
-In `client/vite.config.ts`, add a `define` block alongside your existing config:
-
-```typescript
-export default defineConfig({
-  // ... existing config ...
-  define: {
-    // Changes on every build so the page can detect a new deployment
-    // and clear stale conversation state before GenieChat mounts.
-    "import.meta.env.VITE_APP_VERSION": JSON.stringify(Date.now().toString()),
-  },
-});
-```
-
-### 5. Replace the Genie page
-
-Replace the contents of `client/src/pages/genie/GeniePage.tsx` with the multi-space version below.
-
-`clearConversationUrl` strips `?conversationId` from the URL before the alias state changes, so the newly mounted `GenieChat` instance always starts without a stale cross-space conversation reference.
-
-`initAlias` runs once at component mount. On build-version mismatch it wipes all `appkit:genie:*` localStorage keys and clears the URL param, then restores the user's last-selected alias before returning it as initial state.
-
-```tsx
-import { useState } from "react";
-import { GenieChat } from "@databricks/appkit-ui/react";
-import {
-  Select,
-  SelectContent,
-  SelectItem,
-  SelectTrigger,
-  SelectValue,
-} from "@databricks/appkit-ui/react";
-
-const SPACES = [
-  { alias: "sales", label: "Sales Analytics" },
-  { alias: "support", label: "Support Analytics" },
-];
-
-const VERSION_KEY = "appkit:genie:version";
-const ALIAS_KEY = "appkit:genie:alias";
-
-function clearConversationUrl() {
-  const url = new URL(window.location.href);
-  url.searchParams.delete("conversationId");
-  window.history.replaceState({}, "", url.toString());
-}
-
-function initAlias(): string {
-  const buildVersion = import.meta.env.VITE_APP_VERSION ?? "dev";
-
-  if (localStorage.getItem(VERSION_KEY) !== buildVersion) {
-    const savedAlias = localStorage.getItem(ALIAS_KEY);
-    Object.keys(localStorage)
-      .filter((k) => k.startsWith("appkit:genie:"))
-      .forEach((k) => localStorage.removeItem(k));
-    localStorage.setItem(VERSION_KEY, buildVersion);
-    if (savedAlias) localStorage.setItem(ALIAS_KEY, savedAlias);
-    clearConversationUrl();
-  }
-
-  return localStorage.getItem(ALIAS_KEY) ?? SPACES[0]?.alias ?? "";
-}
-
-export function GeniePage() {
-  const [selectedAlias, setSelectedAlias] = useState(initAlias);
-
-  return (
-    <div className="space-y-6 w-full max-w-4xl mx-auto">
-      <div className="flex items-center justify-between">
-        <div>
-          <h2 className="text-2xl font-bold text-foreground">Genie</h2>
-          <p className="text-sm text-muted-foreground mt-1">
-            Ask questions about your data using Databricks AI/BI Genie.
-          </p>
-        </div>
-        <Select
-          value={selectedAlias}
-          onValueChange={(alias) => {
-            clearConversationUrl();
-            setSelectedAlias(alias);
-            localStorage.setItem(ALIAS_KEY, alias);
-          }}
-        >
-          <SelectTrigger className="w-52">
-            <SelectValue placeholder="Select space" />
-          </SelectTrigger>
-          <SelectContent>
-            {SPACES.map((space) => (
-              <SelectItem key={space.alias} value={space.alias}>
-                {space.label}
-              </SelectItem>
-            ))}
-          </SelectContent>
-        </Select>
-      </div>
-      <div className="h-[600px] border rounded-lg overflow-hidden">
-        <GenieChat key={selectedAlias} alias={selectedAlias} />
-      </div>
-    </div>
-  );
-}
-```
-
-No changes are needed in `client/src/App.tsx` — the import, nav link, and route from the single-space setup carry over unchanged.
-
-### 6. Deploy and test
-
-From the app project directory (the folder containing `databricks.yml`):
-
-```bash
-# Build the client
-npm run build
-
-# Deploy bundle resources and sync files to workspace
-# Copy the upload path printed in the output — you'll need it below
-databricks bundle deploy
-
-# Put the app in RUNNING state and wait for compute to be ready
-# The loop polls every 5 seconds — press Ctrl+C if it hangs more than 2 minutes
-databricks apps start <app-name>
-until databricks apps get <app-name> -o json | grep -q '"ACTIVE"'; do sleep 5; done
-
-# First deploy requires --source-code-path: paste the path from bundle deploy output above
-databricks apps deploy <app-name> \
-  --source-code-path <path-from-bundle-deploy-output>
-```
-
-`bundle deploy` prints the workspace upload path (`Uploading bundle files to ...`) — copy that value for `--source-code-path`. `apps start` puts the app into RUNNING state; the `until` loop waits for compute to be ACTIVE. `apps deploy` deploys the source and starts the app server.
-
-For subsequent deploys, `--source-code-path` is not needed. Run both `bundle deploy` and `apps deploy` when changing `databricks.yml`; for client-only changes, `apps deploy` alone is sufficient after `npm run build`:
-
-```bash
-npm run build
-databricks bundle deploy
-databricks apps deploy <app-name>
-```
-
-Check app status and get the URL:
-
-```bash
-databricks apps get <app-name>
-```
-
-If compute is **STOPPED**, run `databricks apps start <app-name>` and wait for `compute_status.state: ACTIVE` before deploying.
-
-Open `<app-url>/genie` while signed in to Databricks and verify:
-
-1. The space selector shows all configured spaces
-2. Asking a question routes to the correct space
-3. Switching spaces resets the conversation with no `NOT_FOUND` error
-4. Reloading the page restores the last selected space and replays the conversation
-5. After redeploying, stale conversation IDs are automatically cleared on the next page load
-
-#### References
-
-- [Genie plugin docs](/docs/appkit/v0/plugins/genie)
-- [GenieChat component](/docs/appkit/v0/api/appkit-ui/genie/GenieChat)
-- [AI/BI Genie documentation](https://docs.databricks.com/en/genie/index.html)
diff --git a/content/recipes/genie-multi-space/goal.md b/content/recipes/genie-multi-space/goal.md
index f3efa3c..883a060 100644
--- a/content/recipes/genie-multi-space/goal.md
+++ b/content/recipes/genie-multi-space/goal.md
@@ -1,5 +1,3 @@
-Upgrade a single-space Genie app to let users switch between multiple AI/BI Genie spaces from a dropdown.
-
 When done, you will have:
 
 - Multiple Genie spaces accessible from a single app
diff --git a/content/recipes/genie-multi-space/prerequisites.md b/content/recipes/genie-multi-space/prerequisites.md
index b52ba0c..934b120 100644
--- a/content/recipes/genie-multi-space/prerequisites.md
+++ b/content/recipes/genie-multi-space/prerequisites.md
@@ -1,6 +1,5 @@
 This template upgrades an existing single-space Genie app to switch between multiple spaces. Verify these Databricks workspace features are enabled before starting. If any check fails, ask your workspace admin to enable the feature.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **AI/BI Genie enabled.** Run `databricks genie list-spaces --profile <PROFILE>` and confirm the command succeeds.
 - **Two or more Genie spaces configured.** The list above must return at least two spaces — one per entry you want in the selector. If you have fewer, create additional spaces in **AI/BI Genie** in the Databricks UI.
 - **Databricks Apps enabled.** Run `databricks apps list --profile <PROFILE>` and confirm the command succeeds.
diff --git a/content/recipes/lakebase-agent-memory/content.md b/content/recipes/lakebase-agent-memory/content.md
deleted file mode 100644
index 736aa43..0000000
--- a/content/recipes/lakebase-agent-memory/content.md
+++ /dev/null
@@ -1,132 +0,0 @@
-## Lakebase Agent Memory
-
-Save your AI agent's chat conversations to Lakebase so users can come back to a session, scroll their full message history, and let your agent reason over previous turns across requests, deploys, and machines.
-
-The schema is a simplified, production-shaped relational layout (`chat` plus `message`) wired to Databricks AppKit + Lakebase. Once it's in place every chat turn — user input, assistant reply, tool call — is durably persisted in managed Postgres next to the rest of your operational data.
-
-This template assumes you have already completed the [Create a Lakebase Instance](/templates/app-with-lakebase#create-a-lakebase-instance) and [Lakebase Data Persistence](/templates/app-with-lakebase#lakebase-data-persistence) templates (Lakebase project creation, scaffolding, environment variables, `databricks.yml` config, and initial deploy).
-
-### 1. Create chat tables
-
-Create two tables in a `chat` schema:
-
-- `chat.chats`: one row per chat session
-- `chat.messages`: one row per message
-
-```sql
-CREATE SCHEMA IF NOT EXISTS chat;
-
-CREATE TABLE IF NOT EXISTS chat.chats (
-  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-  user_id TEXT NOT NULL,
-  title TEXT NOT NULL,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-);
-
-CREATE TABLE IF NOT EXISTS chat.messages (
-  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-  chat_id UUID NOT NULL REFERENCES chat.chats(id) ON DELETE CASCADE,
-  role TEXT NOT NULL CHECK (role IN ('system', 'user', 'assistant', 'tool')),
-  content TEXT NOT NULL,
-  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-);
-
-CREATE INDEX IF NOT EXISTS idx_messages_chat_id_created_at
-  ON chat.messages(chat_id, created_at);
-```
-
-### 2. Run setup from your server bootstrap
-
-In `server/server.ts`, run schema setup inside `onPluginsReady` so it completes before AppKit starts the HTTP server:
-
-```typescript
-import { createApp, server, lakebase } from "@databricks/appkit";
-import { setupChatTables } from "./lib/chat-store";
-
-await createApp({
-  plugins: [server(), lakebase()],
-  async onPluginsReady(appkit) {
-    await setupChatTables(appkit);
-  },
-});
-```
-
-### 3. Add persistence helpers
-
-Create `server/lib/chat-store.ts` and use parameterized queries:
-
-> **Getting userId**: In deployed Databricks Apps, use `req.header("x-forwarded-email")` from the request headers. For local development, use a hardcoded test user ID.
-
-```typescript
-export async function createChat(
-  appkit: AppKitWithLakebase,
-  input: { userId: string; title: string },
-) {
-  const result = await appkit.lakebase.query(
-    `INSERT INTO chat.chats (user_id, title)
-     VALUES ($1, $2)
-     RETURNING id, user_id, title, created_at, updated_at`,
-    [input.userId, input.title],
-  );
-  return result.rows[0];
-}
-
-export async function appendMessage(
-  appkit: AppKitWithLakebase,
-  input: { chatId: string; role: string; content: string },
-) {
-  const result = await appkit.lakebase.query(
-    `INSERT INTO chat.messages (chat_id, role, content)
-     VALUES ($1, $2, $3)
-     RETURNING id, chat_id, role, content, created_at`,
-    [input.chatId, input.role, input.content],
-  );
-  return result.rows[0];
-}
-```
-
-### 4. Persist in the `/api/chat` flow
-
-In your chat route:
-
-1. create (or load) a chat row
-2. save incoming user message
-3. stream assistant response
-4. save the final assistant response after stream completion
-
-Use an explicit `chatId` on the client and pass it in each request body.
-
-### 5. Add history endpoints
-
-Add REST endpoints for your chat UI:
-
-- `GET /api/chats` -> list chats for current user
-- `GET /api/chats/:chatId/messages` -> load ordered history
-- `DELETE /api/chats/:chatId` -> delete chat and cascade messages
-
-### 6. Update the client to load and resume chats
-
-- Keep selected `chatId` in state or URL
-- Fetch history with `GET /api/chats/:chatId/messages` and call `setMessages()` from the `useChat` return value to load it into the chat (AI SDK v6 uses `messages` in `ChatInit`, not `initialMessages`)
-- Send `chatId` in every `/api/chat` request by passing it via a custom `fetch` wrapper on the `TextStreamChatTransport` constructor (there is no `onResponse` option on the transport; use the custom `fetch` to read response headers like `X-Chat-Id`)
-
-### 7. Verify persistence end-to-end
-
-```bash
-databricks apps deploy --profile <PROFILE>
-databricks apps logs <app-name> --profile <PROFILE>
-```
-
-Verification checklist:
-
-- send 2-3 messages
-- refresh the page
-- confirm prior messages reload from Lakebase
-- start a second chat and confirm separate history
-- delete a chat and confirm it no longer appears
-
-#### References
-
-- [Lakebase plugin docs](/docs/appkit/v0/plugins/lakebase)
-- [PostgreSQL schema design](https://www.postgresql.org/docs/current/ddl.html)
diff --git a/content/recipes/lakebase-agent-memory/goal.md b/content/recipes/lakebase-agent-memory/goal.md
index e4ab43f..2452da6 100644
--- a/content/recipes/lakebase-agent-memory/goal.md
+++ b/content/recipes/lakebase-agent-memory/goal.md
@@ -1,5 +1,3 @@
-Persist AI agent chat conversations to Lakebase so users can resume sessions, view full message history, and let the agent reason over previous turns across requests and deploys.
-
 When done, you will have:
 
 - A relational schema (chats and messages tables) in Lakebase for storing conversations
diff --git a/content/recipes/lakebase-agent-memory/prerequisites.md b/content/recipes/lakebase-agent-memory/prerequisites.md
index 0111a34..f032cd1 100644
--- a/content/recipes/lakebase-agent-memory/prerequisites.md
+++ b/content/recipes/lakebase-agent-memory/prerequisites.md
@@ -1,6 +1,5 @@
 Verify these Databricks workspace features are enabled before starting. If any check fails, ask your workspace admin to enable the feature.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **Lakebase Postgres available.** Run `databricks postgres list-projects --profile <PROFILE>` and confirm the command succeeds (an empty list is fine). A `not enabled` error means Lakebase is not available to this identity in this workspace.
 - **Databricks Apps enabled.** Run `databricks apps list --profile <PROFILE>` and confirm the command succeeds (an empty list is fine). The chat persistence layer runs inside an AppKit app deployed to Databricks Apps.
 - **A scaffolded AppKit app with Lakebase wired up.** Complete the [Create a Lakebase Instance](/templates/lakebase-create-instance) and [Lakebase Data Persistence](/templates/lakebase-data-persistence) templates first. This template adds chat tables on top of that setup.
diff --git a/content/recipes/lakebase-change-data-feed-autoscaling/content.md b/content/recipes/lakebase-change-data-feed-autoscaling/content.md
deleted file mode 100644
index 27c692d..0000000
--- a/content/recipes/lakebase-change-data-feed-autoscaling/content.md
+++ /dev/null
@@ -1,165 +0,0 @@
-## Replicate Lakebase Tables to Unity Catalog with Lakehouse Sync
-
-Replicate your Lakebase Autoscaling Postgres tables into Unity Catalog as managed Delta tables using Lakehouse Sync. CDC captures every row-level change and writes them as SCD Type 2 history, giving you a full audit trail queryable from the lakehouse.
-
-> This template is for **Lakebase Autoscaling** (projects/branches/endpoints with scale-to-zero).
-
-### When to use this
-
-- You want to analyze operational data (orders, user activity, support tickets) in the lakehouse
-- You need a historical record of every insert, update, and delete from your Postgres tables
-- You want to join operational data with analytics data in Spark, SQL, or BI tools
-- You need to feed Lakebase data into downstream pipelines or ML models
-
-### How it works
-
-> **Note:** Lakehouse Sync is currently in **Beta on AWS only** (all Autoscaling regions). Azure support is not yet available. It is a native Lakebase feature with no external compute, pipelines, or jobs required, and there is no incremental charge for replication beyond the underlying Lakebase compute and storage costs.
-
-Lakehouse Sync uses Change Data Capture (CDC) to stream changes from Lakebase Postgres into Unity Catalog. For each synced table, a Delta history table is created:
-
-```
-lb_<table_name>_history
-```
-
-Each row includes metadata columns:
-
-- `_change_type`: `insert`, `update_preimage`, `update_postimage`, or `delete`
-- `_lsn`: Log Sequence Number for ordering changes
-- `_commit_timestamp`: When the change was captured
-
-### 1. Verify table replica identity
-
-Lakehouse Sync requires the right replica identity for capturing changes. Connect to your Lakebase database and check:
-
-```sql
-SELECT n.nspname AS table_schema,
-       c.relname AS table_name,
-       CASE c.relreplident
-         WHEN 'd' THEN 'default'
-         WHEN 'n' THEN 'nothing'
-         WHEN 'f' THEN 'full'
-         WHEN 'i' THEN 'index'
-       END AS replica_identity
-FROM pg_class c
-JOIN pg_namespace n ON n.oid = c.relnamespace
-WHERE c.relkind = 'r'
-  AND n.nspname = 'public'
-ORDER BY n.nspname, c.relname;
-```
-
-If a table shows `default` or `nothing`, set it to `FULL`:
-
-```sql
-ALTER TABLE <table_name> REPLICA IDENTITY FULL;
-```
-
-### 2. Check for unsupported data types
-
-```sql
-SELECT c.table_schema, c.table_name, c.column_name, c.udt_name AS data_type
-FROM information_schema.columns c
-JOIN pg_catalog.pg_type t ON t.typname = c.udt_name
-WHERE c.table_schema = 'public'
-  AND c.table_name IN (
-    SELECT tablename FROM pg_tables WHERE schemaname = c.table_schema
-  )
-  AND NOT (
-    c.udt_name IN (
-      'bool', 'int2', 'int4', 'int8', 'text', 'varchar', 'bpchar',
-      'jsonb', 'numeric', 'date', 'timestamp', 'timestamptz',
-      'real', 'float4', 'float8'
-    )
-    OR t.typcategory = 'E'
-  )
-ORDER BY c.table_schema, c.table_name, c.ordinal_position;
-```
-
-If unsupported types appear, restructure those columns before enabling sync.
-
-### 3. Enable Lakehouse Sync
-
-> **Note:** This step is not yet available via CLI or REST API and must be completed through the Databricks UI:
->
-> In **Catalog**, open your Autoscaling project → branch → **Lakehouse Sync** → **Start Sync**, then select the source database/schema, destination catalog/schema, and tables.
-
-### 4. Monitor sync status
-
-Check active syncs from Postgres (the `wal2delta` schema only exists after Lakehouse Sync has been enabled in Step 3):
-
-```sql
-SELECT * FROM wal2delta.tables;
-```
-
-### 5. Query the history tables
-
-#### Latest state of each row
-
-```sql
-SELECT *
-FROM (
-  SELECT *,
-    ROW_NUMBER() OVER (PARTITION BY id ORDER BY _lsn DESC) AS rn
-  FROM <catalog>.<schema>.lb_<table_name>_history
-  WHERE _change_type IN ('insert', 'update_postimage', 'delete')
-)
-WHERE rn = 1
-  AND _change_type != 'delete';
-```
-
-#### Full change history for a record
-
-```sql
-SELECT *
-FROM <catalog>.<schema>.lb_<table_name>_history
-WHERE id = 12345
-ORDER BY _lsn;
-```
-
-### 6. Handle schema changes
-
-If you need to change a synced table's schema in Postgres, use the rename-and-swap pattern:
-
-```sql
-CREATE TABLE users_v2 (
-  id INT PRIMARY KEY,
-  name TEXT,
-  new_column TEXT
-);
-
-ALTER TABLE users_v2 REPLICA IDENTITY FULL;
-
-INSERT INTO users_v2 SELECT *, NULL FROM users;
-
-BEGIN;
-ALTER TABLE users RENAME TO users_backup;
-ALTER TABLE users_v2 RENAME TO users;
-COMMIT;
-```
-
-### What you end up with
-
-- **Delta history tables** in Unity Catalog (`lb_<table_name>_history`) with full SCD Type 2 change tracking
-- **Continuous replication.** Changes stream from Postgres to Delta automatically.
-- **No external compute.** Lakehouse Sync is a native Lakebase feature.
-- Operational data queryable in Spark SQL, notebooks, BI tools, and downstream pipelines
-
-### Troubleshooting
-
-| Issue                            | Fix                                                                |
-| -------------------------------- | ------------------------------------------------------------------ |
-| Table not appearing in sync      | Ensure it has a primary key or `REPLICA IDENTITY FULL`             |
-| Unsupported data type error      | Check column types with the query in Step 2                        |
-| Sync lag increasing              | Check Lakebase endpoint health and compute scaling                 |
-| Missing changes on update/delete | Verify `REPLICA IDENTITY FULL`. `default` only captures PK columns |
-
-### Limitations
-
-- **AWS only.** Lakehouse Sync Beta is available in all Autoscaling regions on AWS. Azure support is not yet available.
-- **No incremental charge.** Replication cost is included in your Lakebase compute and storage.
-- **Works alongside synced tables.** You can use Lakehouse Sync in a project/schema that also has synced tables.
-
-#### References
-
-- [Lakehouse Sync (Autoscaling)](https://docs.databricks.com/aws/en/oltp/projects/lakehouse-sync)
-- [Register Lakebase in Unity Catalog](https://docs.databricks.com/aws/en/oltp/projects/register-uc)
-- [SCD Type 2 in Databricks](https://docs.databricks.com/aws/en/ingestion/lakeflow-connect/scd)
diff --git a/content/recipes/lakebase-change-data-feed-autoscaling/goal.md b/content/recipes/lakebase-change-data-feed-autoscaling/goal.md
index 4163344..8ef4060 100644
--- a/content/recipes/lakebase-change-data-feed-autoscaling/goal.md
+++ b/content/recipes/lakebase-change-data-feed-autoscaling/goal.md
@@ -1,5 +1,3 @@
-Replicate Lakebase Autoscaling Postgres tables into Unity Catalog as managed Delta tables using Lakehouse Sync, capturing every row-level change as SCD Type 2 history.
-
 When done, you will have:
 
 - Delta history tables in Unity Catalog with full change tracking for every insert, update, and delete
diff --git a/content/recipes/lakebase-change-data-feed-autoscaling/prerequisites.md b/content/recipes/lakebase-change-data-feed-autoscaling/prerequisites.md
index 62c136e..446c0f9 100644
--- a/content/recipes/lakebase-change-data-feed-autoscaling/prerequisites.md
+++ b/content/recipes/lakebase-change-data-feed-autoscaling/prerequisites.md
@@ -1,6 +1,5 @@
 Verify these Databricks workspace features are enabled before starting. Lakehouse Sync is a Beta feature and has stricter workspace requirements than most other templates.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **AWS workspace in an Autoscaling region.** Lakehouse Sync is currently available in **Beta on AWS only**. Azure is not yet supported. Confirm your workspace host is `*.cloud.databricks.com` (AWS) rather than `*.azuredatabricks.net` (Azure).
 - **A Lakebase Autoscaling project with tables.** Run `databricks postgres list-projects --profile <PROFILE>` and confirm your Autoscaling project appears. A `not enabled` error means Lakebase is unavailable to this identity. This template does not cover project creation — see [Create a Lakebase Instance](/templates/lakebase-create-instance) if you need one.
 - **Unity Catalog access.** Run `databricks catalogs list --profile <PROFILE>` and confirm the destination catalog and schema you want to replicate into are present. You will select them when enabling Lakehouse Sync in Step 3.
diff --git a/content/recipes/lakebase-create-instance/content.md b/content/recipes/lakebase-create-instance/content.md
deleted file mode 100644
index 5246435..0000000
--- a/content/recipes/lakebase-create-instance/content.md
+++ /dev/null
@@ -1,45 +0,0 @@
-## Create a Lakebase Instance
-
-Provision a managed Lakebase Postgres project on Databricks and collect the connection values needed by downstream templates.
-
-### 1. Create a Lakebase project
-
-Create a new Lakebase Postgres project. This provisions a managed Postgres cluster with a default branch and endpoint:
-
-```bash
-databricks postgres create-project <project-name> --profile <PROFILE>
-```
-
-### 2. Verify the project resources
-
-Confirm the branch, endpoint, and database were created:
-
-```bash
-databricks postgres list-branches \
-  projects/<project-name> \
-  --profile <PROFILE> -o json
-
-databricks postgres list-endpoints \
-  projects/<project-name>/branches/production \
-  --profile <PROFILE> -o json
-
-databricks postgres list-databases \
-  projects/<project-name>/branches/production \
-  --profile <PROFILE> -o json
-```
-
-### 3. Note the connection values
-
-Record these values from the command output above. They are required by the Lakebase Data Persistence template and other Lakebase-dependent templates:
-
-| Value                    | JSON path                     | Used for                                              |
-| ------------------------ | ----------------------------- | ----------------------------------------------------- |
-| Endpoint host            | `...status.hosts.host`        | `PGHOST`, `lakebase.postgres.host`                    |
-| Endpoint resource path   | `...name`                     | `LAKEBASE_ENDPOINT`, `lakebase.postgres.endpointPath` |
-| Database resource path   | `...name`                     | `lakebase.postgres.database`                          |
-| PostgreSQL database name | `...status.postgres_database` | `PGDATABASE`, `lakebase.postgres.databaseName`        |
-
-#### References
-
-- [What is Lakebase?](/docs/lakebase/overview)
-- [CLI reference for Lakebase](https://docs.databricks.com/aws/en/oltp/projects/cli)
diff --git a/content/recipes/lakebase-create-instance/goal.md b/content/recipes/lakebase-create-instance/goal.md
index 23701be..7d8082e 100644
--- a/content/recipes/lakebase-create-instance/goal.md
+++ b/content/recipes/lakebase-create-instance/goal.md
@@ -1,5 +1,3 @@
-Provision a managed Lakebase Postgres project on Databricks and collect the connection values needed by downstream recipes.
-
 When done, you will have:
 
 - A managed Postgres cluster running in your Databricks workspace
diff --git a/content/recipes/lakebase-create-instance/prerequisites.md b/content/recipes/lakebase-create-instance/prerequisites.md
index 6d335c2..eb5ab31 100644
--- a/content/recipes/lakebase-create-instance/prerequisites.md
+++ b/content/recipes/lakebase-create-instance/prerequisites.md
@@ -1,4 +1,3 @@
 Verify these Databricks workspace features are enabled before starting. If any check fails, ask your workspace admin to enable the feature.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **Lakebase Postgres available in the workspace.** Run `databricks postgres list-projects --profile <PROFILE>` and confirm the command succeeds (an empty list is fine — you are about to create the first project). A `not enabled` or permission error means Lakebase is not available to this identity.
diff --git a/content/recipes/lakebase-data-persistence/content.md b/content/recipes/lakebase-data-persistence/content.md
deleted file mode 100644
index 4c06bdc..0000000
--- a/content/recipes/lakebase-data-persistence/content.md
+++ /dev/null
@@ -1,460 +0,0 @@
-## Lakebase Data Persistence
-
-Add a managed Postgres database to your Databricks app using the Lakebase plugin. Covers schema setup, table creation, and full CRUD REST API routes.
-
-This template assumes you have already completed the [Create a Lakebase Instance](/templates/app-with-lakebase#create-a-lakebase-instance) template and have the connection values (endpoint host, endpoint path, database resource path, and PostgreSQL database name) ready.
-
-The code examples below use a generic `items` resource as a placeholder. Replace `items` with your domain entity (products, orders, users, etc.) and adapt the schema columns to match your data model.
-
-### 1. New app: scaffold with the Lakebase feature
-
-```bash
-databricks apps init --name <app-name> --features lakebase \
-  --set "lakebase.postgres.branch=<BRANCH_NAME>" \
-  --set "lakebase.postgres.database=<DATABASE_NAME>" \
-  --run none --profile <PROFILE>
-```
-
-Where `<BRANCH_NAME>` is the full branch resource name (e.g. `projects/<PROJECT_ID>/branches/<BRANCH_ID>`) and `<DATABASE_NAME>` is the full database resource name (e.g. `projects/<PROJECT_ID>/branches/<BRANCH_ID>/databases/<DB_ID>`). Get these from:
-
-```bash
-databricks postgres list-branches projects/<PROJECT_ID> --profile <PROFILE>
-databricks postgres list-databases projects/<PROJECT_ID>/branches/<BRANCH_ID> --profile <PROFILE>
-```
-
-This scaffolds a complete app with Lakebase already wired up, including a sample CRUD app. Skip to step 3 to configure environment variables, then step 5 to deploy.
-
-### Naming and routing conventions
-
-The scaffolded Lakebase sample uses `lakebase` in route names and file paths to make plugin wiring obvious. For production apps, use domain names in user-facing code and keep `lakebase` only for infrastructure configuration:
-
-- page components and files use domain names: `ItemsPage.tsx`, `item-routes.ts`
-- routes use domain names: `/items`, `/api/items`, `/api/items/:id`
-- keep `lakebase` naming for plugin/config only: `lakebase()` plugin, `LAKEBASE_ENDPOINT`, `postgres` app resource
-
-### 2. Existing app: add Lakebase manually
-
-The following changes match what `apps init --features lakebase` generates. Apply them to an existing scaffolded AppKit app.
-
-> **Tip:** The code below may be outdated. To get the latest, clone `https://github.com/databricks/appkit` and look in the `template/` directory. Search for `{{if .plugins.lakebase}}` to find all lakebase-conditional files and blocks. Files entirely wrapped in that conditional are lakebase-only; shared files like `App.tsx` and `server.ts` contain conditional blocks you can extract.
-
-#### Update `server/server.ts`
-
-Register the `lakebase` plugin and run route setup inside `onPluginsReady`. AppKit waits for that hook to resolve before the server starts accepting requests, so your schema setup completes before the first call lands:
-
-```typescript
-import { createApp, server, lakebase } from "@databricks/appkit";
-import { setupRoutes } from "./routes/item-routes";
-
-await createApp({
-  plugins: [server(), lakebase()],
-  async onPluginsReady(appkit) {
-    await setupRoutes(appkit);
-  },
-});
-```
-
-#### Create `server/routes/item-routes.ts`
-
-CRUD API that creates an `items` table and exposes REST endpoints. Adapt the table schema and routes to your domain:
-
-```typescript
-import { z } from "zod";
-import { Application } from "express";
-
-interface AppKitWithLakebase {
-  lakebase: {
-    query(
-      text: string,
-      params?: unknown[],
-    ): Promise<{ rows: Record<string, unknown>[] }>;
-  };
-  server: {
-    extend(fn: (app: Application) => void): void;
-  };
-}
-
-const TABLE_EXISTS_SQL = `
-  SELECT 1 FROM information_schema.tables
-  WHERE table_schema = 'app' AND table_name = 'items'
-`;
-
-const SETUP_SCHEMA_SQL = `CREATE SCHEMA IF NOT EXISTS app`;
-
-const CREATE_TABLE_SQL = `
-  CREATE TABLE IF NOT EXISTS app.items (
-    id SERIAL PRIMARY KEY,
-    name TEXT NOT NULL,
-    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-  )
-`;
-
-const CreateItemBody = z.object({ name: z.string().min(1) });
-const UpdateItemBody = z.object({ name: z.string().min(1) });
-
-export async function setupRoutes(appkit: AppKitWithLakebase) {
-  try {
-    const { rows } = await appkit.lakebase.query(TABLE_EXISTS_SQL);
-    if (rows.length > 0) {
-      console.log("[lakebase] Table app.items already exists, skipping setup");
-    } else {
-      await appkit.lakebase.query(SETUP_SCHEMA_SQL);
-      await appkit.lakebase.query(CREATE_TABLE_SQL);
-      console.log("[lakebase] Created schema and table app.items");
-    }
-  } catch (err) {
-    console.warn("[lakebase] Database setup failed:", (err as Error).message);
-    console.warn("[lakebase] Routes will be registered but may return errors");
-  }
-
-  appkit.server.extend((app) => {
-    app.get("/api/items", async (_req, res) => {
-      try {
-        const result = await appkit.lakebase.query(
-          "SELECT id, name, created_at FROM app.items ORDER BY created_at DESC",
-        );
-        res.json(result.rows);
-      } catch (err) {
-        console.error("Failed to list items:", err);
-        res.status(500).json({ error: "Failed to list items" });
-      }
-    });
-
-    app.post("/api/items", async (req, res) => {
-      try {
-        const parsed = CreateItemBody.safeParse(req.body);
-        if (!parsed.success) {
-          res.status(400).json({ error: "name is required" });
-          return;
-        }
-        const result = await appkit.lakebase.query(
-          "INSERT INTO app.items (name) VALUES ($1) RETURNING id, name, created_at",
-          [parsed.data.name.trim()],
-        );
-        res.status(201).json(result.rows[0]);
-      } catch (err) {
-        console.error("Failed to create item:", err);
-        res.status(500).json({ error: "Failed to create item" });
-      }
-    });
-
-    app.patch("/api/items/:id", async (req, res) => {
-      try {
-        const id = parseInt(req.params.id, 10);
-        if (isNaN(id)) {
-          res.status(400).json({ error: "Invalid id" });
-          return;
-        }
-        const parsed = UpdateItemBody.safeParse(req.body);
-        if (!parsed.success) {
-          res.status(400).json({ error: "name is required" });
-          return;
-        }
-        const result = await appkit.lakebase.query(
-          "UPDATE app.items SET name = $1 WHERE id = $2 RETURNING id, name, created_at",
-          [parsed.data.name.trim(), id],
-        );
-        if (result.rows.length === 0) {
-          res.status(404).json({ error: "Item not found" });
-          return;
-        }
-        res.json(result.rows[0]);
-      } catch (err) {
-        console.error("Failed to update item:", err);
-        res.status(500).json({ error: "Failed to update item" });
-      }
-    });
-
-    app.delete("/api/items/:id", async (req, res) => {
-      try {
-        const id = parseInt(req.params.id, 10);
-        if (isNaN(id)) {
-          res.status(400).json({ error: "Invalid id" });
-          return;
-        }
-        const result = await appkit.lakebase.query(
-          "DELETE FROM app.items WHERE id = $1 RETURNING id",
-          [id],
-        );
-        if (result.rows.length === 0) {
-          res.status(404).json({ error: "Item not found" });
-          return;
-        }
-        res.status(204).send();
-      } catch (err) {
-        console.error("Failed to delete item:", err);
-        res.status(500).json({ error: "Failed to delete item" });
-      }
-    });
-  });
-}
-```
-
-:::warning[Deploy first to avoid schema ownership errors]
-Lakebase tables are owned by the identity that creates them. If you create the `app` schema locally, your user owns it and the deployed service principal gets `permission denied for schema app`.
-
-**Recommended workflow:** Deploy the app first so the service principal creates and owns the schema. Then grant yourself access for local development:
-
-```bash
-databricks psql --project <project-name> --branch production --endpoint primary --profile <PROFILE> -- -c "
-  CREATE EXTENSION IF NOT EXISTS databricks_auth;
-  SELECT databricks_create_role('<your-email>', 'USER');
-  GRANT databricks_superuser TO \"<your-email>\";
-"
-```
-
-If you are the Lakebase project owner, `databricks_create_role` may fail with `role already exists` and `GRANT databricks_superuser` may fail with `permission denied to grant role`. Both errors are safe to ignore; the project owner already has the necessary access.
-
-This gives you DML access (read/write) but not DDL (create/alter). The service principal remains the schema owner.
-
-If you already created tables locally, drop and recreate the schema so the service principal owns it, or add tables in a separate schema (the [Lakebase Agent Memory template](/templates/ai-chat-app#lakebase-agent-memory) uses a `chat` schema for this reason).
-:::
-
-#### Create `client/src/pages/ItemsPage.tsx`
-
-List and create UI with CRUD operations against the API routes. Adapt the fields and layout to your domain:
-
-```tsx
-import {
-  Card,
-  CardContent,
-  CardHeader,
-  CardTitle,
-  Button,
-  Input,
-  Skeleton,
-} from "@databricks/appkit-ui/react";
-import { useState, useEffect } from "react";
-import { X } from "lucide-react";
-
-interface Item {
-  id: number;
-  name: string;
-  created_at: string;
-}
-
-export function ItemsPage() {
-  const [items, setItems] = useState<Item[]>([]);
-  const [newName, setNewName] = useState("");
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
-  const [submitting, setSubmitting] = useState(false);
-
-  useEffect(() => {
-    fetch("/api/items")
-      .then((res) => {
-        if (!res.ok)
-          throw new Error(`Failed to fetch items: ${res.statusText}`);
-        return res.json() as Promise<Item[]>;
-      })
-      .then(setItems)
-      .catch((err) =>
-        setError(err instanceof Error ? err.message : "Failed to load items"),
-      )
-      .finally(() => setLoading(false));
-  }, []);
-
-  const addItem = async (e: React.FormEvent) => {
-    e.preventDefault();
-    const name = newName.trim();
-    if (!name) return;
-
-    setSubmitting(true);
-    try {
-      const res = await fetch("/api/items", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ name }),
-      });
-      if (!res.ok) throw new Error(`Failed to create item: ${res.statusText}`);
-      const created = (await res.json()) as Item;
-      setItems((prev) => [created, ...prev]);
-      setNewName("");
-    } catch (err) {
-      setError(err instanceof Error ? err.message : "Failed to add item");
-    } finally {
-      setSubmitting(false);
-    }
-  };
-
-  const deleteItem = async (id: number) => {
-    try {
-      const res = await fetch(`/api/items/${id}`, { method: "DELETE" });
-      if (!res.ok) throw new Error(`Failed to delete item: ${res.statusText}`);
-      setItems((prev) => prev.filter((item) => item.id !== id));
-    } catch (err) {
-      setError(err instanceof Error ? err.message : "Failed to delete item");
-    }
-  };
-
-  return (
-    <div className="space-y-6 w-full max-w-2xl mx-auto">
-      <Card className="shadow-lg">
-        <CardHeader>
-          <CardTitle>Items</CardTitle>
-        </CardHeader>
-        <CardContent>
-          <form onSubmit={addItem} className="flex gap-2 mb-6">
-            <Input
-              placeholder="New item name"
-              value={newName}
-              onChange={(e) => setNewName(e.target.value)}
-              disabled={submitting}
-              className="flex-1"
-            />
-            <Button type="submit" disabled={submitting || !newName.trim()}>
-              {submitting ? "Adding..." : "Add"}
-            </Button>
-          </form>
-
-          {error && (
-            <div className="text-destructive bg-destructive/10 p-3 rounded-md mb-4">
-              {error}
-            </div>
-          )}
-
-          {loading && (
-            <div className="space-y-3">
-              {Array.from({ length: 3 }, (_, i) => (
-                <div key={`skeleton-${i}`} className="flex items-center gap-3">
-                  <Skeleton className="h-4 flex-1" />
-                </div>
-              ))}
-            </div>
-          )}
-
-          {!loading && items.length === 0 && (
-            <p className="text-muted-foreground text-center py-8">
-              No items yet. Add one above to get started.
-            </p>
-          )}
-
-          {!loading && items.length > 0 && (
-            <div className="space-y-2">
-              {items.map((item) => (
-                <div
-                  key={item.id}
-                  className="flex items-center gap-3 p-3 rounded-lg border hover:bg-muted/50 transition-colors"
-                >
-                  <span className="flex-1">{item.name}</span>
-                  <Button
-                    variant="ghost"
-                    size="sm"
-                    onClick={() => deleteItem(item.id)}
-                    className="text-muted-foreground hover:text-destructive shrink-0"
-                    aria-label="Delete item"
-                  >
-                    <X className="h-4 w-4" />
-                  </Button>
-                </div>
-              ))}
-            </div>
-          )}
-        </CardContent>
-      </Card>
-    </div>
-  );
-}
-```
-
-#### Update `client/src/App.tsx`
-
-Add the import, nav link, and route:
-
-```tsx
-// Add import at top
-import { ItemsPage } from './pages/ItemsPage';
-
-// Add nav link inside the <nav> element
-<NavLink to="/items" className={navLinkClass}>
-  Items
-</NavLink>
-
-// Add route in the router children array
-{ path: '/items', element: <ItemsPage /> },
-```
-
-### 3. Configure environment variables
-
-For local development, add the Postgres connection details to `.env`:
-
-```bash
-PGHOST=<endpoint-host>
-PGPORT=5432
-PGDATABASE=<postgres-database-name>
-PGSSLMODE=require
-LAKEBASE_ENDPOINT=projects/<project-name>/branches/production/endpoints/primary
-```
-
-For deployment, the platform injects Postgres connection values automatically through the app resource. Keep only the Lakebase endpoint in `app.yaml`:
-
-```yaml
-command: ["npm", "run", "start"]
-env:
-  - name: LAKEBASE_ENDPOINT
-    valueFrom: postgres
-```
-
-### 4. Update `databricks.yml`
-
-Add the postgres variables, resource, and target values:
-
-```yaml
-variables:
-  postgres_branch:
-    description: Lakebase Postgres branch resource name
-  postgres_database:
-    description: Lakebase Postgres database resource name
-  postgres_databaseName:
-    description: Postgres database name for local development
-  postgres_endpointPath:
-    description: Lakebase endpoint resource name for local development
-  postgres_host:
-    description: Postgres host for local development
-  postgres_port:
-    description: Postgres port for local development
-  postgres_sslmode:
-    description: Postgres SSL mode for local development
-
-resources:
-  apps:
-    app:
-      # Add under existing app config
-      resources:
-        - name: postgres
-          postgres:
-            branch: ${var.postgres_branch}
-            database: ${var.postgres_database}
-            permission: CAN_CONNECT_AND_CREATE
-
-targets:
-  default:
-    variables:
-      postgres_branch: projects/<project-name>/branches/production
-      postgres_database: projects/<project-name>/branches/production/databases/<db-name>
-      postgres_databaseName: <postgres-database-name>
-      postgres_endpointPath: projects/<project-name>/branches/production/endpoints/primary
-      postgres_host: <endpoint-host>
-      postgres_port: 5432
-      postgres_sslmode: require
-```
-
-### 5. Deploy and test
-
-```bash
-databricks apps deploy --profile <PROFILE>
-```
-
-Verify the app once it is running by opening the app URL in your browser while signed in to Databricks, navigating to the Items page, and creating, updating, and deleting an item.
-
-If the app does not start, check logs:
-
-```bash
-databricks apps logs <app-name> --profile <PROFILE>
-```
-
-#### References
-
-- [Lakebase plugin docs](/docs/appkit/v0/plugins/lakebase)
-- [Lakebase database permissions](/docs/appkit/v0/plugins/lakebase#database-permissions)
-- [What is Lakebase?](/docs/lakebase/overview)
diff --git a/content/recipes/lakebase-data-persistence/goal.md b/content/recipes/lakebase-data-persistence/goal.md
index 42cfe94..ea6ae4b 100644
--- a/content/recipes/lakebase-data-persistence/goal.md
+++ b/content/recipes/lakebase-data-persistence/goal.md
@@ -1,5 +1,3 @@
-Add a managed Postgres database to your Databricks App using the Lakebase plugin, with schema setup, table creation, and full CRUD REST API routes.
-
 When done, you will have:
 
 - A Databricks App connected to a Lakebase Postgres database
diff --git a/content/recipes/lakebase-data-persistence/prerequisites.md b/content/recipes/lakebase-data-persistence/prerequisites.md
index 425ea0f..43c4f14 100644
--- a/content/recipes/lakebase-data-persistence/prerequisites.md
+++ b/content/recipes/lakebase-data-persistence/prerequisites.md
@@ -1,6 +1,5 @@
 Verify these Databricks workspace features are enabled before starting. If any check fails, ask your workspace admin to enable the feature.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **Lakebase Postgres available.** Run `databricks postgres list-projects --profile <PROFILE>` and confirm the command succeeds. A `not enabled` error means Lakebase is not available to this identity.
 - **Databricks Apps enabled.** Run `databricks apps list --profile <PROFILE>` and confirm the command succeeds (an empty list is fine). The template deploys an AppKit app to Databricks Apps.
 - **A provisioned Lakebase project.** Complete the [Create a Lakebase Instance](/templates/lakebase-create-instance) template first and collect the project's endpoint host, endpoint resource path, database resource path, and PostgreSQL database name.
diff --git a/content/recipes/lakebase-drizzle-off-platform/content.md b/content/recipes/lakebase-drizzle-off-platform/content.md
deleted file mode 100644
index 2729e25..0000000
--- a/content/recipes/lakebase-drizzle-off-platform/content.md
+++ /dev/null
@@ -1,141 +0,0 @@
-## Drizzle ORM with Lakebase in an Off-Platform App
-
-Connect Drizzle ORM to Lakebase in any Node.js server outside Databricks App Platform. Uses the `@databricks/lakebase` package for automatic OAuth token refresh.
-
-### 1. Install Drizzle and the Lakebase package
-
-```bash
-npm install drizzle-orm @databricks/lakebase
-npm install -D drizzle-kit tsx
-```
-
-`drizzle-orm` and `drizzle-kit` must be on the same major version. If `drizzle-kit` errors with "This version of drizzle-kit is outdated," check that both packages share the same major (e.g. both 0.x or both 1.x).
-
-### 2. Create a Lakebase-backed pool and Drizzle client
-
-Create `src/lib/db/client.ts`. `createLakebasePool()` reads env vars automatically (`PGHOST`, `PGDATABASE`, `LAKEBASE_ENDPOINT`, `PGUSER`, etc.) and handles OAuth token refresh with a 2-minute buffer:
-
-```typescript
-import { drizzle } from "drizzle-orm/node-postgres";
-import { createLakebasePool } from "@databricks/lakebase";
-import * as itemsSchema from "@/lib/items/schema";
-
-const pool = createLakebasePool();
-export const db = drizzle({ client: pool, schema: { ...itemsSchema } });
-```
-
-> `@databricks/lakebase` is for **Lakebase Autoscaling only** (not compatible with Provisioned). See the manual alternative at the end if you need Provisioned support.
-
-### 3. Define a Drizzle schema
-
-Create `src/lib/items/schema.ts` with a starter table. Adapt the table name, columns, and types to your domain (e.g. `products`, `orders`, `users`):
-
-```typescript
-import { pgTable, serial, text, timestamp } from "drizzle-orm/pg-core";
-
-export const items = pgTable("items", {
-  id: serial("id").primaryKey(),
-  name: text("name").notNull(),
-  createdAt: timestamp("created_at", { withTimezone: true })
-    .notNull()
-    .defaultNow(),
-});
-```
-
-Add more schema files under `src/lib/<domain>/schema.ts` as your app grows. The `drizzle.config.ts` glob (`./src/lib/*/schema.ts`) picks them all up automatically.
-
-### 4. Write the migration script
-
-Create `scripts/db-migrate.ts`. This uses the same `createLakebasePool()` with automatic credential handling — no need to build a temporary `DATABASE_URL`:
-
-```typescript
-import { drizzle } from "drizzle-orm/node-postgres";
-import { migrate } from "drizzle-orm/node-postgres/migrator";
-import { createLakebasePool } from "@databricks/lakebase";
-
-const pool = createLakebasePool();
-const db = drizzle({ client: pool });
-await migrate(db, { migrationsFolder: "./src/lib/db/migrations" });
-await pool.end();
-console.log("Migrations applied successfully");
-```
-
-### 5. Keep `drizzle.config.ts` minimal
-
-Commands like `generate` only read schema files and never connect, so no `dbCredentials` are needed:
-
-```typescript
-import { defineConfig } from "drizzle-kit";
-
-export default defineConfig({
-  schema: "./src/lib/*/schema.ts",
-  out: "./src/lib/db/migrations",
-  dialect: "postgresql",
-});
-```
-
-### 6. Verify schema generation and migration
-
-Generate reads schema files locally (no database connection):
-
-```bash
-npx drizzle-kit generate
-```
-
-Migrate fetches a fresh Lakebase credential and applies the generated SQL:
-
-```bash
-npx dotenv -e .env.local -- npx tsx scripts/db-migrate.ts
-```
-
-`tsx` does not load `.env.local` automatically (that is a Next.js-specific behavior), so use `dotenv-cli` or your framework's env-loading mechanism to inject the variables.
-
-If both commands succeed, your Drizzle schema and Lakebase connection are working.
-
-### Manual alternative (Provisioned or full control)
-
-If you cannot use `@databricks/lakebase` (e.g. Lakebase Provisioned, or you need full control over SSL and token refresh), build a manual `pg.Pool` with a password callback:
-
-```bash
-npm install drizzle-orm pg
-npm install -D drizzle-kit @types/pg tsx
-```
-
-```typescript
-import { Pool, type PoolConfig } from "pg";
-import { env } from "@/lib/env";
-import { getLakebasePostgresToken } from "@/lib/lakebase/tokens";
-
-function sslConfig(mode: "require" | "prefer" | "disable"): PoolConfig["ssl"] {
-  switch (mode) {
-    case "require":
-      return { rejectUnauthorized: true };
-    case "prefer":
-      return { rejectUnauthorized: false };
-    case "disable":
-      return false;
-  }
-}
-
-export function createLakebasePool(): Pool {
-  return new Pool({
-    host: env.PGHOST,
-    port: env.PGPORT,
-    database: env.PGDATABASE,
-    user: env.PGUSER,
-    password: () => getLakebasePostgresToken(),
-    ssl: sslConfig(env.PGSSLMODE),
-    max: 10,
-    idleTimeoutMillis: 30_000,
-    connectionTimeoutMillis: 10_000,
-  });
-}
-```
-
-For the migration script with this approach, build a temporary `DATABASE_URL` with a fresh credential and pass it to `drizzle-kit migrate` via `execSync`.
-
-#### References
-
-- [Drizzle ORM with PostgreSQL](https://orm.drizzle.team/docs/get-started-postgresql)
-- [`@databricks/lakebase` README](https://github.com/databricks/appkit/tree/main/packages/lakebase)
-- [Lakebase credentials API](https://docs.databricks.com/api/workspace/postgres/credentials)
diff --git a/content/recipes/lakebase-drizzle-off-platform/goal.md b/content/recipes/lakebase-drizzle-off-platform/goal.md
index 97c6ef0..8a52c70 100644
--- a/content/recipes/lakebase-drizzle-off-platform/goal.md
+++ b/content/recipes/lakebase-drizzle-off-platform/goal.md
@@ -1,5 +1,3 @@
-Connect Drizzle ORM to Lakebase in any Node.js server outside Databricks App Platform, with automatic credential refresh and migration support.
-
 When done, you will have:
 
 - A Lakebase-backed connection pool with automatic token refresh via password callback
diff --git a/content/recipes/lakebase-drizzle-off-platform/prerequisites.md b/content/recipes/lakebase-drizzle-off-platform/prerequisites.md
index 030cb98..c129114 100644
--- a/content/recipes/lakebase-drizzle-off-platform/prerequisites.md
+++ b/content/recipes/lakebase-drizzle-off-platform/prerequisites.md
@@ -1,6 +1,5 @@
 This template connects an off-platform Node.js app (e.g. AWS, Vercel, Netlify) to Lakebase Postgres. Verify these Databricks workspace features are enabled before starting.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **Lakebase Postgres available.** Run `databricks postgres list-projects --profile <PROFILE>` and confirm the command succeeds. A `not enabled` error means Lakebase is not available to this identity.
 - **A provisioned Lakebase project.** Complete the [Create a Lakebase Instance](/templates/lakebase-create-instance) template first so you have an endpoint host, database, and endpoint resource path available as `PGHOST`, `PGDATABASE`, and `LAKEBASE_ENDPOINT`.
 - **An env management setup for off-platform auth.** Complete the [Lakebase Env Management for Off-Platform Apps](/templates/lakebase-off-platform-env-management) and [Lakebase Token Management](/templates/lakebase-token-management) templates first — this template imports `env` and `getLakebasePostgresToken` from those modules.
diff --git a/content/recipes/lakebase-off-platform-env-management/content.md b/content/recipes/lakebase-off-platform-env-management/content.md
deleted file mode 100644
index 32632b8..0000000
--- a/content/recipes/lakebase-off-platform-env-management/content.md
+++ /dev/null
@@ -1,127 +0,0 @@
-## Lakebase Environment Management for Off-Platform Apps
-
-Define and validate the environment variables needed to connect to Lakebase from apps deployed outside Databricks App Platform (for example on AWS, Vercel, or Netlify).
-
-### 1. Collect connection values via the Databricks CLI
-
-Every value below can be obtained from the CLI. Run each command and record the result.
-
-**Workspace host** (`DATABRICKS_HOST`):
-
-```bash
-databricks auth profiles
-```
-
-Use the `Host` column for your profile (e.g. `https://dbc-xxxxx.cloud.databricks.com`).
-
-**Lakebase endpoint and Postgres host** (`LAKEBASE_ENDPOINT`, `PGHOST`):
-
-```bash
-databricks postgres list-endpoints \
-  projects/<project-name>/branches/production \
-  --profile <PROFILE> -o json
-```
-
-- `LAKEBASE_ENDPOINT` = the `name` field (e.g. `projects/<project>/branches/production/endpoints/primary`)
-- `PGHOST` = the `status.hosts.host` field
-
-**Postgres database name** (`PGDATABASE`):
-
-```bash
-databricks postgres list-databases \
-  projects/<project-name>/branches/production \
-  --profile <PROFILE> -o json
-```
-
-Use the `status.postgres_database` field (typically `databricks_postgres`).
-
-**Postgres user** (`PGUSER`):
-
-For local development with token auth, this is your Databricks email:
-
-```bash
-databricks current-user me --profile <PROFILE> -o json
-```
-
-Use the `userName` field.
-
-For production with M2M auth, this is the service principal's application ID used for `DATABRICKS_CLIENT_ID`.
-
-**Auth credentials:**
-
-For local development, get a short-lived workspace token:
-
-```bash
-databricks auth token --profile <PROFILE> -o json
-```
-
-Use the `access_token` field for `DATABRICKS_TOKEN`. This token expires after about one hour; the [Token Management](/templates/lakebase-off-platform#lakebase-token-management) template covers automated refresh.
-
-For production, use OAuth M2M credentials (`DATABRICKS_CLIENT_ID` + `DATABRICKS_CLIENT_SECRET`) from a service principal configured in your workspace.
-
-### 2. Validate env at startup with Zod
-
-Create `src/lib/env.ts`. Parsing `process.env` through a Zod schema on import ensures the app fails fast with a clear error when a variable is missing:
-
-```typescript
-import { z } from "zod";
-
-const baseSchema = z.object({
-  DATABRICKS_HOST: z.string().min(1),
-  LAKEBASE_ENDPOINT: z.string().min(1),
-  PGHOST: z.string().min(1),
-  PGPORT: z.coerce.number().default(5432),
-  PGDATABASE: z.string().min(1),
-  PGUSER: z.string().min(1),
-  PGSSLMODE: z.enum(["require", "prefer", "disable"]).default("require"),
-  DATABRICKS_TOKEN: z.string().optional(),
-  DATABRICKS_CLIENT_ID: z.string().optional(),
-  DATABRICKS_CLIENT_SECRET: z.string().optional(),
-});
-
-type AppEnv = z.infer<typeof baseSchema>;
-
-function validateAuth(env: AppEnv): AppEnv {
-  const hasToken = Boolean(env.DATABRICKS_TOKEN);
-  const hasM2M =
-    Boolean(env.DATABRICKS_CLIENT_ID) && Boolean(env.DATABRICKS_CLIENT_SECRET);
-  if (!hasToken && !hasM2M) {
-    throw new Error(
-      "Set DATABRICKS_TOKEN or both DATABRICKS_CLIENT_ID and DATABRICKS_CLIENT_SECRET",
-    );
-  }
-  return env;
-}
-
-export const env = validateAuth(baseSchema.parse(process.env));
-```
-
-### 3. Commit an `.env.example`
-
-Commit this file so every developer (and CI) knows which variables are required. Set the same keys in your hosting platform's secret/env configuration:
-
-```bash
-DATABRICKS_HOST=https://<workspace-host>
-LAKEBASE_ENDPOINT=projects/<project>/branches/production/endpoints/primary
-PGHOST=<status.hosts.host from list-endpoints>
-PGPORT=5432
-PGDATABASE=<status.postgres_database from list-databases>
-PGUSER=<your Databricks email or service principal application ID>
-PGSSLMODE=require
-
-# Option A: local dev, token auth (expires ~1h, use refresh script)
-DATABRICKS_TOKEN=
-
-# Option B: production, M2M auth (service principal)
-DATABRICKS_CLIENT_ID=
-DATABRICKS_CLIENT_SECRET=
-```
-
-### 4. Import `env` early in your server entry point
-
-Import `env` at the top of your server bootstrap file. The Zod parse runs on import, so any missing or invalid variable throws before the app starts accepting requests.
-
-#### References
-
-- [Databricks OAuth machine-to-machine auth](https://docs.databricks.com/en/dev-tools/auth/oauth-m2m.html)
-- [Lakebase credentials API](https://docs.databricks.com/api/workspace/postgres/credentials)
diff --git a/content/recipes/lakebase-off-platform-env-management/goal.md b/content/recipes/lakebase-off-platform-env-management/goal.md
index a88f62c..cadec9e 100644
--- a/content/recipes/lakebase-off-platform-env-management/goal.md
+++ b/content/recipes/lakebase-off-platform-env-management/goal.md
@@ -1,5 +1,3 @@
-Define and validate the environment variables needed to connect to Lakebase from apps deployed outside Databricks App Platform.
-
 When done, you will have:
 
 - All Lakebase connection values collected from the Databricks CLI
diff --git a/content/recipes/lakebase-off-platform-env-management/prerequisites.md b/content/recipes/lakebase-off-platform-env-management/prerequisites.md
index fdef47b..a70b710 100644
--- a/content/recipes/lakebase-off-platform-env-management/prerequisites.md
+++ b/content/recipes/lakebase-off-platform-env-management/prerequisites.md
@@ -1,6 +1,5 @@
 This template collects the environment variables needed to reach Lakebase from an app running outside Databricks App Platform. Verify these Databricks workspace features are enabled before starting.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **Lakebase Postgres available.** Run `databricks postgres list-projects --profile <PROFILE>` and confirm the command succeeds. A `not enabled` error means Lakebase is not available to this identity.
 - **A provisioned Lakebase project.** Complete the [Create a Lakebase Instance](/templates/lakebase-create-instance) template first. You will read connection values from its branch, endpoint, and database.
 - **Machine-to-machine OAuth for production (optional).** If you plan to run in production with a service principal, have `DATABRICKS_CLIENT_ID` / `DATABRICKS_CLIENT_SECRET` ready for that service principal. For local development, a workspace token from `databricks auth token --profile <PROFILE>` is sufficient.
diff --git a/content/recipes/lakebase-pgvector/content.md b/content/recipes/lakebase-pgvector/content.md
deleted file mode 100644
index 0adf360..0000000
--- a/content/recipes/lakebase-pgvector/content.md
+++ /dev/null
@@ -1,137 +0,0 @@
-## Vector Search with Lakebase and pgvector
-
-Enable vector similarity search in Lakebase using the pgvector extension.
-
-This template assumes you have already completed the [Create a Lakebase Instance](/templates/lakebase-create-instance) template and have a Lakebase project provisioned.
-
-### 1. Enable pgvector
-
-```bash
-databricks psql --project <project-name> --profile <PROFILE> -- -c "
-  CREATE EXTENSION IF NOT EXISTS vector;
-"
-```
-
-### 2. Create embedding table
-
-```sql
-CREATE SCHEMA IF NOT EXISTS vectors;
-
-CREATE TABLE IF NOT EXISTS vectors.documents (
-  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-  content TEXT NOT NULL,
-  embedding VECTOR(1024),
-  metadata JSONB NOT NULL DEFAULT '{}',
-  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-);
-```
-
-> **Vector dimensions**: `VECTOR(1024)` must match your embedding model's output dimension. `databricks-gte-large-en` and `databricks-bge-large-en` both produce 1024 dimensions. If you use a different model (for example, a 768- or 1536-dimension model), change `VECTOR(1024)` to match.
-
-### 3. Server-side vector store module
-
-Create `server/lib/vector-store.ts` with table setup, insert, and similarity search. Call `setupVectorTables(appkit)` from `server.ts` before starting the server.
-
-`server/lib/vector-store.ts`:
-
-```typescript
-import type { Application } from "express";
-
-interface AppKitWithLakebase {
-  lakebase: {
-    query(
-      text: string,
-      params?: unknown[],
-    ): Promise<{ rows: Record<string, unknown>[] }>;
-  };
-  server: {
-    extend(fn: (app: Application) => void): void;
-  };
-}
-
-export async function setupVectorTables(appkit: AppKitWithLakebase) {
-  try {
-    await appkit.lakebase.query("CREATE EXTENSION IF NOT EXISTS vector");
-  } catch (err: unknown) {
-    const code = (err as { code?: string }).code;
-    if (code === "42501") {
-      console.log(
-        "[vectors] Skipping extension creation — insufficient privileges (likely already exists)",
-      );
-    } else {
-      throw err;
-    }
-  }
-  const { rows } = await appkit.lakebase.query(
-    `SELECT 1 FROM information_schema.tables
-     WHERE table_schema = 'vectors' AND table_name = 'documents'`,
-  );
-  if (rows.length > 0) return;
-  await appkit.lakebase.query(`CREATE SCHEMA IF NOT EXISTS vectors`);
-  await appkit.lakebase.query(`
-    CREATE TABLE IF NOT EXISTS vectors.documents (
-      id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-      content TEXT NOT NULL,
-      embedding VECTOR(1024),
-      metadata JSONB NOT NULL DEFAULT '{}',
-      created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-    )
-  `);
-}
-
-export async function insertDocument(
-  appkit: AppKitWithLakebase,
-  input: {
-    content: string;
-    embedding: number[];
-    metadata?: Record<string, unknown>;
-  },
-) {
-  const result = await appkit.lakebase.query(
-    `INSERT INTO vectors.documents (content, embedding, metadata)
-     VALUES ($1, $2::vector, $3)
-     RETURNING id, content, metadata, created_at`,
-    [
-      input.content,
-      JSON.stringify(input.embedding),
-      JSON.stringify(input.metadata ?? {}),
-    ],
-  );
-  return result.rows[0];
-}
-
-export async function retrieveSimilar(
-  appkit: AppKitWithLakebase,
-  queryEmbedding: number[],
-  limit = 5,
-) {
-  const result = await appkit.lakebase.query(
-    `SELECT id, content, metadata, 1 - (embedding <=> $1::vector) AS similarity
-     FROM vectors.documents
-     WHERE embedding IS NOT NULL
-     ORDER BY embedding <=> $1::vector
-     LIMIT $2`,
-    [JSON.stringify(queryEmbedding), limit],
-  );
-  return result.rows;
-}
-```
-
-> **Distance operators**: `<=>` cosine (default for text), `<->` L2, `<#>` inner product.
-
-### 4. Create an index
-
-Add after inserting initial data (IVFFlat needs representative data to build):
-
-```sql
-CREATE INDEX IF NOT EXISTS idx_documents_embedding
-  ON vectors.documents USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
-ANALYZE vectors.documents;
-```
-
-> For higher recall without tuning, use `USING hnsw (embedding vector_cosine_ops)` instead.
-
-#### References
-
-- [pgvector](https://github.com/pgvector/pgvector)
-- [Lakebase extensions](https://docs.databricks.com/aws/en/oltp/projects/extensions)
diff --git a/content/recipes/lakebase-pgvector/goal.md b/content/recipes/lakebase-pgvector/goal.md
index 13f7507..fc1c7b4 100644
--- a/content/recipes/lakebase-pgvector/goal.md
+++ b/content/recipes/lakebase-pgvector/goal.md
@@ -1,5 +1,3 @@
-Enable vector similarity search in your Lakebase Postgres database using the pgvector extension, with a server-side module for storing and querying embeddings.
-
 When done, you will have:
 
 - The pgvector extension enabled on your Lakebase instance
diff --git a/content/recipes/lakebase-pgvector/prerequisites.md b/content/recipes/lakebase-pgvector/prerequisites.md
index 335983d..5acbe1a 100644
--- a/content/recipes/lakebase-pgvector/prerequisites.md
+++ b/content/recipes/lakebase-pgvector/prerequisites.md
@@ -1,6 +1,5 @@
 Verify these Databricks workspace features are enabled before starting. If any check fails, ask your workspace admin to enable the feature.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **Lakebase Postgres available.** Run `databricks postgres list-projects --profile <PROFILE>` and confirm the command succeeds. A `not enabled` error means Lakebase is not available to this identity.
 - **A provisioned Lakebase project.** Complete the [Create a Lakebase Instance](/templates/lakebase-create-instance) template first. You will enable the `vector` extension against its primary endpoint.
 - **`databricks psql` available in your CLI.** Run `databricks psql --help` and confirm the subcommand exists. If it does not, upgrade the Databricks CLI (see [Set Up Your Local Dev Environment](/templates/set-up-your-local-dev-environment)).
diff --git a/content/recipes/lakebase-token-management/content.md b/content/recipes/lakebase-token-management/content.md
deleted file mode 100644
index 424e740..0000000
--- a/content/recipes/lakebase-token-management/content.md
+++ /dev/null
@@ -1,205 +0,0 @@
-## Lakebase Token Management
-
-Fetch, cache, and automatically refresh the short-lived Postgres credentials that Lakebase requires. Supports both direct token auth (local dev) and M2M OAuth (production).
-
-### 1. Add a token manager for workspace auth and Lakebase credentials
-
-Create `src/lib/lakebase/tokens.ts`:
-
-```typescript
-import { env } from "@/lib/env";
-
-const REFRESH_BUFFER_MS = 2 * 60 * 1000;
-
-type CachedToken = {
-  value: string;
-  expiresAt: number;
-};
-
-type AuthStrategy =
-  | { kind: "token"; token: string }
-  | { kind: "m2m"; host: string; clientId: string; clientSecret: string };
-
-let cachedWorkspaceToken: CachedToken | null = null;
-let workspaceRefreshPromise: Promise<CachedToken> | null = null;
-let cachedLakebaseToken: CachedToken | null = null;
-let lakebaseRefreshPromise: Promise<CachedToken> | null = null;
-
-function isFresh(token: CachedToken | null): token is CachedToken {
-  return token !== null && Date.now() < token.expiresAt - REFRESH_BUFFER_MS;
-}
-
-function authStrategyFromEnv(): AuthStrategy {
-  if (env.DATABRICKS_TOKEN) {
-    return { kind: "token", token: env.DATABRICKS_TOKEN };
-  }
-  return {
-    kind: "m2m",
-    host: env.DATABRICKS_HOST.replace(/\/$/, ""),
-    clientId: env.DATABRICKS_CLIENT_ID!,
-    clientSecret: env.DATABRICKS_CLIENT_SECRET!,
-  };
-}
-
-async function fetchWorkspaceTokenM2M(
-  host: string,
-  clientId: string,
-  clientSecret: string,
-): Promise<CachedToken> {
-  const response = await fetch(`${host}/oidc/v1/token`, {
-    method: "POST",
-    headers: { "Content-Type": "application/x-www-form-urlencoded" },
-    body: new URLSearchParams({
-      grant_type: "client_credentials",
-      client_id: clientId,
-      client_secret: clientSecret,
-      scope: "all-apis",
-    }),
-  });
-  if (!response.ok) {
-    throw new Error(`M2M token request failed: ${response.status}`);
-  }
-  const data = (await response.json()) as {
-    access_token?: string;
-    expires_in?: number;
-  };
-  if (!data.access_token || !data.expires_in) {
-    throw new Error("Invalid M2M token response");
-  }
-  return {
-    value: data.access_token,
-    expiresAt: Date.now() + data.expires_in * 1000,
-  };
-}
-
-async function getWorkspaceToken(auth: AuthStrategy): Promise<string> {
-  if (auth.kind === "token") {
-    return auth.token;
-  }
-  if (isFresh(cachedWorkspaceToken)) {
-    return cachedWorkspaceToken.value;
-  }
-  if (!workspaceRefreshPromise) {
-    workspaceRefreshPromise = fetchWorkspaceTokenM2M(
-      auth.host,
-      auth.clientId,
-      auth.clientSecret,
-    )
-      .then((token) => {
-        cachedWorkspaceToken = token;
-        return token;
-      })
-      .finally(() => {
-        workspaceRefreshPromise = null;
-      });
-  }
-  return (await workspaceRefreshPromise).value;
-}
-
-async function fetchLakebaseCredential(
-  databricksHost: string,
-  workspaceToken: string,
-): Promise<CachedToken> {
-  const response = await fetch(
-    `${databricksHost}/api/2.0/postgres/credentials`,
-    {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${workspaceToken}`,
-        "Content-Type": "application/json",
-        Accept: "application/json",
-      },
-      body: JSON.stringify({ endpoint: env.LAKEBASE_ENDPOINT }),
-    },
-  );
-  if (!response.ok) {
-    throw new Error(`Lakebase credential request failed: ${response.status}`);
-  }
-  const data = (await response.json()) as {
-    token?: string;
-    expire_time?: string;
-  };
-  if (!data.token || !data.expire_time) {
-    throw new Error("Invalid Lakebase credential response");
-  }
-  return {
-    value: data.token,
-    expiresAt: new Date(data.expire_time).getTime(),
-  };
-}
-
-export async function getLakebasePostgresToken(): Promise<string> {
-  if (isFresh(cachedLakebaseToken)) {
-    return cachedLakebaseToken.value;
-  }
-  if (!lakebaseRefreshPromise) {
-    lakebaseRefreshPromise = (async () => {
-      const auth = authStrategyFromEnv();
-      const workspaceToken = await getWorkspaceToken(auth);
-      return fetchLakebaseCredential(
-        env.DATABRICKS_HOST.replace(/\/$/, ""),
-        workspaceToken,
-      );
-    })()
-      .then((token) => {
-        cachedLakebaseToken = token;
-        return token;
-      })
-      .finally(() => {
-        lakebaseRefreshPromise = null;
-      });
-  }
-  return (await lakebaseRefreshPromise).value;
-}
-```
-
-### 2. Add a script to refresh `DATABRICKS_TOKEN` for local dev
-
-CLI-issued tokens expire after about one hour. Create `scripts/refresh-lakebase-token.ts` to write a fresh token into your local env file:
-
-```typescript
-import { execSync } from "node:child_process";
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
-
-const envFile = process.argv[2] ?? ".env.local";
-const profile = process.env.DATABRICKS_CONFIG_PROFILE ?? "DEFAULT";
-
-const raw = execSync(`databricks auth token --profile "${profile}" -o json`, {
-  encoding: "utf-8",
-});
-const parsed = JSON.parse(raw) as { access_token?: string };
-if (!parsed.access_token) {
-  throw new Error("Failed to get access token from Databricks CLI");
-}
-
-if (!existsSync(envFile)) {
-  throw new Error(`Env file not found: ${envFile}`);
-}
-
-const content = readFileSync(envFile, "utf-8");
-const tokenLine = `DATABRICKS_TOKEN="${parsed.access_token}"`;
-const updated = content.includes("DATABRICKS_TOKEN=")
-  ? content.replace(/^DATABRICKS_TOKEN=.*/m, tokenLine)
-  : `${content.trimEnd()}\n${tokenLine}\n`;
-
-writeFileSync(envFile, updated);
-console.log(`Updated DATABRICKS_TOKEN in ${envFile}`);
-```
-
-### 3. Verify token and credential flow
-
-```bash
-databricks auth token --profile <PROFILE> -o json
-
-curl -sS -X POST "https://<workspace-host>/api/2.0/postgres/credentials" \
-  -H "Authorization: Bearer <workspace-access-token>" \
-  -H "Content-Type: application/json" \
-  -d '{"endpoint":"projects/<project>/branches/<branch>/endpoints/<endpoint>"}'
-```
-
-The response should include `token` and `expire_time`.
-
-#### References
-
-- [Databricks CLI auth token command](https://docs.databricks.com/aws/en/dev-tools/cli/reference/auth-commands)
-- [Lakebase credentials API](https://docs.databricks.com/api/workspace/postgres/credentials)
diff --git a/content/recipes/lakebase-token-management/goal.md b/content/recipes/lakebase-token-management/goal.md
index c58a646..0fd1eda 100644
--- a/content/recipes/lakebase-token-management/goal.md
+++ b/content/recipes/lakebase-token-management/goal.md
@@ -1,5 +1,3 @@
-Fetch, cache, and automatically refresh the short-lived Postgres credentials that Lakebase requires, supporting both token auth and M2M OAuth.
-
 When done, you will have:
 
 - A token manager that fetches and caches Lakebase Postgres credentials with automatic refresh before expiry
diff --git a/content/recipes/lakebase-token-management/prerequisites.md b/content/recipes/lakebase-token-management/prerequisites.md
index f19e225..c39e507 100644
--- a/content/recipes/lakebase-token-management/prerequisites.md
+++ b/content/recipes/lakebase-token-management/prerequisites.md
@@ -1,6 +1,5 @@
 This template fetches and caches Lakebase Postgres credentials from a Node.js process. Verify these Databricks workspace features are enabled before starting.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **Lakebase Postgres available.** Run `databricks postgres list-projects --profile <PROFILE>` and confirm the command succeeds. A `not enabled` error means Lakebase is not available to this identity.
 - **A provisioned Lakebase project.** Complete the [Create a Lakebase Instance](/templates/lakebase-create-instance) template first so you have a `LAKEBASE_ENDPOINT` resource path to pass to the credentials API.
 - **An env management setup.** Complete the [Lakebase Env Management for Off-Platform Apps](/templates/lakebase-off-platform-env-management) template first — this template imports the validated `env` module and expects `DATABRICKS_HOST`, `LAKEBASE_ENDPOINT`, and either `DATABRICKS_TOKEN` or `DATABRICKS_CLIENT_ID` + `DATABRICKS_CLIENT_SECRET` to be set.
diff --git a/content/recipes/medallion-architecture-from-cdc/content.md b/content/recipes/medallion-architecture-from-cdc/content.md
deleted file mode 100644
index 9753e8e..0000000
--- a/content/recipes/medallion-architecture-from-cdc/content.md
+++ /dev/null
@@ -1,205 +0,0 @@
-## Medallion Architecture from CDC History Tables
-
-Transform CDC history tables produced by Lakehouse Sync into a medallion architecture with bronze, silver, and gold layers using Lakeflow Declarative Pipelines. This turns raw change-data-capture records into clean, business-ready analytics tables in Unity Catalog.
-
-### When to use this
-
-- You have Lakehouse Sync CDC history tables (`lb_<table>_history`) in Unity Catalog from a Lakebase operational database
-- You want to build a layered data architecture (bronze → silver → gold) on top of operational data
-- You need clean current-state views, deduplication, and business aggregations for BI, ML, or Genie analytics
-- You want automated, incremental pipeline refreshes instead of manual SQL queries
-
-### How the layers map to CDC data
-
-| Layer      | Purpose                                                | Source                                     | Output                                                |
-| ---------- | ------------------------------------------------------ | ------------------------------------------ | ----------------------------------------------------- |
-| **Bronze** | Raw CDC records with full history                      | Lakehouse Sync `lb_<table>_history` tables | No transformation needed; these tables already exist  |
-| **Silver** | Current state of each record, deduplicated and cleaned | Bronze history tables                      | One streaming table per entity with latest state only |
-| **Gold**   | Business aggregations and domain-specific metrics      | Silver tables                              | Materialized views with aggregations, joins, and KPIs |
-
-### 1. Scaffold a pipeline project
-
-Use the Databricks CLI to scaffold a Lakeflow Declarative Pipelines project:
-
-```bash
-databricks bundle init lakeflow-pipelines \
-  --config-file <(echo '{"project_name": "operational_analytics", "language": "sql", "serverless": "yes"}') \
-  --profile <PROFILE> < /dev/null
-```
-
-Enter the project directory:
-
-```bash
-cd operational_analytics
-```
-
-### 2. Configure the pipeline catalog and schema
-
-Edit `resources/operational_analytics.pipeline.yml` to target your Unity Catalog schema:
-
-```yaml
-resources:
-  pipelines:
-    operational_analytics:
-      name: operational_analytics
-      catalog: <CATALOG_NAME>
-      schema: <SCHEMA_NAME>
-      development: true
-      serverless: true
-      libraries:
-        - file:
-            path: src/
-```
-
-The pipeline publishes all datasets to `<CATALOG_NAME>.<SCHEMA_NAME>` by default.
-
-### 3. Build the silver layer: current state from CDC
-
-For each entity, create a SQL file in `src/` that extracts the latest state from the bronze CDC history table. The silver layer deduplicates by primary key and excludes deleted records.
-
-Create `src/silver_<entity>.sql` (e.g., `src/silver_orders.sql`):
-
-```sql
-CREATE OR REFRESH MATERIALIZED VIEW silver_<entity>
-COMMENT "Current state of <entity> records, deduplicated from CDC history"
-AS
-SELECT * EXCEPT (rn, _change_type, _lsn, _commit_timestamp)
-FROM (
-  SELECT *,
-    ROW_NUMBER() OVER (
-      PARTITION BY <primary_key>
-      ORDER BY _lsn DESC
-    ) AS rn
-  FROM <CATALOG_NAME>.<BRONZE_SCHEMA>.lb_<entity>_history
-  WHERE _change_type IN ('insert', 'update_postimage', 'delete')
-)
-WHERE rn = 1
-  AND _change_type != 'delete'
-```
-
-Replace `<primary_key>` with the entity's primary key column(s), `<CATALOG_NAME>.<BRONZE_SCHEMA>` with the catalog and schema where Lakehouse Sync writes the history tables, and `<entity>` with the table name.
-
-Repeat for each entity you want in the silver layer.
-
-### 4. Build the gold layer: business aggregations
-
-Gold layer tables are materialized views that aggregate, join, or reshape silver tables for specific analytics use cases.
-
-Create `src/gold_<metric>.sql` (e.g., `src/gold_daily_order_summary.sql`):
-
-```sql
-CREATE OR REFRESH MATERIALIZED VIEW gold_daily_order_summary
-COMMENT "Daily order counts and revenue by status"
-AS
-SELECT
-  DATE_TRUNC('day', created_at) AS order_date,
-  status,
-  COUNT(*) AS order_count,
-  SUM(total_amount) AS total_revenue
-FROM silver_orders
-GROUP BY DATE_TRUNC('day', created_at), status
-```
-
-Gold tables read from silver tables within the same pipeline. Use `GROUP BY`, `JOIN`, window functions, or any SQL to build the business view you need.
-
-### 5. Add data quality expectations (optional)
-
-Add expectations to silver or gold tables to enforce data quality constraints:
-
-```sql
-CREATE OR REFRESH MATERIALIZED VIEW silver_<entity> (
-  CONSTRAINT valid_primary_key EXPECT (<primary_key> IS NOT NULL) ON VIOLATION DROP ROW,
-  CONSTRAINT valid_timestamp EXPECT (created_at IS NOT NULL) ON VIOLATION DROP ROW
-)
-COMMENT "Current state of <entity> records with quality enforcement"
-AS
-SELECT ...
-```
-
-Expectations catch data issues early and can either warn, drop bad rows, or fail the pipeline update.
-
-### 6. Deploy and run the pipeline
-
-Validate, deploy, and run:
-
-```bash
-databricks bundle validate --profile <PROFILE>
-databricks bundle deploy -t dev --profile <PROFILE>
-databricks bundle run operational_analytics -t dev --profile <PROFILE>
-```
-
-Monitor the pipeline in the Databricks UI under **Workflows** → **Pipelines**.
-
-### 7. Schedule ongoing refreshes
-
-Add a job to refresh the pipeline on a schedule. Create `resources/operational_analytics_job.job.yml`:
-
-```yaml
-resources:
-  jobs:
-    operational_analytics_job:
-      trigger:
-        periodic:
-          interval: 1
-          unit: HOURS
-      tasks:
-        - task_key: refresh_pipeline
-          pipeline_task:
-            pipeline_id: ${resources.pipelines.operational_analytics.id}
-```
-
-Deploy the schedule:
-
-```bash
-databricks bundle deploy -t dev --profile <PROFILE>
-```
-
-### 8. Query the results
-
-Silver and gold tables are standard Unity Catalog tables. Query them from any connected tool:
-
-```sql
--- Current state of an entity
-SELECT * FROM <CATALOG_NAME>.<SCHEMA_NAME>.silver_orders WHERE customer_id = 12345;
-
--- Business aggregation
-SELECT * FROM <CATALOG_NAME>.<SCHEMA_NAME>.gold_daily_order_summary ORDER BY order_date DESC;
-```
-
-Use these tables as sources for Genie spaces, dashboards, notebooks, or ML pipelines.
-
-### What you end up with
-
-- **Bronze layer.** Lakehouse Sync CDC history tables (already exist, no pipeline needed).
-- **Silver layer.** Deduplicated current-state materialized views per entity.
-- **Gold layer.** Business aggregations and metrics as materialized views.
-- **Scheduled pipeline.** Lakeflow Declarative Pipeline refreshing silver and gold layers incrementally.
-- **Unity Catalog tables.** All layers queryable via SQL, Spark, BI tools, and Genie.
-
-### Agent skill recommendations
-
-For implementing each layer, the following Databricks agent skills provide detailed guidance:
-
-| Skill                  | Use for                                                                  |
-| ---------------------- | ------------------------------------------------------------------------ |
-| `databricks-pipelines` | Lakeflow Declarative Pipeline syntax, dataset types, deployment workflow |
-| `databricks-core`      | CLI authentication, profile management, data exploration                 |
-| `databricks-lakebase`  | Lakebase project and branch management, Postgres access                  |
-
-### Troubleshooting
-
-| Issue                                      | Fix                                                                                  |
-| ------------------------------------------ | ------------------------------------------------------------------------------------ |
-| Silver table returns no rows               | Verify the bronze history table has data: `SELECT COUNT(*) FROM lb_<entity>_history` |
-| `TABLE_OR_VIEW_NOT_FOUND` for bronze table | Use the fully-qualified name: `<CATALOG>.<SCHEMA>.lb_<entity>_history`               |
-| Gold aggregation includes deleted records  | Confirm the silver layer filters `_change_type != 'delete'`                          |
-| Pipeline fails on deploy                   | Run `databricks bundle validate` first to catch config errors                        |
-| Incremental refresh not picking up changes | Verify Lakehouse Sync is active and the bronze table is updating                     |
-
-#### References
-
-- [Medallion architecture](https://docs.databricks.com/aws/en/lakehouse/medallion)
-- [Lakeflow Declarative Pipelines](https://docs.databricks.com/aws/en/delta-live-tables/)
-- [Materialized views](https://docs.databricks.com/aws/en/ldp/materialized-views)
-- [Lakehouse Sync](https://docs.databricks.com/aws/en/oltp/projects/lakehouse-sync)
-- [DevHub: Pipelines and freshness](/docs/lakehouse/pipelines)
diff --git a/content/recipes/medallion-architecture-from-cdc/goal.md b/content/recipes/medallion-architecture-from-cdc/goal.md
index 00e566b..bf57e5b 100644
--- a/content/recipes/medallion-architecture-from-cdc/goal.md
+++ b/content/recipes/medallion-architecture-from-cdc/goal.md
@@ -1,5 +1,3 @@
-Transform Lakehouse Sync CDC history tables into a layered medallion architecture with bronze, silver, and gold layers using Lakeflow Declarative Pipelines.
-
 When done, you will have:
 
 - A bronze layer provided by the upstream Lakehouse Sync CDC history tables (input to this recipe)
diff --git a/content/recipes/medallion-architecture-from-cdc/prerequisites.md b/content/recipes/medallion-architecture-from-cdc/prerequisites.md
index e04d115..fe1d8d2 100644
--- a/content/recipes/medallion-architecture-from-cdc/prerequisites.md
+++ b/content/recipes/medallion-architecture-from-cdc/prerequisites.md
@@ -1,6 +1,5 @@
 This template builds a Lakeflow Declarative Pipeline on top of existing Lakehouse Sync CDC history tables. Verify these Databricks workspace features are enabled before starting.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **Lakeflow Declarative Pipelines (serverless) available.** Run `databricks pipelines list --profile <PROFILE>` and confirm the command succeeds (an empty list is fine). A permission or `not enabled` error means Lakeflow Pipelines is not available to this identity.
 - **Unity Catalog access with a writable destination schema.** Run `databricks catalogs list --profile <PROFILE>` and confirm your destination catalog is listed. You will need `USE_CATALOG` on the catalog and `USE_SCHEMA` + `CREATE_TABLE` on the destination schema to publish silver and gold tables.
 - **Bronze CDC history tables already in Unity Catalog.** Complete the [Lakebase Change Data Feed (Autoscaling, Lakehouse Sync)](/templates/lakebase-change-data-feed-autoscaling) template first so `lb_<entity>_history` tables exist in the bronze schema. This template reads from those tables; it does not create them.
diff --git a/content/recipes/model-serving-endpoint-creation/content.md b/content/recipes/model-serving-endpoint-creation/content.md
deleted file mode 100644
index fdb77eb..0000000
--- a/content/recipes/model-serving-endpoint-creation/content.md
+++ /dev/null
@@ -1,89 +0,0 @@
-## Create a Databricks Model Serving Endpoint
-
-Create and validate a Databricks Model Serving endpoint for AI chat inference.
-
-### 1. Choose an endpoint name
-
-Pick a descriptive endpoint name for your app or feature.
-
-Examples:
-
-- `support-assistant`
-- `analytics-copilot`
-
-### 2. List available foundation models
-
-```bash
-databricks serving-endpoints get-open-api \
-  --profile <PROFILE> \
-  -o json
-```
-
-If your workspace uses a curated endpoint catalog, list available endpoints first:
-
-```bash
-databricks serving-endpoints list --profile <PROFILE> -o json
-```
-
-### 3. Create a serving endpoint
-
-Create an endpoint with a served model using the workspace-supported model name.
-
-```bash
-databricks serving-endpoints create <endpoint-name> \
-  --config '{
-    "served_entities": [
-      {
-        "name": "<entity-name>",
-        "entity_name": "<foundation-model-or-registered-model>",
-        "entity_version": "<version-if-required>",
-        "workload_size": "Small",
-        "scale_to_zero_enabled": true
-      }
-    ]
-  }' \
-  --profile <PROFILE>
-```
-
-### 4. Wait until the endpoint is ready
-
-```bash
-databricks serving-endpoints get <endpoint-name> --profile <PROFILE> -o json
-```
-
-Check that the endpoint is in a READY state before connecting your app.
-
-### 5. Test the endpoint directly
-
-Use the OpenAI-compatible chat completions API exposed by Databricks:
-
-```bash
-curl -sS \
-  -H "Authorization: Bearer <TOKEN>" \
-  -H "Content-Type: application/json" \
-  "https://<workspace>.cloud.databricks.com/serving-endpoints/<endpoint-name>/invocations" \
-  -d '{
-    "messages": [
-      { "role": "system", "content": "You are a helpful assistant." },
-      { "role": "user", "content": "Say hello in one short sentence." }
-    ],
-    "max_tokens": 64
-  }'
-```
-
-### 6. Add endpoint name to app config
-
-Set the endpoint name in `app.yaml`:
-
-```yaml
-env:
-  - name: DATABRICKS_SERVING_ENDPOINT
-    value: "<endpoint-name>"
-```
-
-For local development, mirror this in `.env` (for example `DATABRICKS_SERVING_ENDPOINT=databricks-gpt-5-4-mini`).
-
-#### References
-
-- [Databricks Model Serving endpoints](https://docs.databricks.com/en/machine-learning/model-serving/create-manage-serving-endpoints.html)
-- [Databricks AI Gateway](https://docs.databricks.com/en/ai-gateway/)
diff --git a/content/recipes/model-serving-endpoint-creation/goal.md b/content/recipes/model-serving-endpoint-creation/goal.md
index 3bb0135..3e9d92c 100644
--- a/content/recipes/model-serving-endpoint-creation/goal.md
+++ b/content/recipes/model-serving-endpoint-creation/goal.md
@@ -1,5 +1,3 @@
-Provision and validate a Databricks Model Serving endpoint for AI chat inference.
-
 When done, you will have:
 
 - A model serving endpoint running in your Databricks workspace
diff --git a/content/recipes/model-serving-endpoint-creation/prerequisites.md b/content/recipes/model-serving-endpoint-creation/prerequisites.md
index 55bc0db..02dfa03 100644
--- a/content/recipes/model-serving-endpoint-creation/prerequisites.md
+++ b/content/recipes/model-serving-endpoint-creation/prerequisites.md
@@ -1,6 +1,5 @@
 Verify these Databricks workspace features are enabled before starting. If any check fails, ask your workspace admin to enable the feature.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **Model Serving enabled.** Run `databricks serving-endpoints list --profile <PROFILE>` and confirm the command succeeds (an empty list is fine — you are about to create an endpoint). A permission or `not enabled` error means Model Serving is not available to this identity.
 - **Permission to create serving endpoints.** The Databricks CLI call in Step 3 requires the `CAN_MANAGE` serving-endpoint permission on the workspace. If `databricks serving-endpoints create` returns `PERMISSION_DENIED`, ask your admin to grant it.
 - **A foundation model or registered MLflow model to serve.** List foundation-model entities available to your workspace with `databricks serving-endpoints get-open-api --profile <PROFILE> -o json`. If you plan to serve a registered Unity Catalog model instead, confirm it exists in the Databricks UI under **Models** before running `databricks serving-endpoints create`.
diff --git a/content/recipes/onboard-your-coding-agent/content.md b/content/recipes/onboard-your-coding-agent/content.md
deleted file mode 100644
index 3de79e2..0000000
--- a/content/recipes/onboard-your-coding-agent/content.md
+++ /dev/null
@@ -1,159 +0,0 @@
-## Onboard Your Coding Agent
-
-Make a Databricks repo agent-ready in four steps: install Databricks platform skills into the user's coding agent (project-scoped, so the rules ride with the repo), wire up the DevHub Docs MCP server so the agent can fetch any DevHub page on demand, and bootstrap an `AGENTS.md` (with a symlinked `CLAUDE.md`) that pins the workspace defaults this codebase should use.
-
-References:
-
-- [Agent skills](/docs/tools/ai-tools/agent-skills) — what the Databricks skills give your agent and the full `databricks aitools` flag matrix.
-- [Docs MCP Server](/docs/tools/ai-tools/docs-mcp-server) — what the DevHub MCP server exposes and how to verify it is connected.
-
-### 1. Install Databricks agent skills (project-scoped)
-
-Skills are task-specific instruction files (`databricks-apps`, `databricks-core`, `databricks-lakebase`, `databricks-pipelines`, `databricks-jobs`, etc.) that tell the user's coding agent how Databricks works — CLI conventions, auth patterns, resource shapes — so it generates correct code instead of guessing.
-
-By default, skills install **globally** to each agent's user-level config directory. For a repo handed off to a team, prefer **project scope** so the rules live alongside the code and travel with the repo:
-
-```bash
-databricks aitools install --project
-```
-
-This installs every Databricks skill into the current project directory's agent config (e.g. `.cursor/rules/`, `.claude/skills/`). Run from the repo root.
-
-If the user only wants a subset, scope by skill name and/or by agent:
-
-```bash
-databricks aitools install --project --skills databricks-apps,databricks-lakebase --agents cursor,claude-code
-```
-
-Verify what got installed:
-
-```bash
-databricks aitools list --project
-```
-
-`databricks aitools install --help` is the source of truth for the flag list — DevHub mirrors it on the [agent skills page](/docs/tools/ai-tools/agent-skills) but the CLI is authoritative.
-
-### 2. Wire up the DevHub Docs MCP server
-
-The DevHub MCP server gives coding agents read access to every page on `developers.databricks.com` (docs, templates, and examples) without leaving the editor. The agent can call `list_docs_resources` to see the index and `get_doc_resource(slug)` to fetch any page as markdown.
-
-Install at project scope so the server is bound to this repo (drop `-g` if you want it user-wide):
-
-```bash
-npx add-mcp https://developers.databricks.com/api/mcp --name devhub-docs
-```
-
-To target a specific agent (otherwise the installer auto-detects):
-
-```bash
-npx add-mcp https://developers.databricks.com/api/mcp --name devhub-docs -a cursor
-```
-
-Restart the editor after installation. Some editors (Cursor) require visiting the MCP settings page and toggling `devhub-docs` to enabled.
-
-Verify the connection:
-
-1. Confirm `devhub-docs` shows up in the agent's tool list.
-2. Ask the agent to call `list_docs_resources` — it should return the DevHub markdown index.
-3. Ask the agent to call `get_doc_resource(slug: "start-here")` — it should return the [start-here doc](/docs/start-here) as markdown.
-
-### 3. Bootstrap an `AGENTS.md` with this repo's Databricks defaults
-
-`AGENTS.md` is the project-root file that any modern coding agent reads first to learn how to behave on this codebase. We want a "Working with Databricks" section that pins the resources and CLI profile this repo should default to, so the agent stops guessing on every prompt.
-
-#### 3a. Detect existing files first — do not overwrite
-
-Before writing anything, check what already exists:
-
-```bash
-ls AGENTS.md CLAUDE.md 2>/dev/null
-```
-
-- **Both exist as separate files** → ask the user whether `CLAUDE.md` is a symlink to `AGENTS.md` (run `ls -l CLAUDE.md`) or a divergent file. If divergent, surface that to the user and ask before merging — never overwrite hand-written agent instructions.
-- **Only `AGENTS.md` exists** → append the "Working with Databricks" section below. Then `ln -s AGENTS.md CLAUDE.md` so Claude Code reads the same content.
-- **Only `CLAUDE.md` exists** → rename to `AGENTS.md` (`mv CLAUDE.md AGENTS.md`), then symlink (`ln -s AGENTS.md CLAUDE.md`). Append the section.
-- **Neither exists** → create `AGENTS.md` with the template below, then `ln -s AGENTS.md CLAUDE.md`.
-
-#### 3b. Ask the user for this repo's defaults
-
-Before generating `AGENTS.md`, walk through these questions one at a time (using a multiple-choice tool when available). Leave any answer blank with `TODO:` if the user does not know yet — you can fill it in later as the project develops. Do not infer or invent values.
-
-- **CLI profile** for this repo (e.g. `DEFAULT`, `my-prod-workspace`). Get the list with `databricks auth profiles`.
-- **Workspace URL** (the `Host` column from `databricks auth profiles` for the chosen profile).
-- **Unity Catalog defaults** — catalog name and schema name this repo's tables should land in. Defaults are often `<team_name>_dev` and `<project_name>` respectively.
-- **Lakebase defaults** (only if the app uses Lakebase) — project name, branch (typically `production`), database name, endpoint name (typically `primary`).
-- **Genie space ID** (only if the app embeds Genie).
-- **Model Serving endpoint name** (only if the app calls Databricks-hosted models).
-
-#### 3c. Write the section
-
-Append this block to `AGENTS.md` (substituting the user's answers; keep `TODO:` markers for anything they did not specify):
-
-```markdown title="AGENTS.md (excerpt)"
-## Working with Databricks
-
-This repo deploys onto a single Databricks workspace. When suggesting CLI commands, infrastructure-as-code, or queries, default to these values unless the user asks for something else. Surface the assumption out loud whenever you act on one of them so the user can correct you.
-
-**CLI profile**: `<PROFILE>` — pass `--profile <PROFILE>` on every `databricks` command, or set `export DATABRICKS_CONFIG_PROFILE=<PROFILE>` in the shell session.
-
-**Workspace URL**: `<https://<workspace>.cloud.databricks.com>`
-
-**Unity Catalog defaults**:
-
-- Catalog: `<catalog>`
-- Schema: `<schema>`
-- Reference tables as `` `<catalog>.<schema>.<table>` `` in SQL.
-
-**Lakebase defaults** _(only if the app persists data in Lakebase)_:
-
-- Project: `<project>`
-- Branch: `production`
-- Database: `<database>`
-- Endpoint: `primary`
-
-**Genie space** _(only if the app uses conversational analytics)_:
-
-- Space ID: `<space-id>`
-
-**Model Serving endpoint** _(only if the app calls Databricks-hosted models)_:
-
-- Endpoint name: `<endpoint>`
-
-**Conventions**:
-
-- Always run `databricks auth profiles` and confirm `<PROFILE>` shows `Valid: YES` before running anything that hits the workspace.
-- For non-trivial destructive operations (`databricks apps delete`, `DROP TABLE`, etc.), ask the user to confirm before running.
-- DevHub is the source of truth for the Databricks developer stack. When unsure of a CLI flag or a plugin shape, fetch the matching page from <https://developers.databricks.com/llms.txt> via the `devhub-docs` MCP server before guessing.
-```
-
-#### 3d. Symlink `CLAUDE.md` → `AGENTS.md`
-
-Claude Code (and Codex) read `CLAUDE.md` if present and `AGENTS.md` otherwise. To keep one source of truth:
-
-```bash
-ln -s AGENTS.md CLAUDE.md
-```
-
-On Windows without symlink support, copy instead and remind the user to keep them in sync (or use `mklink /H CLAUDE.md AGENTS.md` for a hard link in cmd).
-
-Confirm:
-
-```bash
-ls -l AGENTS.md CLAUDE.md
-```
-
-`CLAUDE.md` should show as `-> AGENTS.md`.
-
-### 4. Smoke-test the agent
-
-Open a fresh chat with the user's coding agent and ask it:
-
-> Look at AGENTS.md and tell me which CLI profile and Unity Catalog schema this repo uses by default.
-
-The agent should answer correctly without needing to fetch any extra context — that confirms the agent is reading `AGENTS.md` and the Databricks skills are loaded. If it cannot, re-check that the skill install step ran in the project directory (`databricks aitools list --project`) and that `AGENTS.md` is at the repo root.
-
-### Where to next
-
-- [Templates catalog](/templates) — pick a template, copy the prompt, and the agent now has full Databricks context to execute against your workspace defaults.
-- [DevHub Docs MCP Server reference](/docs/tools/ai-tools/docs-mcp-server) — full tool list and connection troubleshooting.
-- [Agent skills reference](/docs/tools/ai-tools/agent-skills) — the full skill catalog plus `--global` / `--project` / `--agents` / `--skills` flag matrix.
diff --git a/content/recipes/onboard-your-coding-agent/goal.md b/content/recipes/onboard-your-coding-agent/goal.md
index 3a94622..e7e749e 100644
--- a/content/recipes/onboard-your-coding-agent/goal.md
+++ b/content/recipes/onboard-your-coding-agent/goal.md
@@ -1,5 +1,3 @@
-Make a Databricks repo agent-ready so your coding agent understands the Databricks platform and can fetch DevHub documentation on demand.
-
 When done, you will have:
 
 - Databricks platform skills installed at project scope, traveling with the repo
diff --git a/content/recipes/onboard-your-coding-agent/prerequisites.md b/content/recipes/onboard-your-coding-agent/prerequisites.md
index 4c82c32..d25f6b9 100644
--- a/content/recipes/onboard-your-coding-agent/prerequisites.md
+++ b/content/recipes/onboard-your-coding-agent/prerequisites.md
@@ -1,6 +1,5 @@
 This template makes a Databricks repo agent-ready: it installs Databricks platform knowledge into the user's coding agent, wires up the DevHub Docs MCP server, and writes an `AGENTS.md` (with a symlinked `CLAUDE.md`) that pins the workspace defaults agents need to do the right thing on this codebase.
 
-- **A working Databricks CLI profile.** The agent skills installer auto-detects installed coding agents and symlinks Databricks-specific instruction files into them — no auth required for the install itself, but every skill you install assumes a valid profile downstream. If `databricks auth profiles` does not show a `Valid: YES` profile, run [Set Up Your Local Dev Environment](/templates/set-up-your-local-dev-environment) first.
 - **A repo to onboard the agent into.** Run this from the root of the project the agent will work on. If the user does not have a project yet, run [Spin Up a Databricks App](/templates/spin-up-databricks-app) first and come back here from inside the scaffolded directory.
 - **A coding agent installed locally.** The Databricks aitools installer detects Cursor, Claude Code, Codex CLI, OpenCode, GitHub Copilot, and Antigravity. The DevHub MCP server install via `npx add-mcp` works with the same set plus VS Code.
 - **`npx` available.** The DevHub MCP install runs through `npx add-mcp` — comes with Node.js `18+`.
diff --git a/content/recipes/set-up-your-local-dev-environment/content.md b/content/recipes/set-up-your-local-dev-environment/content.md
deleted file mode 100644
index ff06336..0000000
--- a/content/recipes/set-up-your-local-dev-environment/content.md
+++ /dev/null
@@ -1,106 +0,0 @@
-## Set Up Your Local Dev Environment
-
-Install the Databricks CLI, authenticate a profile, and verify the handshake. Every other DevHub template assumes this has already passed.
-
-The official CLI reference for these steps is on DevHub at [Databricks CLI](/docs/tools/databricks-cli). Use it whenever a step here is unclear.
-
-### 1. Check the installed CLI version
-
-DevHub templates assume Databricks CLI `1.0.0+`. Anything older is missing the AppKit `apps init` template registry and several `aitools` flags.
-
-```bash
-databricks -v
-```
-
-If the command is not found, or the version is below `1.0.0`, install or upgrade in the next step.
-
-### 2. Install or upgrade the Databricks CLI
-
-Pick the install path for your OS. If the CLI is already installed at an older version, the same commands upgrade in place.
-
-#### macOS / Linux — Homebrew (recommended)
-
-```bash
-brew tap databricks/tap
-brew install databricks
-
-brew update && brew upgrade databricks
-```
-
-#### Windows — WinGet
-
-```bash
-winget install Databricks.DatabricksCLI
-
-winget upgrade Databricks.DatabricksCLI
-```
-
-Restart your terminal after install.
-
-#### Any platform — curl installer
-
-```bash
-curl -fsSL https://raw.githubusercontent.com/databricks/setup-cli/main/install.sh | sh
-```
-
-On Windows, run this from WSL. If `/usr/local/bin` is not writable, rerun with `sudo`. Re-running the script also upgrades an existing install.
-
-After installing, confirm the version is `1.0.0+`:
-
-```bash
-databricks -v
-```
-
-### 3. Authenticate a profile
-
-Always use OAuth for local development. Personal Access Tokens (PATs) are for CI/CD or non-interactive environments only.
-
-Browser-based OAuth is the default for local use:
-
-```bash
-databricks auth login
-```
-
-The CLI prints a URL and waits for the user to complete OAuth in the browser. **Always show the URL to the user as a clickable link** so they can open it themselves — the CLI does not return until authentication finishes. Credentials save to `~/.databrickscfg`.
-
-If you already know the workspace URL and want to name the profile, do it in one go:
-
-```bash
-databricks auth login --host <workspace-url> --profile <PROFILE>
-```
-
-`<PROFILE>` is the label you will pass on subsequent commands as `--profile <PROFILE>`. If you skip `--profile`, the CLI uses the `DEFAULT` profile.
-
-For CI/CD, OAuth client credentials or a personal access token are better fits — see the [authentication section of the CLI doc](/docs/tools/databricks-cli#authenticate) for the non-interactive flows.
-
-### 4. Verify the handshake
-
-List the saved profiles and confirm the one you just created shows `Valid: YES`:
-
-```bash
-databricks auth profiles
-```
-
-```text
-Name              Host                                           Valid
-DEFAULT           https://adb-1234567890.12.azuredatabricks.net  YES
-my-prod-workspace https://mycompany.cloud.databricks.com         YES
-```
-
-If the row shows `Valid: NO`, the saved token is stale. Re-run `databricks auth login --profile <NAME>` to refresh it. **Never proceed past this step if no profile is `Valid: YES`** — every downstream `databricks` command will fail with an auth error that looks like a template bug.
-
-If the user wants a particular profile to be the default for this shell session, export it:
-
-```bash
-export DATABRICKS_CONFIG_PROFILE=<PROFILE>
-```
-
-### 5. Smoke-test the CLI against the workspace
-
-Run a read-only API call to confirm the auth actually works (a fresh OAuth token can fail on the first real call if the user picked the wrong workspace in the browser):
-
-```bash
-databricks current-user me --profile <PROFILE>
-```
-
-A successful response prints the signed-in user's identity. A `401` or `403` here means the auth flow completed against a workspace the user cannot read — re-run `databricks auth login --profile <PROFILE>` and pick the right workspace this time.
diff --git a/content/recipes/set-up-your-local-dev-environment/goal.md b/content/recipes/set-up-your-local-dev-environment/goal.md
index aae8384..0d6f17a 100644
--- a/content/recipes/set-up-your-local-dev-environment/goal.md
+++ b/content/recipes/set-up-your-local-dev-environment/goal.md
@@ -1,5 +1,3 @@
-Install the Databricks CLI, authenticate a profile, and verify the handshake. Every other DevHub template assumes this has already passed.
-
 When done, you will have:
 
 - Databricks CLI `1.0.0+` installed and on `PATH`
diff --git a/content/recipes/spin-up-databricks-app/content.md b/content/recipes/spin-up-databricks-app/content.md
deleted file mode 100644
index a13c7e3..0000000
--- a/content/recipes/spin-up-databricks-app/content.md
+++ /dev/null
@@ -1,111 +0,0 @@
-## Spin Up a Databricks App
-
-Generate a working AppKit Databricks App from scratch in a couple of minutes. This template runs `databricks apps init` to scaffold the project, runs it locally, and deploys it to your workspace.
-
-The full CLI surface — every `--features`, `--set`, `--target`, and the post-deploy management commands — lives on DevHub at [App development](/docs/apps/development) and [Apps quickstart](/docs/apps/quickstart). Use those whenever a flag below is unclear.
-
-### 1. Decide what plugins (`--features`) the app needs
-
-`databricks apps init` produces a working app on its own, but most real apps want one or more AppKit plugins wired in from the start. Pick what you need before running init:
-
-- `lakebase` — managed Postgres for persistent app data. See [Lakebase Quickstart](/docs/lakebase/quickstart).
-- `analytics` — query a SQL Warehouse from the app server.
-- `genie` — embed AI/BI Genie conversational analytics. See [Genie spaces](/docs/agents/genie).
-- `model-serving` — call Databricks-hosted LLMs and ML endpoints.
-
-If you are unsure, list every available plugin and the resource fields each one needs:
-
-```bash
-databricks apps manifest --profile <PROFILE>
-```
-
-Pass plugins as a comma-separated list to `--features` in the next step.
-
-### 2. Scaffold the project with `databricks apps init`
-
-Run from the directory where you want the project created. The CLI creates a new folder named after `--name` inside the current directory.
-
-```bash
-databricks apps init \
-  --name <app-name> \
-  --description "<one-sentence description>" \
-  --features <comma-separated-plugins> \
-  --version latest \
-  --run none \
-  --profile <PROFILE>
-```
-
-Notable flags:
-
-- `--name` — lowercase, hyphenated, ≤ 26 characters. Passing it suppresses interactive prompts.
-- `--features` — omit if you want the bare-minimum app with no plugins.
-- `--version latest` — pin to the latest AppKit release. Drop this for `main`.
-- `--run none` — do not run dev or deploy automatically; we will do those steps explicitly below.
-- `--profile <PROFILE>` — only needed if `<PROFILE>` is not your `DEFAULT`.
-
-For the full flag list and `--set` syntax for resources that need explicit branch/database fields, see [Scaffold options](/docs/apps/development#scaffold-options).
-
-### 3. Install dependencies and run locally
-
-```bash
-cd <app-name>
-npm install
-npm run dev
-```
-
-`npm run dev` reads from `.env` (copy `.env.example` and fill in resource IDs if you used `--features`) and serves the app on `http://localhost:3000` by default.
-
-For Lakebase-backed apps the local user also needs `databricks_superuser` so they can read the schemas the deployed service principal owns — see [Apps development → Local setup](/docs/apps/development#local-setup).
-
-### 4. Make it look great before showing the user
-
-The default AppKit scaffold is intentionally minimal. **Do not stop there.** Use the user's actual feature requests to redesign the routes, page hierarchy, and visual style from first principles _before_ asking the user to run and test locally. shadcn/ui on Tailwind is the default; the Databricks brand palette is `#FF3621`, `#0B2026`, `#EEEDE9`, `#F9F7F4`. The full design guidance lives in the dev-guidelines block at the top of any DevHub prompt.
-
-### 5. Verify locally before deploying
-
-If `agent-browser` is available (or the user approves installing it), use it to drive the local app and confirm the happy path works:
-
-```bash
-npm i -g agent-browser && agent-browser install
-agent-browser skills get agent-browser
-agent-browser open http://localhost:3000
-```
-
-Otherwise share the localhost URL with the user and ask them to click through the key flows. Do not deploy until the local app behaves as intended — Databricks Apps deploys are not free and a broken local build will not magically fix itself in production.
-
-### 6. Update smoke tests
-
-Before validating, update `tests/smoke.spec.ts` to match your app's actual content. The default selectors look for "Minimal Databricks App" and "hello world" text, which will fail on any customized app. Use `getByRole`, `getByText`, or `getByPlaceholder` — never `getByLabelText` (that is a React Testing Library method, not Playwright). Keep result sets under the 1 MB analytics-event payload cap — queries returning thousands of rows cause `INVALID_REQUEST: Event exceeds max size`. Use `LIMIT` or aggregated queries.
-
-### 7. Validate and deploy
-
-Run the project validator first (build + typecheck + lint) so the deploy does not fail on something that would have been caught locally:
-
-```bash
-databricks apps validate --profile <PROFILE>
-```
-
-Then deploy from the project directory:
-
-```bash
-databricks apps deploy --profile <PROFILE>
-```
-
-The CLI uploads the project, builds it on Databricks, and starts the app. On success it prints the workspace URL.
-
-### 8. Verify the deployed app
-
-```bash
-databricks apps get <app-name> --profile <PROFILE> -o json
-databricks apps logs <app-name> --profile <PROFILE>
-```
-
-`apps get` shows `app_status.state: RUNNING` once the app is healthy. `apps logs` streams `[BUILD]`, `[SYSTEM]`, and `[APP]` lines — useful when something goes wrong on first deploy.
-
-Open the URL from `apps get` (signed in to Databricks) to confirm the app responds, then iterate: edit code, redeploy.
-
-### Where to next
-
-- [Onboard Your Coding Agent](/templates/onboard-your-coding-agent) — install Databricks skills (project-scoped) and the DevHub MCP server so your editor's AI assistant has the same context the human does.
-- [App development reference](/docs/apps/development) — all `apps init` / `apps deploy` flags, environment configuration, the pre-deploy checklist, and troubleshooting.
-- [Templates catalog](/templates) — fully composed templates (AI chat, app + Lakebase, Genie analytics, operational analytics) when the bare scaffold is not what you want.
diff --git a/content/recipes/spin-up-databricks-app/goal.md b/content/recipes/spin-up-databricks-app/goal.md
index 767db71..2283f33 100644
--- a/content/recipes/spin-up-databricks-app/goal.md
+++ b/content/recipes/spin-up-databricks-app/goal.md
@@ -1,5 +1,3 @@
-Generate a working AppKit Databricks App from scratch and deploy it to your workspace.
-
 When done, you will have:
 
 - A scaffolded Databricks App project with selected plugins (e.g. Lakebase, analytics, Genie, model serving)
diff --git a/content/recipes/spin-up-databricks-app/prerequisites.md b/content/recipes/spin-up-databricks-app/prerequisites.md
index 58a07a9..b561246 100644
--- a/content/recipes/spin-up-databricks-app/prerequisites.md
+++ b/content/recipes/spin-up-databricks-app/prerequisites.md
@@ -1,6 +1,5 @@
 This template scaffolds a fresh AppKit Databricks App from scratch using `databricks apps init`. Use it when the user wants the smallest possible Databricks App as a starting point — you can layer plugins, routes, and deploy from here.
 
-- **A working Databricks CLI profile.** The init flow calls the workspace API to resolve the AppKit template registry and any `--features` resource bindings, so it fails immediately without auth. If `databricks auth profiles` does not show a `Valid: YES` profile, run [Set Up Your Local Dev Environment](/templates/set-up-your-local-dev-environment) first.
 - **Permission to deploy Databricks Apps in the target workspace.** This template ends with `databricks apps deploy`. If Apps is not enabled for the user's identity, deploy fails with `PERMISSION_DENIED`.
 - **Node.js `22+` and `git` on PATH.** AppKit projects are Node/TypeScript and `npm install` runs against the public registry.
 - **An app name and description in mind.** Names must be lowercase, hyphenated, and ≤ 26 characters. Ask the user for a name and a one-sentence description before running `apps init`.
diff --git a/content/recipes/sync-tables-autoscaling/content.md b/content/recipes/sync-tables-autoscaling/content.md
deleted file mode 100644
index 4136757..0000000
--- a/content/recipes/sync-tables-autoscaling/content.md
+++ /dev/null
@@ -1,163 +0,0 @@
-## Sync a Unity Catalog Table to Lakebase
-
-Serve lakehouse data through Lakebase Autoscaling Postgres so your applications can query it with sub-10ms latency. This creates a synced table, a managed copy of your Unity Catalog table in Lakebase that stays up to date automatically.
-
-> This template is for **Lakebase Autoscaling** (projects/branches/endpoints with scale-to-zero). For Lakebase Provisioned (manually scaled instances), see the Provisioned Sync Tables template (coming soon).
-
-### When to use this
-
-- Your app needs fast lookup-style queries against analytics data (user profiles, feature values, risk scores)
-- You want to serve gold tables, ML outputs, or enriched records through a standard Postgres connection
-- You need ACID transactions and sub-10ms reads alongside your operational state
-
-### Choose a sync mode
-
-| Mode           | Behavior                                       | Best for                                                                              |
-| -------------- | ---------------------------------------------- | ------------------------------------------------------------------------------------- |
-| **Snapshot**   | One-time full copy                             | Source changes >10% of rows per cycle, or source doesn't support CDF (views, Iceberg) |
-| **Triggered**  | Incremental updates on demand or on a schedule | Known cadence of changes, good cost/freshness balance                                 |
-| **Continuous** | Real-time streaming (seconds of latency)       | Changes must appear in Lakebase near-instantly                                        |
-
-> **Triggered** and **Continuous** modes require [Change Data Feed (CDF)](https://docs.databricks.com/aws/en/delta/delta-change-data-feed) enabled on the source table. If it's not enabled, run:
->
-> ```sql
-> ALTER TABLE <catalog>.<schema>.<table> SET TBLPROPERTIES (delta.enableChangeDataFeed = true);
-> ```
-
-### Sync throughput
-
-Autoscaling CUs are physically 8x smaller than Provisioned CUs, so per-CU throughput differs:
-
-| Mode                                     | Rows/sec per CU |
-| ---------------------------------------- | --------------- |
-| **Snapshot** (initial + full refresh)    | ~2,000          |
-| **Triggered / Continuous** (incremental) | ~150            |
-
-> A 10x speedup for large-table snapshot sync (writing Postgres pages directly, leveraging separation of storage and compute) is coming for Autoscaling only.
-
-### 1. Create a synced table
-
-> Your Lakebase database must be registered as a UC catalog first (one-time setup per project). If not already done:
->
-> ```bash
-> databricks postgres create-catalog <CATALOG_NAME> \
->   --json '{
->     "spec": {
->       "postgres_database": "<POSTGRES_DATABASE>",
->       "branch": "projects/<PROJECT_ID>/branches/<BRANCH_ID>"
->     }
->   }' --profile <PROFILE>
-> ```
-
-```bash
-databricks postgres create-synced-table <LAKEBASE_CATALOG>.<SCHEMA>.<SYNCED_TABLE_NAME> \
-  --json '{
-    "spec": {
-      "source_table_full_name": "<CATALOG>.<SCHEMA>.<SOURCE_TABLE>",
-      "primary_key_columns": ["<PRIMARY_KEY_COLUMN>"],
-      "scheduling_policy": "<SNAPSHOT|TRIGGERED|CONTINUOUS>",
-      "branch": "projects/<PROJECT_ID>/branches/<BRANCH_ID>",
-      "postgres_database": "databricks_postgres",
-      "create_database_objects_if_missing": true,
-      "new_pipeline_spec": {
-        "storage_catalog": "<REGULAR_UC_CATALOG>",
-        "storage_schema": "default"
-      }
-    }
-  }' --profile <PROFILE>
-```
-
-`new_pipeline_spec.storage_catalog` must be a **regular** UC catalog for DLT pipeline metadata, not the Lakebase catalog. Long-running operation; the CLI waits by default. Use `--no-wait` to return immediately.
-
-> **DABs:** Do not use `synced_database_tables` in DABs with Autoscaling projects — it maps to the Provisioned Terraform resource and may create unintended Provisioned instances. DAB support for Autoscaling synced tables is not yet available. Use the CLI commands above.
-
-Verify:
-
-```bash
-databricks postgres get-synced-table \
-  "synced_tables/<LAKEBASE_CATALOG>.<SCHEMA>.<SYNCED_TABLE_NAME>" \
-  --profile <PROFILE>
-```
-
-### 2. Configure pipeline reuse
-
-How you set up pipelines depends on your sync mode:
-
-| Sync mode                | Recommendation                         | Why                                                                                                                  |
-| ------------------------ | -------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
-| **Continuous**           | **Reuse** a pipeline across ~10 tables | Cost-advantageous (e.g., 1 pipeline for 10 tables ≈ $204/table/month vs $2,044/table/month for individual pipelines) |
-| **Snapshot / Triggered** | **Separate** pipelines per table       | Allows re-snapshotting individual tables without impacting others                                                    |
-
-### 3. Schedule ongoing syncs
-
-The initial snapshot runs automatically on creation. For **Snapshot** and **Triggered** modes, subsequent syncs need to be triggered.
-
-> **Note:** Table-update triggers for sync pipelines are not yet available via CLI and must be configured through the Databricks UI: **Workflows** → create/open a job → add a **Database Table Sync pipeline** task → **Schedules & Triggers** → add a **Table update** trigger pointing to your source table.
-
-Trigger a sync update programmatically via the Databricks CLI. Look up the pipeline ID for the synced table, then start an update:
-
-```bash
-PIPELINE_ID=$(databricks postgres get-synced-table \
-  "synced_tables/<LAKEBASE_CATALOG>.<SCHEMA>.<SYNCED_TABLE_NAME>" \
-  --output json --profile <PROFILE> \
-  | jq -r '.data_synchronization_status.pipeline_id')
-
-databricks pipelines start-update "$PIPELINE_ID" --profile <PROFILE>
-```
-
-### 4. Query the synced data in Postgres
-
-Once synced, the table is available in Lakebase Postgres. The Unity Catalog schema becomes the Postgres schema:
-
-```sql
-SELECT * FROM "<schema>"."<synced_table_name>" WHERE "user_id" = 12345;
-```
-
-Connect with any standard Postgres client (psql, DBeaver, your application's Postgres driver).
-
-### What you end up with
-
-- A **synced table** in Unity Catalog that tracks the sync pipeline
-- A **read-only Postgres table** in Lakebase that your apps can query with sub-10ms latency
-- A **managed Lakeflow pipeline** that keeps the data in sync based on your chosen mode
-- Up to **16 connections** per sync to your Lakebase database
-
-### Important constraints
-
-- **Primary key is mandatory.** Synced tables always require a primary key. It enables efficient point lookups and incremental updates. Rows with nulls in PK columns are excluded from the sync.
-- **Duplicate primary keys fail the sync** unless you configure a `timeseries_key` for deduplication (latest value wins per PK). Using a timeseries key has a performance penalty.
-- **Schema changes**: For Triggered/Continuous mode, only **additive** changes (e.g., adding a column) propagate. Dropping or renaming columns requires recreating the synced table.
-- **FGAC tables**: Direct sync of Fine-Grained Access Control tables fails. **Workaround**: create a view (`SELECT * FROM table`), then sync the view in Snapshot mode. Caveat: runs as the sync creator and only sees their visible rows.
-- **Connection limits**: Autoscaling supports up to 4,000 concurrent connections (varies by compute size). Each sync uses up to 16 connections.
-- **Read-only in Postgres**: Synced tables should only be read from Postgres. Writing to them interferes with the sync pipeline.
-
-### Cost guidance
-
-Cost formula: `[Rows / (Speed × CUs × 3600)] × DLT Hourly Rate`
-
-Example costs (181M rows, 1 CU, $2.80/hr DLT rate):
-
-| Mode                               | Monthly cost |
-| ---------------------------------- | ------------ |
-| Snapshot (daily)                   | ~$2,110      |
-| Triggered (daily, 5% changes)      | ~$1,407      |
-| Continuous (10 tables, 1 pipeline) | ~$204/table  |
-| Continuous (1 table, 1 pipeline)   | ~$2,044      |
-
-### Troubleshooting
-
-| Issue                               | Fix                                                                                       |
-| ----------------------------------- | ----------------------------------------------------------------------------------------- |
-| CDF not enabled warning             | Run `ALTER TABLE ... SET TBLPROPERTIES (delta.enableChangeDataFeed = true)` on the source |
-| Schema not visible in create dialog | Confirm you have `USE_SCHEMA` and `CREATE_TABLE` on the target schema                     |
-| Null bytes in string columns        | Clean source data: `SELECT REPLACE(col, CAST(CHAR(0) AS STRING), '') AS col FROM table`   |
-| Sync failing                        | Check the pipeline in the synced table's Overview tab for error details                   |
-| FGAC table sync fails               | Create a view over the table and sync the view in Snapshot mode                           |
-| Duplicate primary key failure       | Add a `timeseries_key` to deduplicate (latest wins)                                       |
-
-#### References
-
-- [Synced tables (Autoscaling)](https://docs.databricks.com/aws/en/oltp/projects/sync-tables)
-- [Change Data Feed](https://docs.databricks.com/aws/en/delta/delta-change-data-feed)
-- [Lakebase Autoscaling](https://docs.databricks.com/aws/en/oltp/projects/)
-- [DevHub: Data Lakehouse overview](/docs/lakehouse/overview)
diff --git a/content/recipes/sync-tables-autoscaling/goal.md b/content/recipes/sync-tables-autoscaling/goal.md
index 89ec199..95e0449 100644
--- a/content/recipes/sync-tables-autoscaling/goal.md
+++ b/content/recipes/sync-tables-autoscaling/goal.md
@@ -1,5 +1,3 @@
-Serve lakehouse data through Lakebase Autoscaling Postgres so your applications can query it with sub-10ms latency using a synced table that stays up to date automatically.
-
 When done, you will have:
 
 - A synced table in Unity Catalog tracking the replication pipeline
diff --git a/content/recipes/sync-tables-autoscaling/prerequisites.md b/content/recipes/sync-tables-autoscaling/prerequisites.md
index 709ff3c..b0b3346 100644
--- a/content/recipes/sync-tables-autoscaling/prerequisites.md
+++ b/content/recipes/sync-tables-autoscaling/prerequisites.md
@@ -1,6 +1,5 @@
 This template creates a synced table that mirrors a Unity Catalog table into Lakebase Postgres. Verify these Databricks workspace features are enabled before starting.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **Lakebase Autoscaling available.** Run `databricks postgres list-projects --profile <PROFILE>` and confirm your Autoscaling project is listed. A `not enabled` error means Lakebase is not available to this identity.
 - **Project created via the `/database/` API (not the older `/postgres/` API).** Programmatic synced-table creation via `databricks database create-synced-database-table` only works on projects created through the newer `/database/` API. If your Autoscaling project was created via the older `/postgres/` endpoint, the CLI path in Step 1 is not available yet and you must create synced tables through the Databricks UI (**Catalog** → source table → **Create synced table**). This gap is expected to close in a future release.
 - **Unity Catalog source table with a primary key.** Run `databricks tables get <CATALOG>.<SCHEMA>.<SOURCE_TABLE> --profile <PROFILE>` and confirm at least one column is declared as the table's primary key. Synced tables reject sources without a PK.
diff --git a/content/recipes/unity-catalog-setup/content.md b/content/recipes/unity-catalog-setup/content.md
deleted file mode 100644
index a7bfb94..0000000
--- a/content/recipes/unity-catalog-setup/content.md
+++ /dev/null
@@ -1,133 +0,0 @@
-## Set Up Unity Catalog with External Storage
-
-Create a Unity Catalog catalog backed by an external S3 bucket. For most use cases, the default metastore-managed storage works fine and requires no extra setup (just `databricks catalogs create <CATALOG_NAME>`). Use this template when you specifically need external storage.
-
-> **Note:** Sync Tables (syncing data from the lakehouse back to Lakebase) currently requires the source Unity Catalog catalog to use external storage. Default managed storage does not work with synced tables yet. If you plan to sync lakehouse data back to Lakebase, follow this template. This requirement is expected to be removed in a future release.
-
-### When to use this
-
-- You plan to use Sync Tables to sync lakehouse data back to Lakebase (external storage is currently required for this)
-- You want to control the S3 bucket location, encryption, and lifecycle policies
-- You need cross-account or cross-workspace access to the underlying data
-
-### 1. Create an IAM role for the storage credential
-
-Create an IAM role in AWS that grants Databricks access to your S3 bucket. The trust policy must allow the Databricks account to assume the role.
-
-Minimal IAM policy for the role:
-
-```json
-{
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Effect": "Allow",
-      "Action": [
-        "s3:GetObject",
-        "s3:PutObject",
-        "s3:DeleteObject",
-        "s3:ListBucket",
-        "s3:GetBucketLocation"
-      ],
-      "Resource": ["arn:aws:s3:::<BUCKET_NAME>", "arn:aws:s3:::<BUCKET_NAME>/*"]
-    }
-  ]
-}
-```
-
-Note the IAM role ARN (e.g., `arn:aws:iam::<ACCOUNT_ID>:role/<ROLE_NAME>`).
-
-### 2. Create a storage credential
-
-Register the IAM role as a storage credential in Unity Catalog:
-
-```bash
-databricks storage-credentials create <CREDENTIAL_NAME> \
-  --json '{
-    "aws_iam_role": {
-      "role_arn": "arn:aws:iam::<ACCOUNT_ID>:role/<ROLE_NAME>"
-    }
-  }' --profile <PROFILE>
-```
-
-Verify:
-
-```bash
-databricks storage-credentials get <CREDENTIAL_NAME> --profile <PROFILE>
-```
-
-### 3. Create an external location
-
-Map the S3 bucket path to the storage credential:
-
-```bash
-databricks external-locations create <LOCATION_NAME> \
-  s3://<BUCKET_NAME>/<PREFIX> \
-  <CREDENTIAL_NAME> \
-  --comment "External storage for analytics catalog" \
-  --profile <PROFILE>
-```
-
-Verify:
-
-```bash
-databricks external-locations get <LOCATION_NAME> --profile <PROFILE>
-```
-
-### 4. Create a catalog with external storage
-
-Create the catalog and point its managed storage to the external location:
-
-```bash
-databricks catalogs create <CATALOG_NAME> \
-  --storage-root s3://<BUCKET_NAME>/<PREFIX> \
-  --comment "Catalog for operational and analytics data" \
-  --profile <PROFILE>
-```
-
-All managed tables created in this catalog store their data in the specified S3 path instead of the metastore default.
-
-Verify:
-
-```bash
-databricks catalogs get <CATALOG_NAME> --profile <PROFILE>
-```
-
-### 5. Create a schema
-
-Create a schema within the catalog for your tables:
-
-```bash
-databricks schemas create <SCHEMA_NAME> <CATALOG_NAME> \
-  --comment "Schema for lakehouse tables" \
-  --profile <PROFILE>
-```
-
-Verify:
-
-```bash
-databricks schemas list <CATALOG_NAME> --profile <PROFILE>
-```
-
-### What you end up with
-
-- A **storage credential** linked to your IAM role for S3 access
-- An **external location** mapping an S3 path to the credential
-- A **Unity Catalog catalog** storing managed table data in your S3 bucket
-- A **schema** ready for tables from Lakebase Change Data Feed, Lakehouse Sync, or Lakeflow Pipelines
-
-### Troubleshooting
-
-| Issue                                          | Fix                                                               |
-| ---------------------------------------------- | ----------------------------------------------------------------- |
-| `PERMISSION_DENIED` on credential creation     | Confirm you have `CREATE STORAGE CREDENTIAL` on the metastore     |
-| `ACCESS_DENIED` on S3 during validation        | Verify the IAM role trust policy allows Databricks to assume it   |
-| Bucket not found                               | Confirm the bucket exists in the same AWS region as the workspace |
-| Catalog creation fails with storage root error | Verify the external location covers the specified S3 path         |
-
-#### References
-
-- [Create a storage credential and external location for S3](https://docs.databricks.com/aws/en/connect/unity-catalog/cloud-storage/s3/s3-external-location-manual)
-- [Create catalogs](https://docs.databricks.com/aws/en/catalogs/create-catalog.html)
-- [External locations CLI](https://docs.databricks.com/aws/en/dev-tools/cli/reference/external-locations-commands)
-- [Storage credentials CLI](https://docs.databricks.com/aws/en/dev-tools/cli/reference/storage-credentials-commands)
diff --git a/content/recipes/unity-catalog-setup/goal.md b/content/recipes/unity-catalog-setup/goal.md
index e946594..2cfb9de 100644
--- a/content/recipes/unity-catalog-setup/goal.md
+++ b/content/recipes/unity-catalog-setup/goal.md
@@ -1,5 +1,3 @@
-Create a Unity Catalog catalog backed by an external S3 bucket for scenarios that require custom storage control.
-
 When done, you will have:
 
 - An IAM role granting Databricks access to your S3 bucket
diff --git a/content/recipes/unity-catalog-setup/prerequisites.md b/content/recipes/unity-catalog-setup/prerequisites.md
index 3319d2f..6160e58 100644
--- a/content/recipes/unity-catalog-setup/prerequisites.md
+++ b/content/recipes/unity-catalog-setup/prerequisites.md
@@ -1,6 +1,5 @@
 This template creates a Unity Catalog catalog backed by an external S3 bucket and requires AWS-specific privileges both in Databricks and in AWS IAM.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **AWS workspace.** This template uses S3 and IAM; it does not apply to Azure or GCP workspaces. Confirm your workspace host is `*.cloud.databricks.com`.
 - **Unity Catalog enabled on the workspace.** Run `databricks catalogs list --profile <PROFILE>` and confirm the command succeeds (the system catalogs `main` and `system` should appear). A `not enabled` error means the workspace is not attached to a Unity Catalog metastore.
 - **Metastore privileges to create credentials and catalogs.** You need `CREATE STORAGE CREDENTIAL`, `CREATE EXTERNAL LOCATION`, and `CREATE_CATALOG` on the metastore. If any CLI call in this template returns `PERMISSION_DENIED`, ask your metastore admin to grant the missing privilege.
diff --git a/content/recipes/volume-file-upload/content.md b/content/recipes/volume-file-upload/content.md
deleted file mode 100644
index 7f326d1..0000000
--- a/content/recipes/volume-file-upload/content.md
+++ /dev/null
@@ -1,577 +0,0 @@
-## Volume File Manager
-
-Add file upload, browsing, download, delete, file type validation, and CSV row preview to your Databricks app using Unity Catalog Volumes. The `files` plugin registers all file management HTTP routes automatically. No custom server routes needed.
-
-### 1. Create a Unity Catalog Volume
-
-Create a managed Volume to store uploaded files:
-
-```bash
-databricks volumes create <catalog> <schema> <volume-name> MANAGED \
-  --profile <PROFILE>
-```
-
-Note the full Volume path: `/Volumes/<catalog>/<schema>/<volume-name>`.
-
-### 2. New app: scaffold with the Files feature
-
-```bash
-databricks apps init \
-  --name <app-name> \
-  --version latest \
-  --features=files \
-  --set 'files.files.path=/Volumes/<catalog>/<schema>/<volume-name>' \
-  --run none --profile <PROFILE>
-```
-
-The CLI maps `files.files.path` to `DATABRICKS_VOLUME_FILES` and configures a volume named `files`. It also scaffolds `client/src/pages/files/FilesPage.tsx` and wires the route in `App.tsx` automatically. No manual page creation needed.
-
-After init, install dependencies:
-
-```bash
-cd <app-name>
-npm install
-```
-
-Skip to step 5.
-
-### 3. Existing app: add Files manually
-
-Apply the following changes to an existing scaffolded AppKit app.
-
-#### Add `files` to server plugins
-
-In `server/server.ts`, add `files` to the import and plugins array:
-
-```typescript
-import { createApp, server, files } from "@databricks/appkit";
-
-createApp({
-  plugins: [server(), files()],
-}).catch(console.error);
-```
-
-The `files()` plugin auto-discovers all `DATABRICKS_VOLUME_*` environment variables and registers each as a named volume. The env var suffix (lowercased) becomes the volume key used in all API routes: `DATABRICKS_VOLUME_FILES` → volume key `files`.
-
-To limit upload size, pass a config:
-
-```typescript
-files({
-  volumes: {
-    files: { maxUploadSize: 100_000_000 }, // 100 MB
-  },
-});
-```
-
-#### Add environment variable
-
-Add to `.env` for local development:
-
-```bash
-DATABRICKS_VOLUME_FILES=/Volumes/<catalog>/<schema>/<volume-name>
-```
-
-#### Update `databricks.yml`
-
-Add the volume variables, resource, and target values. The resource uses `uc_securable`. Note that `securable_full_name` is the Unity Catalog three-part name (`<catalog>.<schema>.<volume-name>`), not the `/Volumes/...` path. `user_api_scopes` is required for on-behalf-of (OBO) token access to work in production.
-
-```yaml
-variables:
-  files_path:
-    description: Volume path for file storage (e.g. /Volumes/catalog/schema/volume_name)
-  files_id:
-    description: Unity Catalog Volume securable full name (e.g. catalog.schema.volume_name)
-
-resources:
-  apps:
-    app:
-      # Add under existing app config
-      user_api_scopes:
-        - files.files
-      resources:
-        - name: files
-          uc_securable:
-            securable_full_name: ${var.files_id}
-            securable_type: VOLUME
-            permission: WRITE_VOLUME
-
-targets:
-  default:
-    variables:
-      files_path: /Volumes/<catalog>/<schema>/<volume-name>
-      files_id: <catalog>.<schema>.<volume-name>
-```
-
-#### Update `app.yaml`
-
-Expose the volume path to the running app:
-
-```yaml
-command: ["npm", "run", "start"]
-env:
-  - name: DATABRICKS_VOLUME_FILES
-    valueFrom: files
-```
-
-### 4. Create the file manager page
-
-The `files` plugin auto-registers HTTP routes at `/api/files/files/...` for the volume key `files`:
-
-| Method   | Path                                    | Description                    |
-| -------- | --------------------------------------- | ------------------------------ |
-| `GET`    | `/api/files/files/list?path=<dir>`      | List directory entries         |
-| `GET`    | `/api/files/files/preview?path=<file>`  | File metadata + text preview   |
-| `GET`    | `/api/files/files/download?path=<file>` | Download (attachment)          |
-| `GET`    | `/api/files/files/raw?path=<file>`      | Serve inline (safe types only) |
-| `POST`   | `/api/files/files/upload?path=<file>`   | Upload raw body                |
-| `DELETE` | `/api/files/files?path=<file>`          | Delete file                    |
-
-#### Create `client/src/pages/files/FilesPage.tsx`
-
-File browser with upload, folder creation, download, delete, and file preview. Uses `AbortController` to cancel stale list and preview requests. Entries are sorted directories-first, then alphabetically. `resolveEntryPath` constructs the full path from `currentPath + entry.name`. Do not use `entry.path` directly, as it may not be set by the API.
-
-```tsx
-import type { DirectoryEntry, FilePreview } from "@databricks/appkit-ui/react";
-import {
-  Button,
-  DirectoryList,
-  FileBreadcrumb,
-  FilePreviewPanel,
-  NewFolderInput,
-} from "@databricks/appkit-ui/react";
-import { FolderPlus, Loader2, Upload } from "lucide-react";
-import {
-  type RefObject,
-  useCallback,
-  useEffect,
-  useRef,
-  useState,
-} from "react";
-
-function useAbortController(): RefObject<AbortController | null> {
-  const ref = useRef<AbortController | null>(null);
-  return ref;
-}
-
-function nextSignal(ref: RefObject<AbortController | null>): AbortSignal {
-  ref.current?.abort();
-  ref.current = new AbortController();
-  return ref.current.signal;
-}
-
-export function FilesPage() {
-  const [volumes, setVolumes] = useState<string[]>([]);
-  const [volumeKey, setVolumeKey] = useState<string>(
-    () => localStorage.getItem("appkit:files:volumeKey") ?? "",
-  );
-  const [currentPath, setCurrentPath] = useState<string>("");
-  const [entries, setEntries] = useState<DirectoryEntry[]>([]);
-  const [loading, setLoading] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-  const [selectedFile, setSelectedFile] = useState<string | null>(null);
-  const [preview, setPreview] = useState<FilePreview | null>(null);
-  const [previewLoading, setPreviewLoading] = useState(false);
-  const [uploading, setUploading] = useState(false);
-  const [deleting, setDeleting] = useState(false);
-  const [creatingDir, setCreatingDir] = useState(false);
-  const [newDirName, setNewDirName] = useState("");
-  const [showNewDirInput, setShowNewDirInput] = useState(false);
-  const fileInputRef = useRef<HTMLInputElement>(null);
-  const listAbort = useAbortController();
-  const previewAbort = useAbortController();
-
-  const normalize = (p: string) => p.replace(/\/+$/, "");
-  const isAtRoot = !currentPath;
-
-  const apiUrl = useCallback(
-    (action: string, params?: Record<string, string>) => {
-      const base = `/api/files/${volumeKey}/${action}`;
-      if (!params) return base;
-      const qs = new URLSearchParams(params).toString();
-      return `${base}?${qs}`;
-    },
-    [volumeKey],
-  );
-
-  const loadDirectory = useCallback(
-    async (path?: string) => {
-      if (!volumeKey) return;
-      setLoading(true);
-      setError(null);
-      setSelectedFile(null);
-      setPreview(null);
-
-      try {
-        const signal = nextSignal(listAbort);
-        const url = path ? apiUrl("list", { path }) : apiUrl("list");
-        const response = await fetch(url, { signal });
-
-        if (!response.ok) {
-          const data = await response.json().catch(() => ({}));
-          throw new Error(
-            data.error ?? `HTTP ${response.status}: ${response.statusText}`,
-          );
-        }
-
-        const data: DirectoryEntry[] = await response.json();
-        data.sort((a, b) => {
-          if (a.is_directory && !b.is_directory) return -1;
-          if (!a.is_directory && b.is_directory) return 1;
-          return (a.name ?? "").localeCompare(b.name ?? "");
-        });
-        setEntries(data);
-        setCurrentPath(path ?? "");
-      } catch (err) {
-        if (err instanceof DOMException && err.name === "AbortError") return;
-        setError(err instanceof Error ? err.message : String(err));
-        setEntries([]);
-      } finally {
-        setLoading(false);
-      }
-    },
-    [volumeKey, apiUrl, listAbort],
-  );
-
-  const loadPreview = useCallback(
-    async (filePath: string) => {
-      setPreviewLoading(true);
-      setPreview(null);
-
-      try {
-        const signal = nextSignal(previewAbort);
-        const response = await fetch(apiUrl("preview", { path: filePath }), {
-          signal,
-        });
-
-        if (!response.ok) {
-          const data = await response.json().catch(() => ({}));
-          throw new Error(data.error ?? `HTTP ${response.status}`);
-        }
-
-        const data = await response.json();
-        setPreview(data);
-      } catch (err) {
-        if (err instanceof DOMException && err.name === "AbortError") return;
-        setPreview(null);
-      } finally {
-        setPreviewLoading(false);
-      }
-    },
-    [apiUrl, previewAbort],
-  );
-
-  useEffect(() => {
-    fetch("/api/files/volumes")
-      .then((res) => res.json())
-      .then((data: { volumes: string[] }) => {
-        const list = data.volumes ?? [];
-        setVolumes(list);
-        if (!volumeKey || !list.includes(volumeKey)) {
-          const first = list[0];
-          if (first) {
-            setVolumeKey(first);
-            localStorage.setItem("appkit:files:volumeKey", first);
-          }
-        }
-      })
-      .catch(() => {});
-  }, [volumeKey]);
-
-  useEffect(() => {
-    if (volumeKey) {
-      loadDirectory();
-    }
-  }, [volumeKey, loadDirectory]);
-
-  const resolveEntryPath = (entry: DirectoryEntry) => {
-    const name = entry.name ?? "";
-    return currentPath ? `${currentPath}/${name}` : name;
-  };
-
-  const handleEntryClick = (entry: DirectoryEntry) => {
-    const entryPath = resolveEntryPath(entry);
-    if (entry.is_directory) {
-      loadDirectory(entryPath);
-    } else {
-      setSelectedFile(entryPath);
-      loadPreview(entryPath);
-    }
-  };
-
-  const navigateToParent = () => {
-    if (isAtRoot) return;
-    const segments = currentPath.split("/").filter(Boolean);
-    segments.pop();
-    const parentPath = segments.join("/");
-    loadDirectory(parentPath || undefined);
-  };
-
-  const allSegments = normalize(currentPath).split("/").filter(Boolean);
-
-  const navigateToBreadcrumb = (index: number) => {
-    const targetPath = allSegments.slice(0, index + 1).join("/");
-    loadDirectory(targetPath);
-  };
-
-  const MAX_UPLOAD_SIZE = 5 * 1024 * 1024 * 1024; // 5 GB
-
-  const handleUpload = async (e: React.ChangeEvent<HTMLInputElement>) => {
-    const file = e.target.files?.[0];
-    if (!file) return;
-
-    if (file.size > MAX_UPLOAD_SIZE) {
-      setError(
-        `File "${file.name}" is too large (${(file.size / 1024 / 1024).toFixed(1)} MB). Maximum upload size is ${MAX_UPLOAD_SIZE / 1024 / 1024 / 1024} GB.`,
-      );
-      if (fileInputRef.current) fileInputRef.current.value = "";
-      return;
-    }
-
-    setUploading(true);
-    try {
-      const uploadPath = currentPath
-        ? `${currentPath}/${file.name}`
-        : file.name;
-      const response = await fetch(apiUrl("upload", { path: uploadPath }), {
-        method: "POST",
-        body: file,
-      });
-
-      if (!response.ok) {
-        const data = await response.json().catch(() => ({}));
-        throw new Error(data.error ?? `Upload failed (${response.status})`);
-      }
-
-      await loadDirectory(currentPath || undefined);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : String(err));
-    } finally {
-      setUploading(false);
-      if (fileInputRef.current) {
-        fileInputRef.current.value = "";
-      }
-    }
-  };
-
-  const handleDelete = async () => {
-    if (!selectedFile) return;
-
-    const fileName = selectedFile.split("/").pop();
-    if (!window.confirm(`Delete "${fileName}"?`)) return;
-
-    setDeleting(true);
-    try {
-      const response = await fetch(
-        `/api/files/${volumeKey}?path=${encodeURIComponent(selectedFile)}`,
-        { method: "DELETE" },
-      );
-
-      if (!response.ok) {
-        const data = await response.json().catch(() => ({}));
-        throw new Error(data.error ?? `Delete failed (${response.status})`);
-      }
-
-      setSelectedFile(null);
-      setPreview(null);
-      await loadDirectory(currentPath || undefined);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : String(err));
-    } finally {
-      setDeleting(false);
-    }
-  };
-
-  const handleCreateDirectory = async () => {
-    const name = newDirName.trim();
-    if (!name) return;
-
-    setCreatingDir(true);
-    try {
-      const dirPath = currentPath ? `${currentPath}/${name}` : name;
-      const response = await fetch(apiUrl("mkdir"), {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ path: dirPath }),
-      });
-
-      if (!response.ok) {
-        const data = await response.json().catch(() => ({}));
-        throw new Error(
-          data.error ?? `Create directory failed (${response.status})`,
-        );
-      }
-
-      setShowNewDirInput(false);
-      setNewDirName("");
-      await loadDirectory(currentPath || undefined);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : String(err));
-    } finally {
-      setCreatingDir(false);
-    }
-  };
-
-  return (
-    <div className="space-y-6 w-full max-w-7xl mx-auto">
-      <div>
-        <h2 className="text-2xl font-bold text-foreground">Files</h2>
-        <p className="text-sm text-muted-foreground mt-1">
-          Browse and manage files in Databricks Volumes.
-        </p>
-      </div>
-
-      <div className="flex items-center justify-between">
-        <div className="flex items-center gap-3">
-          {volumes.length > 1 && (
-            <select
-              value={volumeKey}
-              onChange={(e) => {
-                const v = e.target.value;
-                setVolumeKey(v);
-                localStorage.setItem("appkit:files:volumeKey", v);
-                setCurrentPath("");
-                setEntries([]);
-                setSelectedFile(null);
-                setPreview(null);
-              }}
-              className="rounded-md border border-input bg-background px-3 py-1.5 text-sm"
-            >
-              {volumes.map((v) => (
-                <option key={v} value={v}>
-                  {v}
-                </option>
-              ))}
-            </select>
-          )}
-          <FileBreadcrumb
-            rootLabel={volumeKey || "Root"}
-            segments={allSegments}
-            onNavigateToRoot={() => loadDirectory()}
-            onNavigateToSegment={navigateToBreadcrumb}
-          />
-        </div>
-
-        <div className="flex items-center gap-2">
-          <Button
-            variant="outline"
-            size="sm"
-            onClick={() => setShowNewDirInput(true)}
-          >
-            <FolderPlus className="h-4 w-4 mr-2" />
-            New Folder
-          </Button>
-          <input
-            ref={fileInputRef}
-            type="file"
-            className="hidden"
-            onChange={handleUpload}
-          />
-          <Button
-            variant="outline"
-            size="sm"
-            disabled={uploading}
-            onClick={() => fileInputRef.current?.click()}
-          >
-            {uploading ? (
-              <Loader2 className="h-4 w-4 mr-2 animate-spin" />
-            ) : (
-              <Upload className="h-4 w-4 mr-2" />
-            )}
-            {uploading ? "Uploading..." : "Upload"}
-          </Button>
-        </div>
-      </div>
-
-      <div className="flex gap-6">
-        <DirectoryList
-          className="flex-2 min-w-0"
-          entries={entries}
-          loading={loading}
-          error={error}
-          onEntryClick={handleEntryClick}
-          onNavigateToParent={navigateToParent}
-          onRetry={() => loadDirectory(currentPath || undefined)}
-          isAtRoot={isAtRoot}
-          selectedPath={selectedFile}
-          resolveEntryPath={resolveEntryPath}
-          hasCurrentPath={!!currentPath}
-          headerContent={
-            showNewDirInput ? (
-              <NewFolderInput
-                value={newDirName}
-                onChange={setNewDirName}
-                onCreate={handleCreateDirectory}
-                onCancel={() => {
-                  setShowNewDirInput(false);
-                  setNewDirName("");
-                }}
-                creating={creatingDir}
-              />
-            ) : undefined
-          }
-        />
-
-        <FilePreviewPanel
-          className="flex-1 min-w-0"
-          selectedFile={selectedFile}
-          preview={preview}
-          previewLoading={previewLoading}
-          onDownload={(path) =>
-            window.open(apiUrl("download", { path }), "_blank")
-          }
-          onDelete={handleDelete}
-          deleting={deleting}
-          imagePreviewSrc={(p) => apiUrl("raw", { path: p })}
-        />
-      </div>
-    </div>
-  );
-}
-```
-
-#### Update `client/src/App.tsx`
-
-Add the import, nav link, and route:
-
-```tsx
-// Add import at top
-import { FilesPage } from './pages/files/FilesPage';
-
-// Add nav link inside the <nav> element
-<NavLink to="/files" className={navLinkClass}>
-  Files
-</NavLink>
-
-// Add route in the router children array
-{ path: '/files', element: <FilesPage /> },
-```
-
-### 5. Deploy and test
-
-Validate before deploying to catch type errors and run smoke tests:
-
-```bash
-databricks apps validate --profile <PROFILE>
-databricks apps deploy --profile <PROFILE>
-```
-
-Open the app URL while signed in to Databricks, navigate to the Files page, and verify:
-
-1. Upload a `.csv` file. It appears in the directory list.
-2. Click the file. The preview panel shows metadata and the CSV row table renders below it.
-3. Upload a file with a disallowed extension. The error message appears without uploading.
-4. Download and delete a file. The list refreshes correctly.
-
-Check status and logs if the app does not start:
-
-```bash
-databricks apps get <app-name> --profile <PROFILE>
-databricks apps logs <app-name> --profile <PROFILE>
-```
-
-#### References
-
-- [Files plugin docs](/docs/appkit/v0/plugins/files)
-- [Unity Catalog Volumes](https://docs.databricks.com/en/connect/unity-catalog/volumes.html)
-- [DirectoryList component](/docs/appkit/v0/api/appkit-ui/files/DirectoryList)
-- [FilePreviewPanel component](/docs/appkit/v0/api/appkit-ui/files/FilePreviewPanel)
diff --git a/content/recipes/volume-file-upload/goal.md b/content/recipes/volume-file-upload/goal.md
index b340426..3be9aea 100644
--- a/content/recipes/volume-file-upload/goal.md
+++ b/content/recipes/volume-file-upload/goal.md
@@ -1,5 +1,3 @@
-Add file upload, browsing, download, delete, file type validation, and CSV row preview to your Databricks App using Unity Catalog Volumes.
-
 When done, you will have:
 
 - A Unity Catalog Volume configured as file storage
diff --git a/content/recipes/volume-file-upload/prerequisites.md b/content/recipes/volume-file-upload/prerequisites.md
index 630842c..b5a9593 100644
--- a/content/recipes/volume-file-upload/prerequisites.md
+++ b/content/recipes/volume-file-upload/prerequisites.md
@@ -1,5 +1,4 @@
 Verify these Databricks workspace features are enabled before starting. If any check fails, ask your workspace admin to enable the feature.
 
-- **Databricks CLI authenticated.** Run `databricks auth profiles` and confirm at least one profile shows `Valid: YES`. If none do, authenticate with `databricks auth login --host <workspace-url> --profile <PROFILE>`.
 - **Unity Catalog enabled with access to a catalog and schema.** Run `databricks catalogs list --profile <PROFILE>` and confirm at least one writable catalog is listed. You also need `USE_CATALOG` on the catalog and `USE_SCHEMA` + `CREATE_VOLUME` on the schema where the template creates the managed Volume. A `PERMISSION_DENIED` error on `databricks volumes create` in Step 1 means one of those grants is missing.
 - **Databricks Apps enabled.** Run `databricks apps list --profile <PROFILE>` and confirm the command succeeds (an empty list is fine). The template deploys an AppKit app that reads and writes through the `files` plugin.
diff --git a/plugins/content-entries.ts b/plugins/content-entries.ts
index 89662b0..e7d18c4 100644
--- a/plugins/content-entries.ts
+++ b/plugins/content-entries.ts
@@ -50,46 +50,22 @@ function createFolderRouteModuleSource(
   sections: ContentSections,
 ): string {
   const section = entryType === "recipe" ? "recipes" : "examples";
-  const hasGoal = sections.goal !== undefined;
   const hasPrereqs = sections.prerequisites !== undefined;
-  const hasDeploy = sections.deployment !== undefined;
 
-  const imports: string[] = [];
-  if (hasGoal) {
-    imports.push(
-      `import Goal from "@site/content/${section}/${slug}/goal.md";`,
-    );
-  }
-  if (sections.content !== undefined) {
-    imports.push(
-      `import Content from "@site/content/${section}/${slug}/content.md";`,
-    );
-  }
+  const imports: string[] = [
+    `import Goal from "@site/content/${section}/${slug}/goal.md";`,
+  ];
   if (hasPrereqs) {
     imports.push(
       `import Prerequisites from "@site/content/${section}/${slug}/prerequisites.md";`,
     );
   }
-  if (hasDeploy) {
-    imports.push(
-      `import Deployment from "@site/content/${section}/${slug}/deployment.md";`,
-    );
-  }
 
   const prereqsBlock = hasPrereqs
     ? '      <h2 id="prerequisites">Prerequisites</h2>\n      <Prerequisites />'
     : null;
-  const deployBlock = hasDeploy
-    ? '      <h2 id="deployment">Deployment</h2>\n      <Deployment />'
-    : null;
-
-  const goalBlock = hasGoal ? "      <Goal />" : null;
-  const contentBlock =
-    sections.content !== undefined ? "      <Content />" : null;
 
-  const children = [goalBlock, prereqsBlock, contentBlock, deployBlock]
-    .filter(Boolean)
-    .join("\n");
+  const children = ["      <Goal />", prereqsBlock].filter(Boolean).join("\n");
 
   if (entryType === "recipe") {
     return `import type { ReactNode } from "react";
@@ -245,13 +221,16 @@ export default function contentEntriesPlugin(
       });
 
       for (const slug of publishedSlugs) {
+        const sections = sectionsBySlug[slug];
+        if (folderSection && !sections) {
+          throw new Error(
+            `Missing content sections for ${options.entryType} "${slug}"`,
+          );
+        }
+
         const source =
           options.entryType === "recipe" || options.entryType === "example"
-            ? createFolderRouteModuleSource(
-                options.entryType,
-                slug,
-                sectionsBySlug[slug],
-              )
+            ? createFolderRouteModuleSource(options.entryType, slug, sections)
             : createSolutionRouteModuleSource(slug);
 
         const modulePath = await createData(
diff --git a/scripts/validate-content.mjs b/scripts/validate-content.mjs
index a6a59d5..fdce1de 100644
--- a/scripts/validate-content.mjs
+++ b/scripts/validate-content.mjs
@@ -11,14 +11,9 @@ if (!existsSync(resolve(ROOT, "content"))) {
   process.exit(1);
 }
 
-const RESOURCE_ALLOWED_FILES = new Set([
-  "goal.md",
-  "content.md",
-  "prerequisites.md",
-  "deployment.md",
-]);
+const RESOURCE_ALLOWED_FILES = new Set(["goal.md", "prerequisites.md"]);
 /** A folder must have at least one of these to be published. */
-const RESOURCE_REQUIRED_FILES = ["goal.md", "content.md"];
+const RESOURCE_REQUIRED_FILES = ["goal.md"];
 const RESOURCE_SECTIONS = /** @type {const} */ (["recipes", "examples"]);
 
 const COOKBOOK_ALLOWED_FILES = new Set(["goal.md", "intro.md"]);
@@ -86,6 +81,15 @@ function validateContentFolder({
         `${sectionPath}/${entry}/ is missing a required file. Need at least one of: ${requiredFiles.join(", ")}.`,
       );
     }
+
+    if (files.includes("goal.md")) {
+      const goalContent = readFileSync(resolve(entryPath, "goal.md"), "utf-8");
+      if (!goalContent.trim()) {
+        errors.push(
+          `${sectionPath}/${entry}/goal.md is empty or whitespace-only. Add a goal description.`,
+        );
+      }
+    }
   }
 }
 
@@ -95,8 +99,8 @@ for (const section of RESOURCE_SECTIONS) {
     sectionDir: resolve(ROOT, "content", section),
     allowedFiles: RESOURCE_ALLOWED_FILES,
     requiredFiles: RESOURCE_REQUIRED_FILES,
-    emptyHint: "Add goal.md or content.md.",
-    flatHint: `Flat files are not allowed. Move to content/${section}/<slug>/content.md.`,
+    emptyHint: "Add goal.md.",
+    flatHint: `Flat files are not allowed. Move to content/${section}/<slug>/goal.md.`,
   });
 }
 
diff --git a/src/components/agent-usage-card.tsx b/src/components/agent-usage-card.tsx
new file mode 100644
index 0000000..8ab2caa
--- /dev/null
+++ b/src/components/agent-usage-card.tsx
@@ -0,0 +1,45 @@
+import type { ReactNode } from "react";
+import { Bot } from "lucide-react";
+import {
+  CopyPromptButton,
+  type CopyPromptButtonProps,
+} from "@/components/copy-prompt-button";
+
+type AgentUsageCardProps = Omit<CopyPromptButtonProps, "className" | "label">;
+
+export function AgentUsageCard(props: AgentUsageCardProps): ReactNode {
+  return (
+    <div className="rounded-lg border border-border/80 bg-card">
+      <div className="border-b border-border/60 px-5 py-3">
+        <p className="flex items-center gap-2 text-base font-semibold text-foreground">
+          <Bot className="h-5 w-5" />
+          Use with your coding agent
+        </p>
+      </div>
+      <div className="flex flex-col gap-3 px-5 py-5">
+        <ol className="space-y-1 text-[13px] leading-relaxed text-muted-foreground">
+          <li>
+            <span className="font-medium text-foreground">1.</span> Copy the
+            prompt below
+          </li>
+          <li>
+            <span className="font-medium text-foreground">2.</span> Paste into
+            Cursor, Claude Code, Codex, or any coding agent
+          </li>
+          <li>
+            <span className="font-medium text-foreground">3.</span> Your agent
+            builds it — asking questions along the way so the result is exactly
+            what you want
+          </li>
+        </ol>
+        <div>
+          <CopyPromptButton
+            {...props}
+            label="Copy prompt"
+            className="h-10 px-6"
+          />
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/src/components/cookbooks/cookbook-detail.tsx b/src/components/cookbooks/cookbook-detail.tsx
index 227cf32..f020afa 100644
--- a/src/components/cookbooks/cookbook-detail.tsx
+++ b/src/components/cookbooks/cookbook-detail.tsx
@@ -2,10 +2,9 @@ import Link from "@docusaurus/Link";
 import useBaseUrl from "@docusaurus/useBaseUrl";
 import Layout from "@theme/Layout";
 import { MDXProvider } from "@mdx-js/react";
-import { useRef, type ReactNode } from "react";
-import { TemplateUsageBanner } from "@/components/template-usage-banner";
+import type { ReactNode } from "react";
+import { AgentUsageCard } from "@/components/agent-usage-card";
 import { RecipePre } from "@/components/cookbooks/recipe-code-block";
-import { RecipeToc } from "@/components/cookbooks/recipe-toc";
 import type { Cookbook } from "@/lib/recipes/recipes";
 import { BaseUrlAnchor } from "@/components/base-url-anchor";
 
@@ -22,7 +21,6 @@ export function CookbookDetail({
   rawMarkdown,
   children,
 }: CookbookDetailProps): ReactNode {
-  const contentRef = useRef<HTMLDivElement>(null);
   const heroImageUrl = useBaseUrl("/img/template-detail-hero.svg");
   const permalink = `/templates/${cookbook.id}`;
 
@@ -30,52 +28,43 @@ export function CookbookDetail({
     <Layout title={cookbook.name} description={cookbook.description}>
       <main>
         <div className="container px-4 py-8 md:py-12">
-          <div className="mx-auto max-w-5xl">
-            <div className="grid grid-cols-1 gap-8 lg:grid-cols-[minmax(0,1fr)_220px]">
-              <div className="min-w-0">
-                <Link
-                  to="/templates"
-                  className="mb-6 inline-flex items-center gap-1.5 text-sm font-medium text-muted-foreground no-underline transition-colors hover:text-foreground"
-                >
-                  <span aria-hidden="true">&larr;</span>
-                  All templates
-                </Link>
+          <div className="mx-auto max-w-3xl">
+            <Link
+              to="/templates"
+              className="mb-6 inline-flex items-center gap-1.5 text-sm font-medium text-muted-foreground no-underline transition-colors hover:text-foreground"
+            >
+              <span aria-hidden="true">&larr;</span>
+              All templates
+            </Link>
 
-                <TemplateUsageBanner
-                  kind="cookbook"
-                  rawMarkdown={rawMarkdown}
-                  title={cookbook.name}
-                  description={cookbook.description}
-                  permalink={permalink}
-                />
-
-                <h1 className="mb-3 text-3xl font-bold tracking-tight text-foreground md:text-4xl">
-                  {cookbook.name}
-                </h1>
-                <p className="mb-8 max-w-2xl text-base leading-relaxed text-muted-foreground">
-                  {cookbook.description}
-                </p>
-
-                <div className="mb-12 overflow-hidden rounded-xl bg-gradient-to-br from-[#0f172a] to-[#1e293b]">
-                  <img
-                    src={heroImageUrl}
-                    alt="Template architecture preview"
-                    className="h-auto w-full object-cover"
-                    loading="lazy"
-                  />
-                </div>
-
-                <div className="recipe-content-card" ref={contentRef}>
-                  <MDXProvider components={recipeComponents}>
-                    <div className="prose-solution">{children}</div>
-                  </MDXProvider>
-                </div>
-              </div>
+            <div className="mb-10">
+              <h1 className="mb-3 text-3xl font-bold tracking-tight text-foreground md:text-4xl">
+                {cookbook.name}
+              </h1>
+              <p className="mb-6 max-w-xl text-base leading-relaxed text-muted-foreground">
+                {cookbook.description}
+              </p>
+              <AgentUsageCard
+                kind="cookbook"
+                rawMarkdown={rawMarkdown}
+                title={cookbook.name}
+                description={cookbook.description}
+                permalink={permalink}
+              />
+            </div>
 
-              <div className="hidden lg:block">
-                <RecipeToc contentRef={contentRef} />
-              </div>
+            <div className="mb-12 overflow-hidden rounded-xl bg-gradient-to-br from-db-navy to-db-navy-light">
+              <img
+                src={heroImageUrl}
+                alt="Template architecture preview"
+                className="h-auto w-full object-cover"
+                loading="lazy"
+              />
             </div>
+
+            <MDXProvider components={recipeComponents}>
+              <div className="prose-solution">{children}</div>
+            </MDXProvider>
           </div>
         </div>
       </main>
diff --git a/src/components/cookbooks/recipe-detail.tsx b/src/components/cookbooks/recipe-detail.tsx
index caaefd8..989b50f 100644
--- a/src/components/cookbooks/recipe-detail.tsx
+++ b/src/components/cookbooks/recipe-detail.tsx
@@ -1,10 +1,10 @@
 import Link from "@docusaurus/Link";
 import Layout from "@theme/Layout";
 import { MDXProvider } from "@mdx-js/react";
-import { useRef, type ReactNode } from "react";
-import { TemplateUsageBanner } from "@/components/template-usage-banner";
+import type { ReactNode } from "react";
+import { AgentUsageCard } from "@/components/agent-usage-card";
+import { Badge } from "@/components/ui/badge";
 import { RecipePre } from "@/components/cookbooks/recipe-code-block";
-import { RecipeToc } from "@/components/cookbooks/recipe-toc";
 import { recipes } from "@/lib/recipes/recipes";
 import { useRawRecipeMarkdown } from "@/lib/use-raw-content-markdown";
 import { BaseUrlAnchor } from "@/components/base-url-anchor";
@@ -20,7 +20,6 @@ export function RecipeDetail({
   recipeId,
   children,
 }: RecipeDetailProps): ReactNode {
-  const contentRef = useRef<HTMLDivElement>(null);
   const recipe = recipes.find((item) => item.id === recipeId);
   const rawMarkdown = useRawRecipeMarkdown(recipeId);
 
@@ -32,44 +31,44 @@ export function RecipeDetail({
     <Layout title={recipe.name} description={recipe.description}>
       <main>
         <div className="container px-4 py-8 md:py-12">
-          <div className="mx-auto max-w-5xl">
-            <div className="grid grid-cols-1 gap-8 lg:grid-cols-[minmax(0,1fr)_220px]">
-              <div className="min-w-0">
-                <Link
-                  to="/templates"
-                  className="mb-6 inline-flex items-center gap-1.5 text-sm font-medium text-muted-foreground no-underline transition-colors hover:text-foreground"
-                >
-                  <span aria-hidden="true">&larr;</span>
-                  All templates
-                </Link>
+          <div className="mx-auto max-w-3xl">
+            <Link
+              to="/templates"
+              className="mb-6 inline-flex items-center gap-1.5 text-sm font-medium text-muted-foreground no-underline transition-colors hover:text-foreground"
+            >
+              <span aria-hidden="true">&larr;</span>
+              All templates
+            </Link>
 
-                <TemplateUsageBanner
-                  kind="recipe"
-                  rawMarkdown={rawMarkdown}
-                  title={recipe.name}
-                  description={recipe.description}
-                  permalink={`/templates/${recipe.id}`}
-                />
-
-                <div className="mb-3 flex flex-wrap items-center gap-3">
-                  <h1 className="text-3xl font-bold tracking-tight text-foreground md:text-4xl">
-                    {recipe.name}
-                  </h1>
-                </div>
-                <p className="mb-8 max-w-2xl text-base leading-relaxed text-muted-foreground">
-                  {recipe.description}
-                </p>
-
-                <div className="recipe-content-card" ref={contentRef}>
-                  <MDXProvider components={recipeComponents}>
-                    <div className="prose-solution">{children}</div>
-                  </MDXProvider>
+            <div className="mb-10">
+              <h1 className="mb-3 text-3xl font-bold tracking-tight text-foreground md:text-4xl">
+                {recipe.name}
+              </h1>
+              <p className="mb-4 max-w-xl text-base leading-relaxed text-muted-foreground">
+                {recipe.description}
+              </p>
+              {recipe.services.length > 0 && (
+                <div className="mb-6 flex flex-wrap gap-2">
+                  {recipe.services.map((service) => (
+                    <Badge key={service} variant="secondary">
+                      {service}
+                    </Badge>
+                  ))}
                 </div>
-              </div>
+              )}
+              <AgentUsageCard
+                kind="recipe"
+                rawMarkdown={rawMarkdown}
+                title={recipe.name}
+                description={recipe.description}
+                permalink={`/templates/${recipe.id}`}
+              />
+            </div>
 
-              <div className="hidden lg:block">
-                <RecipeToc contentRef={contentRef} />
-              </div>
+            <div className="border-t border-border/60 pt-8">
+              <MDXProvider components={recipeComponents}>
+                <div className="prose-solution">{children}</div>
+              </MDXProvider>
             </div>
           </div>
         </div>
diff --git a/src/components/copy-prompt-button.tsx b/src/components/copy-prompt-button.tsx
index 4360d5f..710fa09 100644
--- a/src/components/copy-prompt-button.tsx
+++ b/src/components/copy-prompt-button.tsx
@@ -14,14 +14,18 @@ import {
   type AgentMarkdownInput,
 } from "@/lib/use-agent-markdown";
 
-type CopyPromptButtonProps = AgentMarkdownInput & {
+export type CopyPromptButtonProps = AgentMarkdownInput & {
   disabled?: boolean;
   disabledTooltip?: string;
+  className?: string;
+  label?: string;
 };
 
 export function CopyPromptButton({
   disabled = false,
   disabledTooltip = "select a template to copy",
+  className,
+  label = "Copy prompt",
   ...input
 }: CopyPromptButtonProps) {
   const { buildAIMarkdown, ensureFetched } = useAgentMarkdown(input);
@@ -61,9 +65,9 @@ export function CopyPromptButton({
         <Tooltip>
           <TooltipTrigger asChild>
             <span className="inline-flex">
-              <Button size="sm" disabled>
+              <Button size="sm" className={className} disabled>
                 <Clipboard className="h-4 w-4" />
-                Copy prompt
+                {label}
               </Button>
             </span>
           </TooltipTrigger>
@@ -74,7 +78,12 @@ export function CopyPromptButton({
   }
 
   return (
-    <Button size="sm" onClick={handleCopy} disabled={copyState === "copying"}>
+    <Button
+      size="sm"
+      className={className}
+      onClick={handleCopy}
+      disabled={copyState === "copying"}
+    >
       {copyState === "copying" ? (
         <>
           <LoaderCircle className="h-4 w-4 animate-spin" />
@@ -90,7 +99,7 @@ export function CopyPromptButton({
       ) : (
         <>
           <Clipboard className="h-4 w-4" />
-          Copy prompt
+          {label}
         </>
       )}
     </Button>
diff --git a/src/components/examples/example-detail.tsx b/src/components/examples/example-detail.tsx
index fe4c773..6e7498f 100644
--- a/src/components/examples/example-detail.tsx
+++ b/src/components/examples/example-detail.tsx
@@ -2,9 +2,9 @@ import Link from "@docusaurus/Link";
 import useDocusaurusContext from "@docusaurus/useDocusaurusContext";
 import Layout from "@theme/Layout";
 import { MDXProvider } from "@mdx-js/react";
-import { useRef, type ReactNode } from "react";
+import type { ReactNode } from "react";
 import { Code2, ExternalLink, FolderGit2 } from "lucide-react";
-import { TemplateUsageBanner } from "@/components/template-usage-banner";
+import { AgentUsageCard } from "@/components/agent-usage-card";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
 import {
@@ -15,12 +15,11 @@ import {
   CardTitle,
 } from "@/components/ui/card";
 import { RecipePre } from "@/components/cookbooks/recipe-code-block";
-import { RecipeToc } from "@/components/cookbooks/recipe-toc";
 import {
   buildFullPrompt,
   buildAdditionalMarkdown,
 } from "@/lib/examples/build-example-markdown";
-import type { Example } from "@/lib/recipes/recipes";
+import type { Cookbook, Example, Recipe } from "@/lib/recipes/recipes";
 import { cookbooks, recipes } from "@/lib/recipes/recipes";
 import { useExampleSections } from "@/lib/use-raw-content-markdown";
 import { goalOnly } from "@/lib/content-sections";
@@ -127,20 +126,19 @@ export function ExampleDetail({
 }: ExampleDetailProps): ReactNode {
   const { siteConfig } = useDocusaurusContext();
   const siteUrl = siteUrlFromConfig(siteConfig.url, siteConfig.baseUrl);
-  const contentRef = useRef<HTMLDivElement>(null);
   const permalink = `/templates/${example.id}`;
   const githubUrl = example.templateUrl;
 
-  const sections = useExampleSections(example.id) ?? { content: "" };
+  const sections = useExampleSections(example.id) ?? {};
   const rawMarkdown = goalOnly(sections);
 
   const includedCookbooks = example.cookbookIds
     .map((id) => cookbooks.find((c) => c.id === id))
-    .filter(Boolean);
+    .filter((c): c is Cookbook => c !== undefined);
 
   const includedRecipes = example.recipeIds
     .map((id) => recipes.find((r) => r.id === id))
-    .filter(Boolean);
+    .filter((r): r is Recipe => r !== undefined);
 
   const mdOpts = {
     example,
@@ -156,96 +154,86 @@ export function ExampleDetail({
     <Layout title={example.name} description={example.description}>
       <main>
         <div className="container px-4 py-8 md:py-12">
-          <div className="mx-auto max-w-5xl">
-            <div className="grid grid-cols-1 gap-8 lg:grid-cols-[minmax(0,1fr)_220px]">
-              <div className="min-w-0">
-                <Link
-                  to="/templates"
-                  className="mb-6 inline-flex items-center gap-1.5 text-sm font-medium text-muted-foreground no-underline transition-colors hover:text-foreground"
-                >
-                  <span aria-hidden="true">&larr;</span>
-                  All templates
-                </Link>
+          <div className="mx-auto max-w-3xl">
+            <Link
+              to="/templates"
+              className="mb-6 inline-flex items-center gap-1.5 text-sm font-medium text-muted-foreground no-underline transition-colors hover:text-foreground"
+            >
+              <span aria-hidden="true">&larr;</span>
+              All templates
+            </Link>
+
+            <div className="mb-10">
+              <h1 className="mb-3 text-3xl font-bold tracking-tight text-foreground md:text-4xl">
+                {example.name}
+              </h1>
+              <p className="mb-6 max-w-xl text-base leading-relaxed text-muted-foreground">
+                {example.description}
+              </p>
+              <AgentUsageCard
+                kind="example"
+                rawMarkdown={rawMarkdown}
+                additionalMarkdown={additionalMarkdown}
+                customTemplateBody={fullPrompt}
+                title={example.name}
+                description={example.description}
+                permalink={permalink}
+              />
+            </div>
 
-                <TemplateUsageBanner
-                  kind="example"
-                  rawMarkdown={rawMarkdown}
-                  additionalMarkdown={additionalMarkdown}
-                  customTemplateBody={fullPrompt}
-                  title={example.name}
-                  description={example.description}
-                  permalink={permalink}
+            {example.galleryImages && example.galleryImages.length > 0 ? (
+              <TemplateImageCarousel
+                images={example.galleryImages}
+                exampleName={example.name}
+              />
+            ) : (
+              <div className="relative mb-8 aspect-[16/9] w-full overflow-hidden rounded-xl border border-border/60 bg-muted/30">
+                <TemplatePreviewImage
+                  lightUrl={example.previewImageLightUrl}
+                  darkUrl={example.previewImageDarkUrl}
+                  alt={`${example.name} preview`}
+                  fallback={<FallbackCardArt index={0} />}
                 />
-
-                <h1 className="mb-3 text-3xl font-bold tracking-tight text-foreground md:text-4xl">
-                  {example.name}
-                </h1>
-                <p className="mb-6 max-w-2xl text-base leading-relaxed text-muted-foreground">
-                  {example.description}
+              </div>
+            )}
+
+            <StarterCodeCard templateUrl={example.templateUrl} />
+
+            <MDXProvider components={mdxComponents}>
+              <div className="prose-solution">{children}</div>
+            </MDXProvider>
+
+            {(includedCookbooks.length > 0 || includedRecipes.length > 0) && (
+              <div className="mt-12">
+                <h2 className="mb-2 text-xl font-semibold tracking-tight">
+                  Built on these templates
+                </h2>
+                <p className="mb-6 max-w-2xl text-sm leading-relaxed text-muted-foreground">
+                  This example's codebase and the agent prompt above both build
+                  on top of the templates below. Open one to dive into a
+                  specific technique on its own or apply it to a different
+                  project.
                 </p>
-
-                {example.galleryImages && example.galleryImages.length > 0 ? (
-                  <TemplateImageCarousel
-                    images={example.galleryImages}
-                    exampleName={example.name}
-                  />
-                ) : (
-                  <div className="relative mb-8 aspect-[16/9] w-full overflow-hidden rounded-xl border border-border/60 bg-muted/30">
-                    <TemplatePreviewImage
-                      lightUrl={example.previewImageLightUrl}
-                      darkUrl={example.previewImageDarkUrl}
-                      alt={`${example.name} preview`}
-                      fallback={<FallbackCardArt index={0} />}
+                <div className="grid grid-cols-1 gap-4 sm:grid-cols-2">
+                  {includedCookbooks.map((c) => (
+                    <IncludedTemplateCard
+                      key={c.id}
+                      name={c.name}
+                      description={c.description}
+                      href={`/templates/${c.id}`}
                     />
-                  </div>
-                )}
-
-                <StarterCodeCard templateUrl={example.templateUrl} />
-
-                <div className="recipe-content-card" ref={contentRef}>
-                  <MDXProvider components={mdxComponents}>
-                    <div className="prose-solution">{children}</div>
-                  </MDXProvider>
+                  ))}
+                  {includedRecipes.map((r) => (
+                    <IncludedTemplateCard
+                      key={r.id}
+                      name={r.name}
+                      description={r.description}
+                      href={`/templates/${r.id}`}
+                    />
+                  ))}
                 </div>
-
-                {(includedCookbooks.length > 0 ||
-                  includedRecipes.length > 0) && (
-                  <div className="mt-12">
-                    <h2 className="mb-2 text-xl font-semibold tracking-tight">
-                      Built on these templates
-                    </h2>
-                    <p className="mb-6 max-w-2xl text-sm leading-relaxed text-muted-foreground">
-                      This example's codebase and the agent prompt above both
-                      build on top of the templates below. Open one to dive into
-                      a specific technique on its own or apply it to a different
-                      project.
-                    </p>
-                    <div className="grid grid-cols-1 gap-4 sm:grid-cols-2">
-                      {includedCookbooks.map((c) => (
-                        <IncludedTemplateCard
-                          key={c.id}
-                          name={c.name}
-                          description={c.description}
-                          href={`/templates/${c.id}`}
-                        />
-                      ))}
-                      {includedRecipes.map((r) => (
-                        <IncludedTemplateCard
-                          key={r.id}
-                          name={r.name}
-                          description={r.description}
-                          href={`/templates/${r.id}`}
-                        />
-                      ))}
-                    </div>
-                  </div>
-                )}
               </div>
-
-              <div className="hidden lg:block">
-                <RecipeToc contentRef={contentRef} />
-              </div>
-            </div>
+            )}
           </div>
         </div>
       </main>
diff --git a/src/components/template-usage-banner.tsx b/src/components/template-usage-banner.tsx
deleted file mode 100644
index 4dd547e..0000000
--- a/src/components/template-usage-banner.tsx
+++ /dev/null
@@ -1,91 +0,0 @@
-import type { ComponentProps } from "react";
-import { useCallback, useRef } from "react";
-import { ArrowDown, Bot, BookOpen, Info } from "lucide-react";
-import { Button } from "@/components/ui/button";
-import { CopyPromptButton } from "@/components/copy-prompt-button";
-
-type CopyPromptProps = ComponentProps<typeof CopyPromptButton>;
-
-export function TemplateUsageBanner(copyPromptProps: CopyPromptProps) {
-  const bannerRef = useRef<HTMLDivElement>(null);
-
-  const handleScrollToContent = useCallback(() => {
-    const next = bannerRef.current?.nextElementSibling as HTMLElement | null;
-    if (!next) return;
-    const navbarHeight = 60;
-    const padding = 24;
-    const y =
-      next.getBoundingClientRect().top +
-      window.scrollY -
-      navbarHeight -
-      padding;
-    window.scrollTo({ top: y, behavior: "smooth" });
-  }, []);
-
-  return (
-    <div
-      ref={bannerRef}
-      className="mb-8 rounded-lg border border-border/80 bg-card"
-    >
-      <div className="border-b border-border/60 px-5 py-3">
-        <p className="m-0 flex items-center gap-2 text-base font-semibold text-card-foreground">
-          <Info className="h-5 w-5 text-muted-foreground" />
-          Two ways to use this template
-        </p>
-      </div>
-
-      <div className="relative grid grid-cols-1 sm:grid-cols-[1fr_auto_1fr]">
-        <div className="flex flex-col gap-3 px-5 py-5">
-          <div className="flex items-center gap-2 text-sm font-semibold text-card-foreground">
-            <Bot className="h-4 w-4 text-db-lava" />
-            Use with your coding agent
-          </div>
-          <ol className="m-0 list-none space-y-1 p-0 text-[13px] leading-relaxed text-muted-foreground">
-            <li>
-              <span className="font-medium text-card-foreground">1.</span> Click
-              "Copy prompt" below
-            </li>
-            <li>
-              <span className="font-medium text-card-foreground">2.</span> Paste
-              into Cursor, Claude Code, Codex, or any coding agent
-            </li>
-            <li>
-              <span className="font-medium text-card-foreground">3.</span> Your
-              agent builds the app — it asks questions along the way so the
-              result is exactly what you want
-            </li>
-          </ol>
-          <div className="mt-auto pt-1">
-            <CopyPromptButton {...copyPromptProps} />
-          </div>
-        </div>
-
-        <div className="flex items-stretch justify-center">
-          <div className="flex w-full items-center gap-3 px-5 sm:w-auto sm:flex-col sm:py-5 sm:px-0">
-            <div className="h-px flex-1 bg-border/60 sm:h-auto sm:w-px" />
-            <span className="shrink-0 text-xs font-medium text-muted-foreground">
-              or
-            </span>
-            <div className="h-px flex-1 bg-border/60 sm:h-auto sm:w-px" />
-          </div>
-        </div>
-
-        <div className="flex flex-col gap-3 px-5 py-5">
-          <div className="flex items-center gap-2 text-sm font-semibold text-card-foreground">
-            <BookOpen className="h-4 w-4 text-db-lava" />
-            Read step-by-step
-          </div>
-          <p className="m-0 text-[13px] leading-relaxed text-muted-foreground">
-            Follow the steps below to set things up manually, at your own pace.
-          </p>
-          <div className="mt-auto pt-1">
-            <Button variant="outline" size="sm" onClick={handleScrollToContent}>
-              <ArrowDown className="h-4 w-4" />
-              Read below
-            </Button>
-          </div>
-        </div>
-      </div>
-    </div>
-  );
-}
diff --git a/src/lib/content-markdown.ts b/src/lib/content-markdown.ts
index 6d3976b..8d7d686 100644
--- a/src/lib/content-markdown.ts
+++ b/src/lib/content-markdown.ts
@@ -1,7 +1,6 @@
 import { existsSync, readFileSync, readdirSync, statSync } from "fs";
 import { resolve } from "path";
 import {
-  REQUIRED_CONTENT_SECTION_FILE,
   type ContentSectionFile,
   type ContentSections,
 } from "./content-sections";
@@ -31,7 +30,7 @@ export function hasSolutionSlug(rootDir: string, slug: string): boolean {
 
 /**
  * Recipes and examples live in `content/<section>/<slug>/` folders.
- * A folder is published if it has either goal.md or content.md (or both).
+ * A folder is published if it has goal.md.
  */
 export function getContentSlugs(
   rootDir: string,
@@ -42,10 +41,7 @@ export function getContentSlugs(
     .filter((entry) => {
       const fullPath = resolve(directory, entry);
       if (!statSync(fullPath).isDirectory()) return false;
-      return (
-        existsSync(resolve(fullPath, "goal.md")) ||
-        existsSync(resolve(fullPath, `${REQUIRED_CONTENT_SECTION_FILE}.md`))
-      );
+      return existsSync(resolve(fullPath, "goal.md"));
     })
     .sort();
 }
@@ -111,17 +107,16 @@ export function readCookbookGoal(
   return readFileSync(filePath, "utf-8");
 }
 
-/** Reads all present section files; throws when neither goal.md nor content.md exists. */
+/** Reads all present section files; throws when goal.md is missing. */
 export function readContentSections(
   rootDir: string,
   section: FolderContentSection,
   slug: string,
 ): ContentSections {
   const goal = readContentSection(rootDir, section, slug, "goal");
-  const content = readContentSection(rootDir, section, slug, "content");
-  if (goal === undefined && content === undefined) {
+  if (goal === undefined) {
     throw new Error(
-      `Missing required goal.md or content.md for ${section} "${slug}" at content/${section}/${slug}/`,
+      `Missing required goal.md for ${section} "${slug}" at content/${section}/${slug}/`,
     );
   }
   const prerequisites = readContentSection(
@@ -130,11 +125,7 @@ export function readContentSections(
     slug,
     "prerequisites",
   );
-  const deployment = readContentSection(rootDir, section, slug, "deployment");
-  const sections: ContentSections = {};
-  if (goal !== undefined) sections.goal = goal;
-  if (content !== undefined) sections.content = content;
+  const sections: ContentSections = { goal };
   if (prerequisites !== undefined) sections.prerequisites = prerequisites;
-  if (deployment !== undefined) sections.deployment = deployment;
   return sections;
 }
diff --git a/src/lib/content-sections.ts b/src/lib/content-sections.ts
index ce2f9b1..d2f5a5f 100644
--- a/src/lib/content-sections.ts
+++ b/src/lib/content-sections.ts
@@ -1,42 +1,12 @@
 /** Allowed file names inside each content/<recipes|examples>/<slug>/ folder. */
-const CONTENT_SECTION_FILES = [
-  "goal",
-  "content",
-  "prerequisites",
-  "deployment",
-] as const;
-export type ContentSectionFile = (typeof CONTENT_SECTION_FILES)[number];
-
-/**
- * Legacy constant for backward compat. Slug detection in content-markdown.ts
- * now accepts either goal.md or content.md as the required file.
- */
-export const REQUIRED_CONTENT_SECTION_FILE: ContentSectionFile = "content";
+export type ContentSectionFile = "goal" | "prerequisites";
 
 export type ContentSections = {
   goal?: string;
-  /** Present when content.md exists. Optional because examples may only have goal.md. */
-  content?: string;
   prerequisites?: string;
-  deployment?: string;
 };
 
-/**
- * Returns goal-only content for agent prompts. Falls back to
- * joinContentSections() when no goal.md exists (backward compat
- * during incremental migration).
- */
+/** Returns goal-only content for agent prompts. */
 export function goalOnly(sections: ContentSections): string {
-  if (sections.goal) return sections.goal.trim();
-  return joinContentSections(sections);
-}
-
-/** Joins present sections in display order (prerequisites → content → deployment). */
-export function joinContentSections(sections: ContentSections): string {
-  const parts = [
-    sections.prerequisites,
-    sections.content,
-    sections.deployment,
-  ].filter((part): part is string => Boolean(part && part.trim()));
-  return parts.map((part) => part.trim()).join("\n\n");
+  return sections.goal?.trim() ?? "";
 }
diff --git a/src/lib/cookbook-composition.ts b/src/lib/cookbook-composition.ts
index a4548de..eb9db2c 100644
--- a/src/lib/cookbook-composition.ts
+++ b/src/lib/cookbook-composition.ts
@@ -6,50 +6,23 @@ export type CookbookRecipeInput = {
   sections: ContentSections;
 };
 
-export type CookbookCompositionMode = "agent" | "human";
-
 type CookbookCompositionInput = {
   cookbookName: string;
   cookbookDescription: string;
   goal?: string;
   intro?: string;
   recipes: CookbookRecipeInput[];
-  mode?: CookbookCompositionMode;
 };
 
-/** Strips a leading `## Prerequisites` heading (and any blank line that follows) from a prereqs body. */
-export function stripPrerequisitesHeading(body: string): string {
-  return body.replace(/^\s*##\s+Prerequisites\s*\n+/, "").trim();
-}
-
-function heading(level: number, text: string): string {
-  return `${"#".repeat(level)} ${text}`;
-}
-
-function demoteRecipePrereqs(recipe: CookbookRecipeInput): string | undefined {
-  if (!recipe.sections.prerequisites) return undefined;
-  const body = stripPrerequisitesHeading(recipe.sections.prerequisites);
-  return `${heading(3, recipe.name)}\n\n${body}`;
-}
-
-function wrapRecipeDeployment(recipe: CookbookRecipeInput): string | undefined {
-  if (!recipe.sections.deployment) return undefined;
-  return `${heading(3, recipe.name)}\n\n${recipe.sections.deployment.trim()}`;
-}
-
 /**
  * Composes a cookbook from its constituent recipes.
  *
- * mode="human" (default): intro/goal → combined Prerequisites → all recipe
- * content bodies → optional combined Deployment.
- *
- * mode="agent": cookbook goal/intro → each recipe's goal under a
- * "## Component: <Name>" heading. No prerequisites, content bodies, or deployment.
+ * Cookbook goal/intro → each recipe's goal under a
+ * "## Component: <Name>" heading.
  */
 export function composeCookbookMarkdown(
   input: CookbookCompositionInput,
 ): string {
-  const mode = input.mode ?? "human";
   const introText = input.goal ?? input.intro;
   const { recipes } = input;
   const parts: string[] = [];
@@ -58,39 +31,11 @@ export function composeCookbookMarkdown(
     parts.push(introText.trim());
   }
 
-  if (mode === "agent") {
-    for (const recipe of recipes) {
-      const recipeGoal = goalOnly(recipe.sections);
-      if (recipeGoal.trim()) {
-        parts.push(
-          `${heading(2, `Component: ${recipe.name}`)}\n\n${recipeGoal.trim()}`,
-        );
-      }
+  for (const recipe of recipes) {
+    const recipeGoal = goalOnly(recipe.sections);
+    if (recipeGoal.trim()) {
+      parts.push(`## Component: ${recipe.name}\n\n${recipeGoal.trim()}`);
     }
-    return parts.join("\n\n");
-  }
-
-  const prereqBlocks = recipes
-    .map(demoteRecipePrereqs)
-    .filter((block): block is string => Boolean(block));
-  if (prereqBlocks.length > 0) {
-    parts.push([heading(2, "Prerequisites"), "", ...prereqBlocks].join("\n\n"));
-  }
-
-  const contentBlocks = recipes
-    .map((recipe) => recipe.sections.content?.trim())
-    .filter((block): block is string => Boolean(block));
-  if (contentBlocks.length > 0) {
-    parts.push(contentBlocks.join("\n\n---\n\n"));
-  }
-
-  const deploymentBlocks = recipes
-    .map(wrapRecipeDeployment)
-    .filter((block): block is string => Boolean(block));
-  if (deploymentBlocks.length > 0) {
-    parts.push(
-      [heading(2, "Deployment"), "", ...deploymentBlocks].join("\n\n"),
-    );
   }
 
   return parts.join("\n\n");
diff --git a/src/lib/examples/build-example-markdown.ts b/src/lib/examples/build-example-markdown.ts
index 218bca5..8091f7b 100644
--- a/src/lib/examples/build-example-markdown.ts
+++ b/src/lib/examples/build-example-markdown.ts
@@ -11,8 +11,6 @@ export type ExampleMarkdownOptions = {
   baseUrl: string;
 };
 
-export type ExampleSections = ContentSections;
-
 function isInitCommand(initCommand: string): boolean {
   return initCommand.trimStart().startsWith("databricks apps init");
 }
@@ -70,7 +68,7 @@ export function buildExportGetStartedSection(example: Example): string {
 }
 
 export function buildFullPrompt(
-  opts: ExampleMarkdownOptions & { sections: ExampleSections },
+  opts: ExampleMarkdownOptions & { sections: ContentSections },
 ): string {
   const {
     example,
@@ -80,23 +78,16 @@ export function buildFullPrompt(
     includedRecipes,
     baseUrl,
   } = opts;
-  const hasGoal = Boolean(sections.goal);
   const cliTemplateUrl = example.templateUrl;
   const lines: string[] = [`# ${example.name}`, "", example.description, ""];
 
-  // When goal.md exists, use it as the body and skip prerequisites/content/deployment.
-  // The agent gets the outcome description + scaffold entry point; skills handle implementation.
-  if (hasGoal) {
-    lines.push(sections.goal!.trim(), "");
+  if (sections.goal) {
+    lines.push(sections.goal.trim(), "");
   }
 
   lines.push("## Get started", "");
 
   if (isInitCommand(example.initCommand)) {
-    if (!hasGoal && sections.prerequisites) {
-      lines.push(sections.prerequisites, "");
-    }
-
     lines.push(
       "### Scaffold the project",
       "",
@@ -106,16 +97,9 @@ export function buildFullPrompt(
       example.initCommand,
       "```",
       "",
+      "A **`README.md`** ships inside the scaffolded project. Follow it end to end to configure, run, and deploy the app.",
+      "",
     );
-
-    if (!hasGoal && sections.deployment) {
-      lines.push(sections.deployment, "");
-    } else {
-      lines.push(
-        "A **`README.md`** ships inside the scaffolded project. Follow it end to end to configure, run, and deploy the app.",
-        "",
-      );
-    }
   } else {
     lines.push(
       "### Clone and follow `README.md`",
@@ -137,10 +121,6 @@ export function buildFullPrompt(
     );
   }
 
-  if (!hasGoal && sections.content) {
-    lines.push("", sections.content);
-  }
-
   lines.push("", `## Source Code`, "", `GitHub: ${githubUrl}`);
 
   const includedTemplateLinks = buildIncludedTemplateLinks(
diff --git a/src/lib/use-cookbook-markdown.ts b/src/lib/use-cookbook-markdown.ts
index d680ff8..261754d 100644
--- a/src/lib/use-cookbook-markdown.ts
+++ b/src/lib/use-cookbook-markdown.ts
@@ -38,7 +38,6 @@ export function useCookbookMarkdown(
     cookbookDescription: cookbook.description,
     goal,
     recipes: recipeInputs,
-    mode: "agent",
   });
 
   return { cookbook, rawMarkdown };
diff --git a/src/pages/templates/ai-chat-app.tsx b/src/pages/templates/ai-chat-app.tsx
index 5106990..407b517 100644
--- a/src/pages/templates/ai-chat-app.tsx
+++ b/src/pages/templates/ai-chat-app.tsx
@@ -1,40 +1,14 @@
 import type { ReactNode } from "react";
 import { CookbookDetail } from "@/components/cookbooks/cookbook-detail";
 import { useCookbookMarkdown } from "@/lib/use-cookbook-markdown";
-import Intro from "@site/content/cookbooks/ai-chat-app/goal.md";
-import FoundationModelsApiPrereqs from "@site/content/recipes/foundation-models-api/prerequisites.md";
-import FoundationModelsApiContent from "@site/content/recipes/foundation-models-api/content.md";
-import AiChatModelServingPrereqs from "@site/content/recipes/ai-chat-model-serving/prerequisites.md";
-import AiChatModelServingContent from "@site/content/recipes/ai-chat-model-serving/content.md";
-import LakebaseCreateInstancePrereqs from "@site/content/recipes/lakebase-create-instance/prerequisites.md";
-import LakebaseCreateInstanceContent from "@site/content/recipes/lakebase-create-instance/content.md";
-import LakebaseDataPersistencePrereqs from "@site/content/recipes/lakebase-data-persistence/prerequisites.md";
-import LakebaseDataPersistenceContent from "@site/content/recipes/lakebase-data-persistence/content.md";
-import LakebaseAgentMemoryPrereqs from "@site/content/recipes/lakebase-agent-memory/prerequisites.md";
-import LakebaseAgentMemoryContent from "@site/content/recipes/lakebase-agent-memory/content.md";
+import Goal from "@site/content/cookbooks/ai-chat-app/goal.md";
 
 export default function AiChatAppPage(): ReactNode {
   const { cookbook, rawMarkdown } = useCookbookMarkdown("ai-chat-app");
 
   return (
     <CookbookDetail cookbook={cookbook} rawMarkdown={rawMarkdown}>
-      <Intro />
-      <h2 id="prerequisites">Prerequisites</h2>
-      <FoundationModelsApiPrereqs />
-      <AiChatModelServingPrereqs />
-      <LakebaseCreateInstancePrereqs />
-      <LakebaseDataPersistencePrereqs />
-      <LakebaseAgentMemoryPrereqs />
-      <hr />
-      <FoundationModelsApiContent />
-      <hr />
-      <AiChatModelServingContent />
-      <hr />
-      <LakebaseCreateInstanceContent />
-      <hr />
-      <LakebaseDataPersistenceContent />
-      <hr />
-      <LakebaseAgentMemoryContent />
+      <Goal />
     </CookbookDetail>
   );
 }
diff --git a/src/pages/templates/app-with-lakebase.tsx b/src/pages/templates/app-with-lakebase.tsx
index 7de8c7a..4c3e59c 100644
--- a/src/pages/templates/app-with-lakebase.tsx
+++ b/src/pages/templates/app-with-lakebase.tsx
@@ -2,10 +2,6 @@ import type { ReactNode } from "react";
 import { CookbookDetail } from "@/components/cookbooks/cookbook-detail";
 import { useCookbookMarkdown } from "@/lib/use-cookbook-markdown";
 import Goal from "@site/content/cookbooks/app-with-lakebase/goal.md";
-import LakebaseCreateInstancePrereqs from "@site/content/recipes/lakebase-create-instance/prerequisites.md";
-import LakebaseCreateInstanceContent from "@site/content/recipes/lakebase-create-instance/content.md";
-import LakebaseDataPersistencePrereqs from "@site/content/recipes/lakebase-data-persistence/prerequisites.md";
-import LakebaseDataPersistenceContent from "@site/content/recipes/lakebase-data-persistence/content.md";
 
 export default function AppWithLakebasePage(): ReactNode {
   const { cookbook, rawMarkdown } = useCookbookMarkdown("app-with-lakebase");
@@ -13,13 +9,6 @@ export default function AppWithLakebasePage(): ReactNode {
   return (
     <CookbookDetail cookbook={cookbook} rawMarkdown={rawMarkdown}>
       <Goal />
-      <h2 id="prerequisites">Prerequisites</h2>
-      <LakebaseCreateInstancePrereqs />
-      <LakebaseDataPersistencePrereqs />
-      <hr />
-      <LakebaseCreateInstanceContent />
-      <hr />
-      <LakebaseDataPersistenceContent />
     </CookbookDetail>
   );
 }
diff --git a/src/pages/templates/genie-analytics-app.tsx b/src/pages/templates/genie-analytics-app.tsx
index ad4a3ee..b98cf08 100644
--- a/src/pages/templates/genie-analytics-app.tsx
+++ b/src/pages/templates/genie-analytics-app.tsx
@@ -2,8 +2,6 @@ import type { ReactNode } from "react";
 import { CookbookDetail } from "@/components/cookbooks/cookbook-detail";
 import { useCookbookMarkdown } from "@/lib/use-cookbook-markdown";
 import Goal from "@site/content/cookbooks/genie-analytics-app/goal.md";
-import GenieConversationalAnalyticsPrereqs from "@site/content/recipes/genie-conversational-analytics/prerequisites.md";
-import GenieConversationalAnalyticsContent from "@site/content/recipes/genie-conversational-analytics/content.md";
 
 export default function GenieAnalyticsAppPage(): ReactNode {
   const { cookbook, rawMarkdown } = useCookbookMarkdown("genie-analytics-app");
@@ -11,10 +9,6 @@ export default function GenieAnalyticsAppPage(): ReactNode {
   return (
     <CookbookDetail cookbook={cookbook} rawMarkdown={rawMarkdown}>
       <Goal />
-      <h2 id="prerequisites">Prerequisites</h2>
-      <GenieConversationalAnalyticsPrereqs />
-      <hr />
-      <GenieConversationalAnalyticsContent />
     </CookbookDetail>
   );
 }
diff --git a/src/pages/templates/index.tsx b/src/pages/templates/index.tsx
index 555c9ba..8ce6793 100644
--- a/src/pages/templates/index.tsx
+++ b/src/pages/templates/index.tsx
@@ -172,8 +172,8 @@ export default function TemplatesPage(): ReactNode {
               next Databricks app.
             </h1>
             <p className="mb-3 max-w-2xl text-lg text-black/68 dark:text-white/68">
-              Use each template step by step, or copy it as a prompt for your
-              coding agent to build for you.
+              Copy any template as a prompt for your coding agent to build for
+              you.
             </p>
             <Link
               to="/docs/templates"
diff --git a/src/pages/templates/lakebase-off-platform.tsx b/src/pages/templates/lakebase-off-platform.tsx
index e0c50a6..d1cdde5 100644
--- a/src/pages/templates/lakebase-off-platform.tsx
+++ b/src/pages/templates/lakebase-off-platform.tsx
@@ -2,14 +2,6 @@ import type { ReactNode } from "react";
 import { CookbookDetail } from "@/components/cookbooks/cookbook-detail";
 import { useCookbookMarkdown } from "@/lib/use-cookbook-markdown";
 import Goal from "@site/content/cookbooks/lakebase-off-platform/goal.md";
-import LakebaseCreateInstancePrereqs from "@site/content/recipes/lakebase-create-instance/prerequisites.md";
-import LakebaseCreateInstanceContent from "@site/content/recipes/lakebase-create-instance/content.md";
-import LakebaseOffPlatformEnvManagementPrereqs from "@site/content/recipes/lakebase-off-platform-env-management/prerequisites.md";
-import LakebaseOffPlatformEnvManagementContent from "@site/content/recipes/lakebase-off-platform-env-management/content.md";
-import LakebaseTokenManagementPrereqs from "@site/content/recipes/lakebase-token-management/prerequisites.md";
-import LakebaseTokenManagementContent from "@site/content/recipes/lakebase-token-management/content.md";
-import LakebaseDrizzleOffPlatformPrereqs from "@site/content/recipes/lakebase-drizzle-off-platform/prerequisites.md";
-import LakebaseDrizzleOffPlatformContent from "@site/content/recipes/lakebase-drizzle-off-platform/content.md";
 
 export default function LakebaseOffPlatformPage(): ReactNode {
   const { cookbook, rawMarkdown } = useCookbookMarkdown(
@@ -19,19 +11,6 @@ export default function LakebaseOffPlatformPage(): ReactNode {
   return (
     <CookbookDetail cookbook={cookbook} rawMarkdown={rawMarkdown}>
       <Goal />
-      <h2 id="prerequisites">Prerequisites</h2>
-      <LakebaseCreateInstancePrereqs />
-      <LakebaseOffPlatformEnvManagementPrereqs />
-      <LakebaseTokenManagementPrereqs />
-      <LakebaseDrizzleOffPlatformPrereqs />
-      <hr />
-      <LakebaseCreateInstanceContent />
-      <hr />
-      <LakebaseOffPlatformEnvManagementContent />
-      <hr />
-      <LakebaseTokenManagementContent />
-      <hr />
-      <LakebaseDrizzleOffPlatformContent />
     </CookbookDetail>
   );
 }
diff --git a/src/pages/templates/operational-data-analytics.tsx b/src/pages/templates/operational-data-analytics.tsx
index d661169..f915ce5 100644
--- a/src/pages/templates/operational-data-analytics.tsx
+++ b/src/pages/templates/operational-data-analytics.tsx
@@ -2,16 +2,6 @@ import type { ReactNode } from "react";
 import { CookbookDetail } from "@/components/cookbooks/cookbook-detail";
 import { useCookbookMarkdown } from "@/lib/use-cookbook-markdown";
 import Goal from "@site/content/cookbooks/operational-data-analytics/goal.md";
-import UnityCatalogSetupPrereqs from "@site/content/recipes/unity-catalog-setup/prerequisites.md";
-import UnityCatalogSetupContent from "@site/content/recipes/unity-catalog-setup/content.md";
-import LakebaseCreateInstancePrereqs from "@site/content/recipes/lakebase-create-instance/prerequisites.md";
-import LakebaseCreateInstanceContent from "@site/content/recipes/lakebase-create-instance/content.md";
-import LakebaseChangeDataFeedAutoscalingPrereqs from "@site/content/recipes/lakebase-change-data-feed-autoscaling/prerequisites.md";
-import LakebaseChangeDataFeedAutoscalingContent from "@site/content/recipes/lakebase-change-data-feed-autoscaling/content.md";
-import SyncTablesAutoscalingPrereqs from "@site/content/recipes/sync-tables-autoscaling/prerequisites.md";
-import SyncTablesAutoscalingContent from "@site/content/recipes/sync-tables-autoscaling/content.md";
-import MedallionArchitectureFromCdcPrereqs from "@site/content/recipes/medallion-architecture-from-cdc/prerequisites.md";
-import MedallionArchitectureFromCdcContent from "@site/content/recipes/medallion-architecture-from-cdc/content.md";
 
 export default function OperationalDataAnalyticsPage(): ReactNode {
   const { cookbook, rawMarkdown } = useCookbookMarkdown(
@@ -21,22 +11,6 @@ export default function OperationalDataAnalyticsPage(): ReactNode {
   return (
     <CookbookDetail cookbook={cookbook} rawMarkdown={rawMarkdown}>
       <Goal />
-      <h2 id="prerequisites">Prerequisites</h2>
-      <UnityCatalogSetupPrereqs />
-      <LakebaseCreateInstancePrereqs />
-      <LakebaseChangeDataFeedAutoscalingPrereqs />
-      <SyncTablesAutoscalingPrereqs />
-      <MedallionArchitectureFromCdcPrereqs />
-      <hr />
-      <UnityCatalogSetupContent />
-      <hr />
-      <LakebaseCreateInstanceContent />
-      <hr />
-      <LakebaseChangeDataFeedAutoscalingContent />
-      <hr />
-      <SyncTablesAutoscalingContent />
-      <hr />
-      <MedallionArchitectureFromCdcContent />
     </CookbookDetail>
   );
 }
diff --git a/tests/bootstrap-prompt.test.ts b/tests/bootstrap-prompt.test.ts
index 68ff927..380631a 100644
--- a/tests/bootstrap-prompt.test.ts
+++ b/tests/bootstrap-prompt.test.ts
@@ -100,9 +100,7 @@ describe("hero bootstrap prompt composition (matches /api/bootstrap-prompt)", ()
     const bootstrapIdx = combined.indexOf(
       "# Verify your local Databricks dev environment",
     );
-    const localBootstrapBodyIdx = combined.indexOf(
-      "Install the Databricks CLI",
-    );
+    const localBootstrapBodyIdx = combined.indexOf("When done, you will have");
 
     expect(aboutIdx).toBe(0);
     expect(guidelinesIdx).toBeGreaterThan(aboutIdx);
@@ -122,7 +120,7 @@ describe("hero bootstrap prompt composition (matches /api/bootstrap-prompt)", ()
       siteOrigin: "https://developers.databricks.com",
     });
     // goal.md has the outcome description, not CLI commands
-    expect(combined).toContain("Install the Databricks CLI");
+    expect(combined).toContain("Databricks CLI");
     expect(combined).toContain("https://developers.databricks.com/llms.txt");
   });
 
@@ -132,7 +130,7 @@ describe("hero bootstrap prompt composition (matches /api/bootstrap-prompt)", ()
       "set-up-your-local-dev-environment",
     );
     // Agent prompt now returns goal.md content (outcome), not full implementation
-    expect(recipe).toContain("Install the Databricks CLI");
+    expect(recipe).toContain("Databricks CLI");
     expect(recipe).toContain("authenticated CLI profile");
   });
 });
diff --git a/tests/build-example-markdown.test.ts b/tests/build-example-markdown.test.ts
index 51c85db..1eda379 100644
--- a/tests/build-example-markdown.test.ts
+++ b/tests/build-example-markdown.test.ts
@@ -5,10 +5,8 @@ import {
   buildExportGetStartedSection,
   buildIncludedTemplatesPreamble,
 } from "../src/lib/examples/build-example-markdown";
-import type {
-  ExampleMarkdownOptions,
-  ExampleSections,
-} from "../src/lib/examples/build-example-markdown";
+import type { ExampleMarkdownOptions } from "../src/lib/examples/build-example-markdown";
+import type { ContentSections } from "../src/lib/content-sections";
 import type { Example } from "../src/lib/recipes/recipes";
 
 const minimalExample: Example = {
@@ -30,19 +28,10 @@ const githubUrl =
 
 const baseUrl = "https://example.com";
 
-const sampleContentMarkdown = [
-  "## Test Example",
-  "",
-  "This is the example overview from content/examples/test-example/content.md.",
-  "",
-  "### Data Flow",
-  "",
-  "1. Step one",
-  "2. Step two",
-].join("\n");
-
-const emptySections: ExampleSections = { content: "" };
-const contentOnlySections: ExampleSections = { content: sampleContentMarkdown };
+const emptySections: ContentSections = {};
+const goalSections: ContentSections = {
+  goal: "Build a test example that demonstrates the pattern.",
+};
 
 const sampleTemplates = [
   { id: "tmpl-a", name: "Template A", description: "First template." },
@@ -102,26 +91,14 @@ describe("buildFullPrompt", () => {
     );
   });
 
-  test("includes content section body", () => {
+  test("includes goal section body", () => {
     const prompt = buildFullPrompt({
       ...baseOpts,
-      sections: contentOnlySections,
+      sections: goalSections,
     });
-    expect(prompt).toContain("This is the example overview");
-    expect(prompt).toContain("### Data Flow");
-    expect(prompt).toContain("1. Step one");
-  });
-
-  test("content body appears after get started and before source code", () => {
-    const prompt = buildFullPrompt({
-      ...baseOpts,
-      sections: contentOnlySections,
-    });
-    const getStartedIdx = prompt.indexOf("### Clone and follow");
-    const rawIdx = prompt.indexOf("This is the example overview");
-    const sourceIdx = prompt.indexOf("## Source Code");
-    expect(getStartedIdx).toBeLessThan(rawIdx);
-    expect(rawIdx).toBeLessThan(sourceIdx);
+    expect(prompt).toContain(
+      "Build a test example that demonstrates the pattern.",
+    );
   });
 
   test("includes github link", () => {
@@ -169,12 +146,6 @@ describe("buildFullPrompt", () => {
     const prompt = buildFullPrompt({ ...baseOpts, sections: emptySections });
     expect(prompt).not.toContain("## Included templates");
   });
-
-  test("omits content body when section is empty", () => {
-    const prompt = buildFullPrompt({ ...baseOpts, sections: emptySections });
-    expect(prompt).not.toContain("This is the example overview");
-    expect(prompt).toContain("## Source Code");
-  });
 });
 
 describe("buildAdditionalMarkdown", () => {
@@ -233,45 +204,6 @@ describe("buildAdditionalMarkdown", () => {
   });
 });
 
-describe("buildFullPrompt matches Copy as Markdown content", () => {
-  test("full prompt includes same content body as Copy as Markdown would", () => {
-    const prompt = buildFullPrompt({
-      ...baseOpts,
-      sections: contentOnlySections,
-      includedCookbooks: sampleTemplates,
-      includedRecipes: sampleRecipes,
-    });
-    for (const line of sampleContentMarkdown.split("\n").filter(Boolean)) {
-      expect(prompt).toContain(line);
-    }
-  });
-});
-
-describe("example Get started: full prompt (Copy prompt) vs export markdown (Copy as Markdown)", () => {
-  test("full prompt uses ### substeps; export uses ## Get started without ### clone substep", () => {
-    const full = buildFullPrompt({ ...baseOpts, sections: emptySections });
-    const exportMd = buildAdditionalMarkdown(baseOpts);
-
-    expect(full).toContain("### Clone and follow `README.md`");
-    expect(full).toContain("```bash");
-    expect(full).toContain(minimalExample.initCommand);
-
-    expect(exportMd).toContain(buildExportGetStartedSection(minimalExample));
-    expect(exportMd).not.toContain("### Clone and follow");
-    expect(exportMd).toContain("```bash");
-    expect(exportMd).toContain(minimalExample.initCommand);
-  });
-
-  test("export markdown never embeds full-prompt subheadings in the appended section", () => {
-    const exportMd = buildAdditionalMarkdown({
-      ...baseOpts,
-      includedCookbooks: sampleTemplates,
-      includedRecipes: sampleRecipes,
-    });
-    expect(exportMd).not.toContain("### 2.");
-  });
-});
-
 describe("init-style examples (databricks apps init)", () => {
   const initExample: Example = {
     ...minimalExample,
@@ -314,52 +246,4 @@ describe("init-style examples (databricks apps init)", () => {
     expect(prompt).not.toContain("### Clone and follow `README.md`");
     expect(prompt).toContain(initExample.initCommand);
   });
-
-  test("prereq section is injected before scaffold", () => {
-    const sections: ExampleSections = {
-      content: "",
-      prerequisites: [
-        "### Create the Lakebase Postgres prerequisites",
-        "",
-        "```bash",
-        "databricks postgres create-project my-proj",
-        "```",
-      ].join("\n"),
-    };
-    const prompt = buildFullPrompt({
-      ...initOpts,
-      sections,
-    });
-    expect(prompt).toContain("### Create the Lakebase Postgres prerequisites");
-    expect(prompt).toContain("### Scaffold the project");
-    expect(prompt).toContain("databricks postgres create-project my-proj");
-    const prereqIdx = prompt.indexOf(
-      "### Create the Lakebase Postgres prerequisites",
-    );
-    const scaffoldIdx = prompt.indexOf("### Scaffold the project");
-    expect(prereqIdx).toBeLessThan(scaffoldIdx);
-  });
-
-  test("deploy section replaces the default README pointer when provided", () => {
-    const sections: ExampleSections = {
-      content: "",
-      deployment: [
-        "### Install and deploy",
-        "",
-        "```bash",
-        "npm install",
-        "npm run deploy",
-        "```",
-      ].join("\n"),
-    };
-    const prompt = buildFullPrompt({
-      ...initOpts,
-      sections,
-    });
-    expect(prompt).toContain("### Install and deploy");
-    expect(prompt).toContain("npm run deploy");
-    expect(prompt).not.toContain(
-      "A **`README.md`** ships inside the scaffolded project",
-    );
-  });
 });
diff --git a/tests/cookbook-composition.test.ts b/tests/cookbook-composition.test.ts
index 84ec1dc..5aa06cc 100644
--- a/tests/cookbook-composition.test.ts
+++ b/tests/cookbook-composition.test.ts
@@ -2,7 +2,6 @@ import { describe, expect, test } from "vitest";
 import {
   buildCookbookMarkdownDocument,
   composeCookbookMarkdown,
-  stripPrerequisitesHeading,
   type CookbookRecipeInput,
 } from "../src/lib/cookbook-composition";
 
@@ -10,9 +9,7 @@ const recipeA: CookbookRecipeInput = {
   id: "recipe-a",
   name: "Recipe A",
   sections: {
-    content: "## Recipe A\n\n### 1. Step A1\n\nDo the first thing.",
-    prerequisites:
-      "## Prerequisites\n\nSome intro paragraph.\n\n- **Feature A** must be enabled.",
+    goal: "Build feature A for the app.",
   },
 };
 
@@ -20,58 +17,31 @@ const recipeB: CookbookRecipeInput = {
   id: "recipe-b",
   name: "Recipe B",
   sections: {
-    content: "## Recipe B\n\n### 1. Step B1\n\nDo the first thing.",
-    prerequisites:
-      "## Prerequisites\n\nDifferent intro.\n\n- **Feature B** must be enabled.",
-    deployment: "### 3. Deploy B\n\n```bash\nnpm run deploy\n```",
+    goal: "Build feature B for the app.",
   },
 };
 
-const recipeNoExtras: CookbookRecipeInput = {
+const recipeNoGoal: CookbookRecipeInput = {
   id: "recipe-c",
   name: "Recipe C",
-  sections: {
-    content: "## Recipe C\n\n### 1. Only step.",
-  },
+  sections: {},
 };
 
-describe("stripPrerequisitesHeading", () => {
-  test("removes a leading `## Prerequisites` heading", () => {
-    const body = "## Prerequisites\n\nIntro.\n\n- bullet";
-    expect(stripPrerequisitesHeading(body)).toBe("Intro.\n\n- bullet");
-  });
-
-  test("leaves bodies without a Prerequisites heading untouched", () => {
-    const body = "Just a paragraph.\n\n- bullet";
-    expect(stripPrerequisitesHeading(body)).toBe(body);
-  });
-});
-
 describe("composeCookbookMarkdown", () => {
-  test("hoists every recipe's prereqs into one combined section with H3 per recipe", () => {
+  test("emits each recipe goal under a ## Component heading", () => {
     const md = composeCookbookMarkdown({
       cookbookName: "Cookbook X",
       cookbookDescription: "desc",
       recipes: [recipeA, recipeB],
     });
 
-    const locate = (pattern: RegExp): number => md.search(pattern);
-
-    const prereqIdx = locate(/^## Prerequisites$/m);
-    const recipeAHeaderIdx = locate(/^### Recipe A$/m);
-    const recipeBHeaderIdx = locate(/^### Recipe B$/m);
-    const contentAIdx = locate(/^## Recipe A$/m);
-    const contentBIdx = locate(/^## Recipe B$/m);
-
-    expect(prereqIdx).toBeGreaterThanOrEqual(0);
-    expect(recipeAHeaderIdx).toBeGreaterThan(prereqIdx);
-    expect(recipeBHeaderIdx).toBeGreaterThan(recipeAHeaderIdx);
-    expect(contentAIdx).toBeGreaterThan(recipeBHeaderIdx);
-    expect(contentBIdx).toBeGreaterThan(contentAIdx);
-    expect(md.match(/^## Prerequisites$/gm)?.length).toBe(1);
+    expect(md).toContain("## Component: Recipe A");
+    expect(md).toContain("Build feature A for the app.");
+    expect(md).toContain("## Component: Recipe B");
+    expect(md).toContain("Build feature B for the app.");
   });
 
-  test("prepends intro content above the Prerequisites section", () => {
+  test("prepends intro/goal content above component headings", () => {
     const md = composeCookbookMarkdown({
       cookbookName: "Cookbook",
       cookbookDescription: "desc",
@@ -80,56 +50,46 @@ describe("composeCookbookMarkdown", () => {
     });
 
     const introIdx = md.indexOf("## What you are building");
-    const prereqIdx = md.indexOf("## Prerequisites");
+    const componentIdx = md.indexOf("## Component: Recipe A");
     expect(introIdx).toBeGreaterThanOrEqual(0);
-    expect(prereqIdx).toBeGreaterThan(introIdx);
-  });
-
-  test("skips Prerequisites section when no recipe has prerequisites", () => {
-    const md = composeCookbookMarkdown({
-      cookbookName: "Cookbook",
-      cookbookDescription: "desc",
-      recipes: [recipeNoExtras],
-    });
-    expect(md).not.toContain("## Prerequisites");
-    expect(md).toContain("## Recipe C");
+    expect(componentIdx).toBeGreaterThan(introIdx);
   });
 
-  test("emits combined Deployment section after content when any recipe has a deployment", () => {
+  test("skips recipes with no goal", () => {
     const md = composeCookbookMarkdown({
       cookbookName: "Cookbook",
       cookbookDescription: "desc",
-      recipes: [recipeA, recipeB],
+      recipes: [recipeA, recipeNoGoal],
     });
-
-    const contentBIdx = md.search(/^## Recipe B$/m);
-    const deployIdx = md.search(/^## Deployment$/m);
-    expect(contentBIdx).toBeGreaterThanOrEqual(0);
-    expect(deployIdx).toBeGreaterThan(contentBIdx);
-    expect(md).toContain("### Recipe B\n\n### 3. Deploy B");
+    expect(md).toContain("## Component: Recipe A");
+    expect(md).not.toContain("Recipe C");
   });
 
-  test("omits Deployment section when no recipe has deployment content", () => {
+  test("prefers goal over intro", () => {
     const md = composeCookbookMarkdown({
       cookbookName: "Cookbook",
       cookbookDescription: "desc",
+      goal: "Goal text.",
+      intro: "Intro text.",
       recipes: [recipeA],
     });
-    expect(md).not.toContain("## Deployment");
+    expect(md).toContain("Goal text.");
+    expect(md).not.toContain("Intro text.");
   });
+});
 
-  test("drops the ## Prerequisites heading from each recipe's body", () => {
-    const md = composeCookbookMarkdown({
-      cookbookName: "Cookbook",
-      cookbookDescription: "desc",
-      recipes: [recipeA, recipeB],
+describe("buildCookbookMarkdownDocument", () => {
+  test("produces header-only document when all recipe goals are empty", () => {
+    const md = buildCookbookMarkdownDocument({
+      cookbookName: "Empty Cookbook",
+      cookbookDescription: "No recipes with goals.",
+      recipes: [recipeNoGoal],
     });
-    const prereqHeadings = md.match(/^## Prerequisites$/gm);
-    expect(prereqHeadings?.length).toBe(1);
+    expect(md).toContain('title: "Empty Cookbook"');
+    expect(md).toContain("# Empty Cookbook");
+    expect(md).not.toContain("## Component:");
   });
-});
 
-describe("buildCookbookMarkdownDocument", () => {
   test("wraps composed body with frontmatter and title", () => {
     const md = buildCookbookMarkdownDocument({
       cookbookName: "Cookbook X",
@@ -140,7 +100,7 @@ describe("buildCookbookMarkdownDocument", () => {
     expect(md).toContain('title: "Cookbook X"');
     expect(md).toContain('summary: "Desc with \\"quotes\\"."');
     expect(md).toContain("# Cookbook X");
-    expect(md).toContain("## Prerequisites");
-    expect(md).toContain("### Recipe A");
+    expect(md).toContain("## Component: Recipe A");
+    expect(md).toContain("Build feature A for the app.");
   });
 });
diff --git a/tests/e2e/copy-markdown.spec.ts b/tests/e2e/copy-markdown.spec.ts
index 4cfe1d5..07c8251 100644
--- a/tests/e2e/copy-markdown.spec.ts
+++ b/tests/e2e/copy-markdown.spec.ts
@@ -53,7 +53,7 @@ test.describe("copy markdown exports raw markdown on recipe pages", () => {
 
     const copied = await getCopiedText(page);
     expect(copied).toContain("# About DevHub");
-    expect(copied).toContain("Install the Databricks CLI");
+    expect(copied).toContain("Databricks CLI");
     expect(copied).toContain("authenticated CLI profile");
     expect(copied).toContain("llms.txt");
   });
@@ -74,7 +74,7 @@ test.describe("copy markdown exports raw markdown on template pages", () => {
     expect(copied).toContain("# Working with DevHub prompts");
     expect(copied).toContain("# What the user just did");
     expect(copied).toContain("# Verify your local Databricks dev environment");
-    expect(copied).toContain("Install the Databricks CLI");
+    expect(copied).toContain("Databricks CLI");
     // Cookbook body comes after the meta-prompt, with its own frontmatter:
     expect(copied).toContain('title: "AI Chat App"');
     expect(copied).toContain("# The cookbook the user copied");
diff --git a/tests/e2e/navigation.spec.ts b/tests/e2e/navigation.spec.ts
index b17684f..afbf234 100644
--- a/tests/e2e/navigation.spec.ts
+++ b/tests/e2e/navigation.spec.ts
@@ -175,7 +175,7 @@ test.describe("home page link navigation", () => {
     expect(finalCopiedText).toContain(
       "# Verify your local Databricks dev environment",
     );
-    expect(finalCopiedText).toContain("Install the Databricks CLI");
+    expect(finalCopiedText).toContain("Databricks CLI");
     expect(finalCopiedText).toContain("developers.databricks.com");
     expect(finalCopiedText).toContain("llms.txt");
   });
diff --git a/tests/markdown.test.ts b/tests/markdown.test.ts
index 9ee98a7..ae03694 100644
--- a/tests/markdown.test.ts
+++ b/tests/markdown.test.ts
@@ -66,7 +66,7 @@ describe("detail markdown resolver", () => {
       "set-up-your-local-dev-environment",
     );
     // Agent prompt returns goal.md content (no heading, just description)
-    expect(markdown).toContain("Install the Databricks CLI");
+    expect(markdown).toContain("Databricks CLI");
     expect(markdown).toContain("authenticated CLI profile");
   });
 
@@ -120,7 +120,7 @@ describe("templates section resolves recipes, examples, and cookbooks", () => {
       "templates",
       "set-up-your-local-dev-environment",
     );
-    expect(markdown).toContain("Install the Databricks CLI");
+    expect(markdown).toContain("Databricks CLI");
   });
 
   test("resolves an example slug via templates", () => {
@@ -271,7 +271,7 @@ describe("slug normalization strips .md extension", () => {
       "recipes",
       "set-up-your-local-dev-environment.md",
     );
-    expect(markdown).toContain("Install the Databricks CLI");
+    expect(markdown).toContain("Databricks CLI");
   });
 
   test("templates slug with .md extension resolves", () => {
diff --git a/tests/validate-content.test.ts b/tests/validate-content.test.ts
index 2b8ef7b..153f4ef 100644
--- a/tests/validate-content.test.ts
+++ b/tests/validate-content.test.ts
@@ -55,10 +55,10 @@ describe("validate-content script", () => {
     rmSync(workDir, { recursive: true, force: true });
   });
 
-  test("passes for a valid folder layout with only content.md", () => {
+  test("passes for a valid folder layout with goal.md", () => {
     seedFixture(workDir, {
-      "content/recipes/my-recipe/content.md": "## My Recipe\n",
-      "content/examples/my-example/content.md": "## My Example\n",
+      "content/recipes/my-recipe/goal.md": "Build something.\n",
+      "content/examples/my-example/goal.md": "Build an example.\n",
     });
 
     const result = runValidator(workDir);
@@ -66,11 +66,10 @@ describe("validate-content script", () => {
     expect(result.stdout).toContain("validation passed");
   });
 
-  test("passes when optional prerequisites.md and deployment.md are present", () => {
+  test("passes when optional prerequisites.md is present", () => {
     seedFixture(workDir, {
-      "content/examples/full/content.md": "## Full\n",
+      "content/examples/full/goal.md": "Build it.\n",
       "content/examples/full/prerequisites.md": "### Prereqs\n",
-      "content/examples/full/deployment.md": "### Deploy\n",
     });
 
     const result = runValidator(workDir);
@@ -88,33 +87,43 @@ describe("validate-content script", () => {
     expect(result.stderr).toContain("is not a directory");
   });
 
-  test("fails when a folder is missing required content.md", () => {
+  test("fails when a folder is missing required goal.md", () => {
     seedFixture(workDir, {
-      "content/recipes/no-content/prerequisites.md": "### Prereqs\n",
+      "content/recipes/no-goal/prerequisites.md": "### Prereqs\n",
     });
 
     const result = runValidator(workDir);
     expect(result.status).toBe(1);
-    expect(result.stderr).toContain("no-content");
+    expect(result.stderr).toContain("no-goal");
     expect(result.stderr).toContain("missing a required file");
   });
 
+  test("fails when goal.md is whitespace-only", () => {
+    seedFixture(workDir, {
+      "content/recipes/blank/goal.md": "   \n  \n",
+    });
+
+    const result = runValidator(workDir);
+    expect(result.status).toBe(1);
+    expect(result.stderr).toContain("empty or whitespace-only");
+  });
+
   test("fails when a folder contains a disallowed filename", () => {
     seedFixture(workDir, {
-      "content/recipes/stray/content.md": "## Stray\n",
-      "content/recipes/stray/steps.md": "### Steps\n",
+      "content/recipes/stray/goal.md": "Build it.\n",
+      "content/recipes/stray/content.md": "## Steps\n",
     });
 
     const result = runValidator(workDir);
     expect(result.status).toBe(1);
-    expect(result.stderr).toContain("steps.md");
+    expect(result.stderr).toContain("content.md");
     expect(result.stderr).toContain("not an allowed filename");
   });
 
   test("accepts content/cookbooks/<slug>/intro.md", () => {
     seedFixture(workDir, {
-      "content/recipes/r/content.md": "## R\n",
-      "content/examples/e/content.md": "## E\n",
+      "content/recipes/r/goal.md": "Build it.\n",
+      "content/examples/e/goal.md": "Build it.\n",
       "content/cookbooks/my-cookbook/intro.md": "## Intro\n",
     });
 
@@ -147,8 +156,8 @@ describe("validate-content script", () => {
 
   test("fails on absolute DevHub markdown links inside templates and docs", () => {
     seedFixture(workDir, {
-      "content/recipes/bad/content.md": [
-        "## Bad",
+      "content/recipes/bad/goal.md": [
+        "Build it.",
         "",
         "See [docs](https://developers.databricks.com/docs/start-here) for setup.",
         "",
@@ -166,7 +175,7 @@ describe("validate-content script", () => {
     const result = runValidator(workDir);
     expect(result.status).toBe(1);
     expect(result.stderr).toContain(
-      "content/recipes/bad/content.md: absolute DevHub markdown link",
+      "content/recipes/bad/goal.md: absolute DevHub markdown link",
     );
     expect(result.stderr).toContain(
       '"https://developers.databricks.com/docs/start-here"',
@@ -181,8 +190,8 @@ describe("validate-content script", () => {
 
   test("allows bare prose URLs and code-block URLs that mention developers.databricks.com", () => {
     seedFixture(workDir, {
-      "content/recipes/ok/content.md": [
-        "## OK",
+      "content/recipes/ok/goal.md": [
+        "Build it.",
         "",
         "Website: https://developers.databricks.com.",
         "",