agentleFS
cryptofish7cryptofish7/claude-skills/skills/smoke-test/SKILL.md

smoke-test

Skill1 starsChanged 9 months agoMITView on GitHub

Generate and maintain a local deploy script (scripts/deploy.sh). Discovers project services, deploys them locally, and health-checks each one. Use when the user asks to "smoke test", "deploy locally", "test local deploy", "update deploy script", "run deploy", or "run smoke test".

22 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use debugging-difficult-bugs, pr-explainer and 2 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • dzevsSkill

    debugging-difficult-bugs

    Use early when debugging a medium or hard bug, especially when tests alone may not reveal the real runtime failure. Trigger this before extended TDD iteration when a bug involves runtime state, PTY/terminal ordering, persistence, streaming, async/concurrency, the TUI/manual reproduction, the IPC socket layer, or when a red or newly passing test may not model the real issue. Skip only when the root cause is already directly proven by a stack trace or deterministic test that exercises the real runtime path.

    Also in 3 projects that use this

  • Mathews-TomSkill

    pr-explainer

    Use when a developer asks to explain a pushed PR, walk through a PR stack, understand one stack member, or explain what an AI agent just pushed so they can connect code changes to end-to-end functionality and update domain knowledge. Not for defect review, merge approval, PR-body authoring, or full-repository onboarding.

    Also in 3 projects that use this

  • dzevsSkill

    pr-splitter

    Use when breaking a large, complex, messy, or hard-to-review pull request into multiple smaller PRs; planning stacked PRs; extracting independent changes from a branch; splitting mixed refactor and behavior changes; managing drift after review feedback (operator gate, Codex/swarm second opinion); rebasing follow-up PRs as earlier PRs change; or preserving original branch intent while shipping incrementally.

    Also in 3 projects that use this

  • GitHubSkill

    commit-message

    Generate conventional commit messages - use when creating commits, writing commit messages, or asking for git commit help

    Also in 3 projects that use this

The file

We split this skill into the rules it gives an agent

3 rules. 0 are common, 1 is distinctive, and 2 are very specific to this project.

  • 0

    Common

    Most of the 19 edited versions we read keep these.

  • 1

    Distinctive

    This author's own choices. Worth a look.

  • 2

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    If an existing scripts/deploy.sh exists, produce a diff:

    line 34
  2. Very specific:

    Write or update scripts/deploy.sh (create the scripts/ directory if needed)

    line 42
  3. Distinctive:

    If it fails, diagnose and fix the script (not the project code — the script should reflect reality)

    line 58

“Common” is measured: kept by at least 6 in 10 of the 19 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Local Deploy Script

Generate and maintain a scripts/deploy.sh script that deploys the project locally and health-checks each service. Designed to be called repeatedly — each invocation re-audits the project and adds, removes, or updates stages to match what's currently deployed.

Workflow

Phase 1: Discover project state

Build a project profile by detecting:

  1. Language & runtime — Check file extensions and config files (pyproject.toml, package.json, go.mod, Cargo.toml, etc.). Note the minimum required version (e.g., requires-python = ">=3.11").
  2. Package manager — pip/uv/poetry, npm/yarn/pnpm, cargo, go modules, etc.
  3. CLI entry point — main.py, src/index.ts, cmd/main.go, Cargo.toml [[bin]], etc.
  4. CLI commands — Parse argument parsers or command definitions to find subcommands.
  5. Key modules — Identify services, servers, and infrastructure components (databases, chain nodes, etc.).
  6. Existing scripts/deploy.sh — If present, read it to understand current stages and compare with detected state.

Phase 2: Design stages

Map discovered state to stages. Only include stages for services and infrastructure that are implemented.

Standard stage ordering:

  1. Environment — Required tools and runtimes are available (version checks, binary existence)
  2. Build — Compile/build steps needed before services can start (e.g., forge build, pnpm build, cargo build)
  3. Start services — Start infrastructure (database, chain node, message queue) and application services (backend, frontend, indexer). Use a cleanup trap (trap cleanup EXIT) to tear down all started services on both success and failure.
  4. Health-check — Verify each service responds correctly (HTTP endpoints return 200, RPC nodes answer queries, databases accept connections, pages load)

If an existing scripts/deploy.sh exists, produce a diff:

  • Stages to add (new services or infrastructure detected since last run)
  • Stages to remove (services removed)
  • Stages to update (ports, commands, or endpoints changed)
  • Stages unchanged

Phase 3: Execute

  1. Write or update scripts/deploy.sh (create the scripts/ directory if needed)
  2. Script structure:
    • #!/usr/bin/env bash
    • set -euo pipefail
    • Each stage is a function: stage_N_name()
    • Each stage prints --- Stage N: <name> --- before running
    • On success: prints PASS: <check>
    • On failure: prints FAIL: <check> and exits immediately
    • Final line on success: echo "DEPLOY OK"
    • The set -e flag handles fail-fast automatically
  3. Run chmod +x scripts/deploy.sh

Phase 4: Verify

  1. Run ./scripts/deploy.sh
  2. Confirm it exits 0 with DEPLOY OK
  3. If it fails, diagnose and fix the script (not the project code — the script should reflect reality)
  4. Report result to user

Guidelines

  • Deploy only — No static analysis, linting, typechecking, or tests. CI handles verification.
  • Idempotent — Safe to run repeatedly. No side effects beyond temporary files (cleaned up).
  • Only deploy what's implemented — Never include services that aren't wired up yet.
  • Fast — Prefer offline stages, but if the feature being tested requires network (e.g., fetching exchange data), include it. Guard network stages with a credentials check — if credentials aren't configured, prompt the user interactively (via read -p) and continue. Never persist credentials or silently skip functional stages.
  • Language-agnostic — Detect Python/Node/Go/Rust/etc. patterns from config files. Don't hardcode for any language.
  • Portable — Use POSIX-compatible bash. Avoid platform-specific commands where possible.
  • Minimal output on success — Each stage prints its name and PASS/FAIL. No verbose logs unless a stage fails.
  • No project code changes — The skill only creates/updates scripts/deploy.sh. It never modifies source code, tests, or configuration.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.