Skip to content
Back to search

databricks-agent-skills

MarketplaceWorks with Claude CodeGitHub

Databricks agent skills for AI coding assistants.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/databricks/databricks-agent-skills with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/databricks/databricks-agent-skills'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/databricks-databricks-agent-skills/badge.svg)](/listings/databricks-databricks-agent-skills)

HTML

<a href="/listings/databricks-databricks-agent-skills"><img src="/api/listings/databricks-databricks-agent-skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Two install paths cover the **stable** skills. They install to different places but end up loaded by the same agents — pick whichever fits your workflow.

- **Databricks CLI** writes SKILL.md files directly into each agent's skill directory (`~/.claude/skills/`, `~/.cursor/extensions/<...>`, etc.). - **Plugin marketplaces** (Claude Code, Cursor) cache the plugin under the agent's plugin directory (e.g. `~/.claude/plugins/cache/databricks-agent-skills/`); the agent discovers skills from there.

**Via the Databricks CLI (canonical; supports experimental skills):**

databricks aitools install

The CLI auto-detects your coding agent(s) and installs the stable skills to the right location:

- **Claude Code** → `~/.claude/skills/` - **Cursor**, **Codex CLI**, **OpenCode**, **GitHub Copilot**, **Antigravity** → their respective skill directories

For finer control, use the `aitools skills install` subcommand directly — it accepts a positional skill name and an `--experimental` flag (see the [Experimental Skills](#experimental-skills) section).

**Via the Claude Code plugin marketplace** (stable skills only — installs every skill under [`./skills/`](./skills/)):

/plugin marketplace add databricks/databricks-agent-skills
/plugin install databricks@databricks-agent-skills

**Via the Cursor plugin marketplace:**

/add-plugin databricks

The Cursor plugin ships the skills plus the `databricks-setup` / `databricks-doctor` commands, two of the three hooks (session context, auth-failure hints), and a routing rule that steers Databricks prompts into the skills; see [Commands and hooks](#commands-and-hooks-claude-code-cursor).

**Via the GitHub Copilot plugin marketplace:**

copilot plugin marketplace add databricks/databricks-agent-skills
copilot plugin install databricks@databricks-agent-skills

Works in Copilot CLI (plugins are GA there) and VS Code (agent plugins, preview; also installable from the Extensions view). Ships the skills plus two hooks: the session context primer and the auth-failure hinter (both run on Copilot CLI and the cloud agent; VS Code has its own hooks system). The Copilot cloud agent on github.com takes no plugins; for that surface, vendor the skills into the target repo (`.github/skills/`) and the auth-hint hook into `.github/hooks/`.

**Via the Codex plugin marketplace:**

codex plugin marketplace add databricks/databricks-agent-skills
codex plugin add databricks

The Codex plugin ships the skills plus all three hooks (prompt routing, session context, auth-failure hints). Codex hash-pins plugin hooks: run `/hooks` once after install (and after each update) to review and enable them. Codex has no distributable slash commands, so the setup/doctor workflows are reachable through the skills there.

CLI vs plugin marketplace

| | CLI | Plugin marketplace | |---|---|---| | Stable skills | ✅ (default) | ✅ | | Experimental skills | ✅ (with `--experimental` or by name) | ❌ | | Per-skill selection | ✅ (`databricks aitools install <name>`) | ❌ (all-or-nothing) | | Commands & hooks | ❌ (skills only today, see below) | ✅ | | Updates | `databricks aitools update` | Plugin marketplace update flow | | Required outside the agent | Databricks CLI v1.0.0+ | None |

If in doubt, use the CLI — it's the canonical install path and the only one that exposes experimental skills.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 21 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "$schema": "https://json.schemastore.org/claude-code-plugin-marketplace.json",
  3. "name": "databricks-agent-skills",
  4. "description": "Databricks agent skills for AI coding assistants.",
  5. "owner": {
  6. "name": "Databricks"
  7. },
  8. "plugins": [
  9. {
  10. "name": "databricks",
  11. "source": {
  12. "source": "git-subdir",
  13. "url": "databricks/databricks-agent-skills",
  14. "path": "plugins/databricks/claude",
  15. "ref": "main"
  16. },
  17. "category": "development",
  18. "description": "Databricks skills for the CLI, Apps, Lakebase, Model Serving, Lakeflow Jobs, Spark Declarative Pipelines, Declarative Automation Bundles (DABs), and classic-to-serverless migration."
  19. }
  20. ]
  21. }
README.md · README · 353 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Databricks AI Tools
  2. Build on Databricks with AI coding agents such as Claude Code, Cursor, Codex,
  3. GitHub Copilot, and many others.
  4. This repository provides the skills and agent plugins for Databricks AI Tools.
  5. Skills give your agent Databricks-specific guidance for building apps, jobs,
  6. and data pipelines, working with Lakebase and Model Serving, and deploying
  7. resources with Declarative Automation Bundles. Plugins add hooks and commands
  8. where supported.
  9. See the [Databricks AI Tools documentation](https://docs.databricks.com/agent-skills/)
  10. for setup and guidance on using AI Tools alongside managed MCP servers.
  11. ## Installation
  12. Two install paths cover the **stable** skills. They install to different places
  13. but end up loaded by the same agents — pick whichever fits your workflow.
  14. - **Databricks CLI** writes SKILL.md files directly into each agent's skill
  15. directory (`~/.claude/skills/`, `~/.cursor/extensions/<...>`, etc.).
  16. - **Plugin marketplaces** (Claude Code, Cursor) cache the plugin under the
  17. agent's plugin directory (e.g. `~/.claude/plugins/cache/databricks-agent-skills/`);
  18. the agent discovers skills from there.
  19. **Via the Databricks CLI (canonical; supports experimental skills):**
  20. ```bash
  21. databricks aitools install
  22. ```
  23. The CLI auto-detects your coding agent(s) and installs the stable skills into
  24. each agent's own skills directory. For example, Claude Code skills are
  25. installed in `~/.claude/skills/`. Run `databricks aitools --help` for the
  26. current list of supported agents.
  27. For finer control, use the `aitools skills install` subcommand directly — it
  28. accepts a positional skill name and an `--experimental` flag (see the
  29. [Experimental Skills](#experimental-skills) section).
  30. **Via the Claude Code plugin marketplace** (stable skills only — installs every
  31. skill under [`./skills/`](./skills/)):
  32. ```text
  33. /plugin marketplace add databricks/databricks-agent-skills
  34. /plugin install databricks@databricks-agent-skills
  35. ```
  36. **Via the Cursor plugin marketplace:**
  37. ```text
  38. /add-plugin databricks
  39. ```
  40. The Cursor plugin ships the skills plus the `databricks-setup` /
  41. `databricks-doctor` commands, two of the three hooks (session context,
  42. auth-failure hints), and a routing rule that steers Databricks prompts into the
  43. skills; see
  44. [Commands and hooks](#commands-and-hooks-claude-code-cursor).
  45. **Via the GitHub Copilot plugin marketplace:**
  46. ```text
  47. copilot plugin marketplace add databricks/databricks-agent-skills
  48. copilot plugin install databricks@databricks-agent-skills
  49. ```
  50. Works in Copilot CLI (plugins are GA there) and VS Code (agent plugins,
  51. preview; also installable from the Extensions view). Ships the skills plus
  52. two hooks: the session context primer and the auth-failure hinter (both run on
  53. Copilot CLI and the cloud agent; VS Code has its own hooks system). The Copilot
  54. cloud agent on github.com takes no plugins;
  55. for that surface, vendor the skills into the target repo (`.github/skills/`)
  56. and the auth-hint hook into `.github/hooks/`.
  57. **Via the Codex plugin marketplace:**
  58. ```text
  59. codex plugin marketplace add databricks/databricks-agent-skills
  60. codex plugin add databricks
  61. ```
  62. The Codex plugin ships the skills plus all three hooks (prompt routing,
  63. session context, auth-failure hints). Codex hash-pins plugin hooks: run
  64. `/hooks` once after install (and after each update) to review and enable
  65. them. Codex has no distributable slash commands, so the setup/doctor
  66. workflows are reachable through the skills there.
  67. ### CLI vs plugin marketplace
  68. | | CLI | Plugin marketplace |
  69. |---|---|---|
  70. | Stable skills | ✅ (default) | ✅ |
  71. | Experimental skills | ✅ (with `--experimental` or by name) | ❌ |
  72. | Per-skill selection | ✅ (`databricks aitools install <name>`) | ❌ (all-or-nothing) |
  73. | Commands & hooks | ❌ (skills only today, see below) | ✅ |
  74. | Updates | `databricks aitools update` | Plugin marketplace update flow |
  75. | Required outside the agent | Databricks CLI v1.0.0+ | None |
  76. If in doubt, use the CLI — it's the canonical install path and the only one that
  77. exposes experimental skills.
  78. ## Available Skills
  79. The MLflow workflows are adapted from
  80. [`mlflow/skills@6a505d8`](https://github.com/mlflow/skills/tree/6a505d8f30b7fbf93533cdf4e7d88fc30d66ba8b). Use
  81. `databricks-mlflow-evaluation` for evaluation workflows and `databricks-mlflow-tracing`
  82. for tracing and observability workflows.
  83. Stable skills shipped from [`skills/`](./skills/):
  84. - **databricks-core** — CLI, authentication, profile selection, data exploration. Parent skill for all product skills.
  85. - **databricks-data-discovery** — Find, explore, and query data via Genie One (natural-language data Q&A and SQL generation); falls back to manual `information_schema` exploration.
  86. - **databricks-lakehouse-mcp** — Discover and connect to the hosted Lakehouse MCP, then retrieve notebook workflow guidance. Available before preview access; setup is provided by `system.ai.lakehouse`, and access questions go to your Databricks account representative.
  87. - **databricks-apps** — Build full-stack TypeScript apps on Databricks using AppKit.
  88. - **databricks-app-design** — Design the UX of data apps: dashboards, KPI pages, reports, charts, and Genie/chat surfaces, mapped to AppKit components.
  89. - **databricks-dabs** — Declarative Automation Bundles (formerly Asset Bundles) for deploying and managing Databricks resources.
  90. - **databricks-jobs** — Lakeflow Jobs orchestration: task types, triggers, schedules, notifications.
  91. - **databricks-lakebase** — Lakebase Postgres: projects, branching, autoscaling, synced tables, Data API.
  92. - **databricks-model-serving** — Model Serving endpoint management, AI Gateway, traffic config.
  93. - **databricks-pipelines** — Lakeflow Spark Declarative Pipelines (formerly DLT) for batch and streaming.
  94. - **databricks-serverless-migration** — Migrate classic-compute workloads to serverless compute.
  95. - **databricks-serverless-migration-api** — Start, review, and approve managed job migrations through the Compute Migrations API and CLI.
  96. - **databricks-vector-search** — AI Search (formerly Vector Search) endpoints + indexes for RAG and semantic search.
  97. - **databricks-ai-functions** — Built-in AI Functions (ai_query, ai_classify, ai_extract, ai_parse_document, ai_forecast) in SQL and PySpark.
  98. - **databricks-ai-runtime** — AI Runtime (`air`) CLI for serverless GPU training workloads and custom Docker images.
  99. - **databricks-aibi-dashboards** — AI/BI dashboards with a SQL-validation workflow.
  100. - **databricks-apps-python** — Python data apps (Streamlit, Dash, Gradio, Flask, FastAPI, Reflex); prefers AppKit for new apps.
  101. - **databricks-dbsql** — Databricks SQL warehouse patterns.
  102. - **databricks-docs** — Databricks documentation lookup via llms.txt.
  103. - **databricks-execution-compute** — Execute code on Databricks compute.
  104. - **databricks-iceberg** — Apache Iceberg tables (Managed/Foreign), UniForm, Iceberg REST Catalog, client interoperability.
  105. - **databricks-lakeflow-connect** — Lakeflow Connect managed ingestion from databases (CDC, gateway, query-based).
  106. - **databricks-lakeflow-connect-saas** — Lakeflow Connect managed ingestion from SaaS applications, files, Kafka and RabbitMQ.
  107. - **databricks-metric-views** — Unity Catalog Metric Views for governed metrics.
  108. - **databricks-ml-training** — ML model training on Databricks.
  109. - **databricks-mlflow-evaluation** — MLflow agent evaluation, scorers, and quality improvement.
  110. - **databricks-mlflow-tracing** — MLflow tracing, trace analysis, and observability.
  111. - **databricks-python-sdk** — Python SDK, Databricks Connect, CLI, REST API.
  112. - **databricks-sandbox** — Databricks Sandbox: serverless sandboxes for untrusted/agent code; lifecycle, command execution, and files via the Databricks SDK (Python, Java, Go, JavaScript).
  113. - **databricks-spark-structured-streaming** — Spark Structured Streaming patterns.
  114. - **databricks-synthetic-data-gen** — Realistic synthetic / test data with Faker.
  115. - **databricks-unity-catalog** — Unity Catalog system tables for lineage, audit, and billing.
  116. - **databricks-unity-gateway** — Governed AI model, MCP, and model provider services in Unity Catalog.
  117. - **databricks-unstructured-pdf-generation** — Generate synthetic PDFs for RAG.
  118. - **databricks-zerobus-ingest** — Zerobus streaming ingest patterns.
  119. ## Experimental Skills
  120. The [`experimental/`](./experimental/) directory contains additional skills on a
  121. **best-effort basis**. These include skills authored here and remaining snapshot
  122. imports from
  123. [databricks-solutions/ai-dev-kit](https://github.com/databricks-solutions/ai-dev-kit)
  124. (now deprecated — this repo is the source of truth going forward).
  125. - Experimental skills are **not officially supported** — they may be used, but
  126. do not follow the same review / quality bar as the stable skills under
  127. [`skills/`](./skills/).
  128. - They are **not installed by default** by `databricks aitools install`.
  129. Pass `--experimental` to install all of them, or install a specific one
  130. by name (with the `--experimental` flag — e.g. `databricks aitools install
  131. spark-python-data-source --experimental`).
  132. - See [`experimental/README.md`](./experimental/README.md) for the full list
  133. and caveats.
  134. ## Commands and hooks (Claude Code, Cursor)
  135. When installed as a Claude Code plugin, the `databricks` plugin adds slash
  136. commands and three hooks (prompt routing, session context, auth-failure hints)
  137. on top of the skills. The Cursor plugin (`databricks`) ships the same
  138. commands and two of the hooks; see the Cursor note below.
  139. (These ship via the plugin marketplaces; the CLI `databricks aitools install`
  140. path installs skills only today; see the note at the end.)
  141. **Slash commands**: friction-only entry points; everyday work stays with the
  142. auto-invoked skills.
  143. - `/databricks:setup [workspace-url]`: auth/onboarding. Install check, then an
  144. OAuth / PAT / service-principal profile, then verify.
  145. - `/databricks:doctor [profile]`: read-only health check (CLI version, auth,
  146. workspace reachability, compute, recent job failures).
  147. (Product workflows such as apps, jobs, pipelines, DABs, etc. are handled by the
  148. skills, not commands, so they aren't duplicated here.)
  149. **Hooks** (`hooks/`, all fail-open):
  150. - **Prompt router** (UserPromptSubmit): a fast keyword regex (sub-50ms, no LLM,
  151. no network) over each prompt. When the prompt is Databricks-related, it injects
  152. a note steering Claude to load `databricks-core` plus the matching product
  153. skill before answering. The full note fires once per session; later Databricks
  154. prompts get a one-line reminder. Unrelated prompts are untouched. No
  155. permission gating, no cost warnings.
  156. - **Context primer** (SessionStart, skipped on resume): injects the routing
  157. rule, CLI version, configured profile names and any
  158. `[__settings__].default_profile` (read locally, no network call, no token
  159. values), and env/in-platform auth state.
  160. - **Auth-failure hint** (PostToolUse on Bash): when a `databricks` command fails
  161. with an auth-shaped error, adds one line suggesting `/databricks:doctor` or
  162. `databricks auth login` before retrying. Never blocks or rewrites commands.
  163. **Cursor.** Cursor has a flat `/` menu (no `plugin:command` namespacing), so
  164. the same commands ship as `/databricks-setup` and `/databricks-doctor`,
  165. rendered from the one templated [`commands/`](./commands/) source into the
  166. Cursor bundle folder. The Cursor-dialect hook wiring ships as the Cursor bundle
  167. folder's `hooks/hooks.json` (auto-discovered from the plugin root, no
  168. declaration): the context primer (`sessionStart`) and the auth-failure hint
  169. (`postToolUse`), both invoked with `--platform cursor` so they emit Cursor's
  170. output shape and reference the Cursor command names. The
  171. prompt-router hook does not port (Cursor's `beforeSubmitPrompt` cannot inject
  172. context), so routing instead ships as a Cursor rule
  173. ([`rules/databricks-routing.mdc`](./rules/databricks-routing.mdc)) that injects
  174. the routing table when a prompt is Databricks-related, independent of an open
  175. Cursor bug that currently drops hook `additional_context`. Native skill
  176. selection also helps.
  177. > **Distribution parity (follow-up).** Each plugin bundle includes its provider's
  178. > supported components. `databricks aitools install` currently packages only
  179. > `skills/`, so CLI-install users don't yet get commands/hooks. Closing that gap
  180. > is tracked as CLI-side work.
  181. ## Structure
  182. Each skill follows the [Agent Skills Specification](https://agentskills.io/specification):
  183. ```
  184. skill-name/
  185. ├── SKILL.md # Main skill file with frontmatter + instructions
  186. └── references/ # Additional documentation loaded on demand
  187. ```
  188. ## Development
  189. ### Adding New Skills
  190. For a narrower variation of an existing skill, create a subskill that declares
  191. its parent via frontmatter. This is how the stable skills are organized today
  192. — each product skill sets `parent: databricks-core`.
  193. ```markdown
  194. ---
  195. name: "databricks-apps-chatbots"
  196. description: "Databricks apps with chatbot features"
  197. parent: databricks-apps
  198. ---
  199. # Chatbot Apps
  200. **FIRST**: Use the parent `databricks-apps` skill for app development basics.
  201. Then apply these patterns:
  202. - Pattern 1
  203. - Pattern 2
  204. ```
  205. This approach:
  206. - Keeps the main skill stable and focused
  207. - Allows experimentation without modifying core skills
  208. - Makes it easy to follow the changes in the main skill
  209. ### Manifest Management
  210. `manifest.json` is **generated** by `scripts/skills.py` from the skill
  211. directories and frontmatter. Do not edit it by hand. CI rejects manual changes
  212. via two checks: content drift (parsed dict doesn't match what `generate` would
  213. produce) and canonical form (on-disk bytes don't match
  214. `json.dumps(..., indent=2, sort_keys=True)`).
  215. Because the CLI reads `manifest.json` and plugin installs read the generated
  216. catalogs and provider bundle live from `main`, `main` must stay a consistent
  217. index of its own source between releases. `.github/workflows/self-heal-manifest.yml`
  218. enforces this: on every push to `main` that touches generation inputs it re-runs
  219. `scripts/skills.py generate` and commits the refreshed `manifest.json`, plugin
  220. catalogs, hook/routing files, and provider bundle back to `main`, so a skill
  221. added, deleted, or reshaped in one PR can't leave installs fetching missing
  222. files. The per-PR committed-manifest check is therefore advisory (it surfaces
  223. staleness without blocking PRs that merely inherited it from `main`).
  224. Sync assets and regenerate the manifest after adding or updating skills:
  225. ```bash
  226. python3 scripts/skills.py
  227. ```
  228. Validate that assets and manifest are up to date (used by CI):
  229. ```bash
  230. python3 scripts/skills.py validate
  231. ```
  232. To check only that a committed manifest points at files that exist in the repo:
  233. ```bash
  234. python3 scripts/skills.py validate-committed-manifest
  235. ```
  236. The manifest is consumed by the CLI to discover available skills.
  237. ### Plugin manifest management
  238. The repo ships one plugin to five targets (Claude Code, Codex, Copilot, Cursor,
  239. Antigravity), with a separate bundle at `plugins/databricks/<provider>/` for each
  240. target. Four `marketplace.json` catalogs at the repo root each point a scoped
  241. source at their provider's bundle (tracking `main`). The Antigravity provider is
  242. available for [local testing](docs/antigravity.md); runtime validation is pending.
  243. The bundles, the catalogs, the five `plugin.json` files,
  244. and `manifest.json` are all
  245. **generated** from a single source of truth,
  246. [`metaplugin/plugin.meta.json`](./metaplugin/plugin.meta.json), by `scripts/skills.py`. Do not
  247. hand-edit the generated files (generated manifest subdirectories also carry a
  248. `README.md` saying so, and `plugins/**` is marked `linguist-generated`) — edit
  249. `metaplugin/plugin.meta.json` and regenerate:
  250. ```bash
  251. python3 scripts/skills.py generate # regenerates manifest.json + all plugin manifests
  252. python3 scripts/skills.py validate # CI check: fails on any drift
  253. ```
  254. `metaplugin/version.meta.json` owns the release version, propagated to all five
  255. targets. `metaplugin/plugin.meta.json` owns the name, description, keywords,
  256. author/license, per-target display names and hook/command/rule wiring, and the
  257. skill-to-keyword map. Adding a stable skill
  258. means adding it to the `skills` map there (with a `keyword`); CI fails if a
  259. shipped skill has no entry. The same source also drives prompt routing: its
  260. `routing` block is rendered into the prompt router's data
  261. (`hooks/_routing_data.json`), the Cursor routing rule
  262. (`rules/databricks-routing.mdc`), and the Antigravity routing rule
  263. (`plugins/databricks/antigravity/rules/databricks-routing.md`) from one table,
  264. so they can't drift. See
  265. [CONTRIBUTING.md](./CONTRIBUTING.md) for the full field reference.
  266. ## Security
  267. Please see [SECURITY](./SECURITY) for vulnerability reporting guidelines.
  268. ## Integrity
  269. Release tags are created by the [Release workflow](./.github/workflows/release.yml)
  270. and map 1:1 to a published version.
  271. ## Contributing
  272. We welcome feedback and change proposals through [GitHub issues][change-proposal].
  273. This repository is published from an internal Databricks source of truth. Pull
  274. request creation is restricted to repository collaborators and is used only to
  275. publish internal changes. If a proposal is accepted, a Databricks maintainer
  276. will implement it internally and publish the change here. See
  277. [CONTRIBUTING.md](./CONTRIBUTING.md) for details.
  278. [change-proposal]: /databricks/databricks-agent-skills/issues/new/choose
  279. - All changes require approval from a code owner (see [CODEOWNERS](./.github/CODEOWNERS)).
  280. - Documentation examples must follow least-privilege defaults — avoid suggesting elevated permissions or broad scopes unless explicitly necessary.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.