StreamSnow ❄️

An open-source toolkit for building, governing, and shipping Streamlit-in-Snowflake apps with Claude Code.

Scaffold a governed monorepo, build dashboards inside enforced data-governance guardrails, and deploy them to Snowflake — without learning the rules by hand.

Status: beta, functional. The CLI (configure / init / new / doctor / validate-app / preview / check / sql-review / review-gate / review-loop / migrate / nav / deploy-sql / deploy-setup / verify-deploy) and the Claude Code plugin (8 skills + shared recipes, with deprecated aliases for the pre-0.3 names) are implemented and CI-green for both runtimes and both deploy sources. Published on PyPI (uvx streamsnow / pip install streamsnow); APIs may still evolve toward 1.0.

What it is

StreamSnow is a hybrid of two things that work together:

1. A streamsnow CLI (PyPI) — scaffolds a governed Streamlit-in-Snowflake monorepo, runs an interactive setup wizard, and vendors the validation tools, CI, pre-commit hooks, and branding your repo needs.
2. A Claude Code plugin (marketplace) — ships the skills, subagents, and hooks that turn Claude Code into a domain expert for this stack: /start-app (the front door), /preview-app, /validate-app, /review-app, /ship-app, and more.

Think a Claude Code skill pack fused with an installable system + setup. The CLI gives you the substrate; the plugin gives Claude the playbook. A single streamsnow.config.yaml is the source of truth both read from.

Why

Building Streamlit apps on Snowflake well means getting a hundred small things right: caching with TTLs, parameterized SQL that survives the deployed Go driver, runtime selection (container vs. warehouse), schema access guardrails, a deploy pipeline, branding, and review discipline. StreamSnow encodes those as executable guardrails — pre-commit + CI gates, scaffolding templates, and Claude Code skills — so every developer (and every Claude session) follows the same rules and ships safely.

Two things you choose

StreamSnow treats two axes as first-class, configurable options:

Quickstart (target experience)

# 0. Check your machine has the prerequisites (Python 3.11+, uv, git, snow CLI)
uvx streamsnow doctor

# 1. Install the CLI, then configure + scaffold a governed repo with a starter app
uv tool install streamsnow   # persistent `streamsnow` on your PATH (uvx runs are one-shot)
mkdir my-snowflake-apps && cd my-snowflake-apps   # init scaffolds into the current directory (or pass --dir)
streamsnow init              # runs the config wizard, then scaffolds
#    (or split it: `streamsnow configure` to set up streamsnow.config.yaml first,
#     then `streamsnow init` to scaffold)

# 2. Connect to Snowflake + create local preview secrets
snow connection add --connection-name <name> --account <locator> \
  --user <you> --authenticator externalbrowser   # init prints the exact command
cp apps/<slug>/.streamlit/secrets.toml.example apps/<slug>/.streamlit/secrets.toml

# 3. Add the Claude Code plugin (inside Claude Code)
/plugin marketplace add kyle-chalmers/streamsnow
/plugin install streamsnow@streamsnow

# 4. Build, preview, validate, ship
streamsnow new marketing campaign-dashboard   # or let /start-app drive the whole flow
uv venv && uv pip install -e apps/marketing-campaign-dashboard   # install the app's deps first
uv run streamlit run apps/marketing-campaign-dashboard/streamlit_app.py
#    /start-app  ->  /preview-app  ->  /validate-app  ->  /review-app  ->  /ship-app

The skills

One front door plus focused verbs — each skill's SKILL.md stays under 80 lines, with depth in per-skill reference files:

Pre-0.3 names (/new-app, /refine-requirements, /add-page, /onboard, /auto-review-app, /sql-review, /apply-review, /deep-dive-data) still work as deprecated aliases and will be removed in the next major release.

The audit trail (new in 0.6)

Every query under apps/<slug>/queries/ gets a human-runnable proof: a fully-rendered, paste-runnable .review.sql under apps/<slug>/sql_review/, generated from a per-feature manifest and verified by an import-free freshness

• coverage gate (streamsnow sql-review check). Coverage is keyed to the queries/ convention — the same place the validate gate pushes UI-feeding SQL — so SQL inlined in Python sits outside its reach. The gate fails closed in pre-commit and the generated CI where those configs are adopted; inside streamsnow validate-app it warns only in 0.6 (FAIL planned for 0.7). A person with nothing but Snowsight can trace a covered visual back to the data and confirm it — see Auditing a visual. For dashboards whose visuals aggregate differently than any single query, "mode": "metrics" manifests (0.6.1) render one authored block per visual.

Make it yours — repo overlays (new in 0.6.1)

The skills are generic procedures; your org's knowledge layers on top without forking them. Commit .streamsnow/overlays/<skill>.md files and every skill reads its overlay first — extra steps, local failure signatures, environment specifics, explicit overrides. Plugin upgrades never touch them; overlays may not skip mandatory gate invocations, and the coded gates (hooks, CI, pre-commit) run outside skill prose entirely. See skills/_shared/overlays.md.

Hooks, in full

Trust demands transparency: this plugin runs hooks, so here is every one of them. All are stdlib-only, make no network calls, never write outside the repo (plus one best-effort dedupe state file in $TMPDIR, so the review nudge fires once per state, not every turn), and fail open — a hook error never blocks your session; the guards only ever add a confirmation or a note.

All hooks are repo-gated on streamsnow.config.yaml — zero cost in unrelated repos — and declare explicit timeouts so a hung hook can never stall a session. To turn them off, disable the plugin (claude plugin disable streamsnow). Upgrading from ≤0.5: hook additions do not reach installed copies automatically — run /plugin uninstall streamsnow then reinstall.

How it's organized

streamsnow/            the PyPI package — CLI, config, policy, scaffolder, tools
  ├── cli.py           configure / init / new / doctor / check
  ├── config.py        typed + validated streamsnow.config.yaml model
  ├── policy.py        schema allow/deny single source of truth
  ├── scaffolder.py    renders a governed repo from config
  ├── _templates/      the Jinja scaffold templates (repo/ + app/)
  └── tools/           governance checks + engines (schema refs, security,
                       caching, dependency vulns, tombstones, path leaks,
                       sql_review generator, review gate/loop, migrate, doctor)
.claude-plugin/        Claude Code plugin manifest + marketplace
skills/  agents/  hooks/   Claude Code plugin surface (skills + SessionStart hook)
docs/  examples/            guides + a runnable no-Snowflake example app

Active scaffolding lives in streamsnow/ (templates under streamsnow/_templates/).

The streamsnow Python package is the single source of truth for tool logic: the CLI, the Claude Code plugin, pre-commit, and CI all call the same code — one implementation, many consumers.

Documentation

• Getting started — run the example with no Snowflake, then scaffold and preview your own governed app.
• Data discovery — find tables and wire queries inside the schema-access guardrails.
• Deploying — ship apps to Snowflake on merge, for both deploy sources.
• Deploy setup — the one-time Snowflake objects and CI secrets the pipeline needs.
• Auditing a visual — the five-minute runbook for confirming any dashboard number against the warehouse, no code required.
• Production lessons — the incidents behind the guardrails, genericized.
• Distribution — how StreamSnow ships (PyPI CLI + plugin) and why there's no separate copy-paste kit.
• Migrating a consumer repo — bring a repo with home-grown skills onto the plugin (skill map + incremental path).

License

MIT © Kyle Chalmers

StreamSnow is an independent open-source project and is not affiliated with or endorsed by Snowflake Inc., Streamlit, or Anthropic.