Skip to main content
skill CX Codex

discovering-make-commands — Claude Code skill: how to install

discovering-make-commands supplies coding agents with the repository Makefile targets for building, testing, and linting Streamlit.

Apache-2.0 ★ 46,474 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add streamlit/streamlit --skill discovering-make-commands -a claude-code
Open on GitHub

What discovering-make-commands does

This skill exposes the full catalog of make targets meant to be executed from the root of the Streamlit repository. Instead of guessing build scripts, the model reads the exact target names, arguments, and intended workflows.

The catalog spans frontend Vite builds, protobuf compilation with buf, static typing checks, unit testing, and Playwright suites. It includes specialized targets such as check to validate only modified files before git commits, plus commands for snapshot updates.

Running python-integration-tests requires running PYTHON_DEPENDENCY_GROUP=integration make python-init beforehand.

What it helps with

  • find the exact make command to rebuild frontend or protobuf files
  • run Playwright e2e tests in debug mode or with tracing enabled
  • verify touched files before commit using make check
  • build wheel distribution packages into dist folder

Example prompts for the agent

  • Which make command should I run to inspect only modified files before committing?
  • Show the make command to run st_command_test.py in debug mode
  • Recompile Protobuf definitions for both Python and the frontend

How to install discovering-make-commands

1Skills CLI (Vercel)

npx skills add streamlit/streamlit --skill discovering-make-commands -a claude-code

2Manually: put the files in place

~/.claude/skills/discovering-make-commands/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/discovering-make-commands/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about discovering-make-commands

How to install discovering-make-commands in Claude Code?

Run npx skills add streamlit/streamlit --skill discovering-make-commands -a claude-code. The skill will be placed at ~/.claude/skills/discovering-make-commands/SKILL.md.

What does discovering-make-commands do?

It gives the coding assistant an authoritative reference of repository make targets covering builds, formatting, unit tests, and Playwright execution.

Are there prerequisites before running integration tests?

Yes, target python-integration-tests requires executing PYTHON_DEPENDENCY_GROUP=integration make python-init first.

Source text

SKILL.md · Apache-2.0
---
name: discovering-make-commands
description: Lists available make commands for Streamlit development. Use for build, test, lint, or format tasks.
---

# Available `make` commands

List of all `make` commands available for execution from the repository root folder:

```
help                      Show all available make commands.
all                       Install all dependencies, build frontend, and install editable Streamlit.
all-dev                   Install all dependencies and editable Streamlit, but do not build the frontend.
init                      Install all dependencies and build protobufs.
clean                     Remove all generated files.
protobuf                  Recompile Protobufs for Python and the frontend.
protobuf-lint             Lint and check formatting of protobuf files (buf).
protobuf-format           Format protobuf files (buf).
python-init               Install Python dependencies and Streamlit in editable mode.
python-lint               Lint and check formatting of Python files.
python-format             Format Python files.
python-tests              Run Python unit tests.
python-performance-tests  Run Python performance tests.
python-integration-tests  Run Python integration tests. Requires `PYTHON_DEPENDENCY_GROUP=integration make python-init` first.
python-types              Run the Python type checker.
frontend-init             Install all frontend dependencies.
frontend                  Build the frontend.
frontend-with-profiler    Build the frontend with the profiler enabled.
frontend-fast             Build the frontend (as fast as possible).
frontend-dev              Start the frontend development server.
debug                     Start Streamlit and Vite dev server for debugging. Use via `make debug my-script.py`.
frontend-lint             Lint and check formatting of frontend files.
frontend-types            Run the frontend type checker.
frontend-format           Format frontend files.
frontend-tests            Run frontend unit tests and generate coverage report.
frontend-knip             Run Knip unused-export and unused-dependency analysis.
frontend-typesync         Check for unsynced frontend types.
update-frontend-typesync  Installs missing typescript typings for dependencies.
update-snapshots          Update e2e snapshots from the failed Playwright run for the current commit.
update-snapshots-changed  Update changed-file e2e snapshots from the failed Playwright run for this commit.
update-material-icons     Update material icons based on latest Google material symbol version.
update-emojis             Update emojis from Unicode's latest emoji-test.txt.
update-notices            Update the notices file (licenses of frontend assets and dependencies).
update-headers            Update all license headers.
update-min-deps           Update minimum dependency constraints file.
debug-e2e-test            Run a playwright e2e test in debug mode. Use it via `make debug-e2e-test st_command_test.py`.
run-e2e-test              Run a playwright e2e test. Use it via `make run-e2e-test st_command_test.py`.
trace-e2e-test            Run e2e test with tracing and view it. Use via `make trace-e2e-test <test_file.py>::<test_func>`.
lighthouse-tests          Run Lighthouse performance tests.
bare-execution-tests      Run all e2e tests in bare mode.
cli-smoke-tests           Run CLI smoke tests.
check                     Run all checks (format, lint, types, unit tests) on changed files only. Useful to verify the current state of the codebase before committing.
autofix                   Autofix linting and formatting errors.
package                   Create Python wheel files in `dist/`.
```

© streamlit · Apache-2.0 · streamlit/streamlit

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set6

Project sponsors

Companies that keep this analytics open