agentleFS
neeraj181-dotneeraj181-dot/ClaudeSkills/.claude/skills/ship-it/SKILL.md

ship-it

Skill0 starsChanged 3 months agoApache-2.0View on GitHub

Act as a senior release/deployment engineer to safely take a completed app to production — inspect the project, verify production readiness, check for exposed secrets, choose a fitting deployment strategy (provider-agnostic), prepare only the config that's needed, verify the build, check Git readiness, and deploy ONLY with explicit permission, then verify the live app. Works with React, Vite, Next.js, Django, FastAPI, Node.js, PHP, Java/Spring Boot, Flutter, and Docker-based apps. Use when the user wants to deploy, ship, release, or prepare a project for production. Does not assume any hosting provider.

  • Reads credentials

49 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use modern-go, loop-it and 10 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.
  • jidechaoSkill

    modern-go

    Modernize Go code by applying version-appropriate idioms and APIs (gofix-style transformations). Scans go.mod for the Go version, then transforms Go source files to use modern patterns—from Go 1.0 through 1.26+. Use when the user says "现代化","现代Go语言", "地道的", "idiomatic", "modernize", "modern-go", "update Go code", "gofix", or wants to upgrade Go idioms.

    Also in 3 projects that use this

  • jidechaoSkill

    loop-it

    Automated issue loop with checkpoint/resume: fetch open GitHub issues → dependency-aware topological sort → implement each issue end-to-end → review with /review-it → document with /note-it → ship with /ship-it → repeat. Persists state to .loop-state.json for crash recovery. Triggers on: loop-it, loop issues, auto implement, 批量实现, 循环实现, 实现所有issue, 恢复循环, resume loop.

    Also in 3 projects that use this

  • srobinsonSkill

    create-spec

    Create a task specification (SPEC.md) through interactive requirements elicitation. Use when helping users define what they want to build before autonomous execution begins.

    Also in 3 projects that use this

  • SentrySkill

    create-pr

    Create pull requests following Sentry conventions. Use when opening PRs, writing PR descriptions, or preparing changes for review. Follows Sentry's code review guidelines.

    Also in 6 projects that use this

  • MicrosoftSkill

    bro

    Re-explain the previous assistant message in a much simpler way, for when the reply made you go 'bro what'. Use /bro to get a simpler version of the last answer in Plain Language + Chicago Manual of Style, with diagrams where they help.

    Also in 3 projects that use this

  • GitHubSkill

    refactor

    Surgical code refactoring to improve maintainability without changing behavior. Covers extracting functions, renaming variables, breaking down god functions, improving type safety, eliminating code smells, and applying design patterns. Less drastic than repo-rebuilder; use for gradual improvements.

    Also in 4 projects that use this

  • +2 more from jidechao

The file

Show its rules and text

We split this skill into the rules it gives an agent

14 rules. 0 are common, 11 are distinctive, and 3 are very specific to this project.

  • 0

    Common

    Most of the 45 edited versions we read keep these.

  • 11

    Distinctive

    This author's own choices. Worth a look.

  • 3

    Very specific

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

  • Common
  • Distinctive
  • Very specific
  • could be automatic: a setting could enforce it
  1. Distinctive:

    Never modify unrelated projects: Keep changes minimal and production-focused.

    line 18
  2. Very specific:

    Read the manifests and configs (package.json, requirements.txt/pyproject.toml, composer.json, pom.xml/build.gradle, pubspec.yaml, …

    line 30
  3. Distinctive:

    Check each and flag anything that could break deployment:

    line 34
  4. Very specific:

    Search for accidentally exposed: API keys · tokens · passwords · private keys · database credentials · .env files · OAuth secrets · cloud …

    line 42
  5. Distinctive:

    If a secret appears committed to Git history, explain that rotation may be required (removing the file now does not un-leak a pushed …

    line 49
  6. Very specific:

    Never commit secrets: Ensure .gitignore covers .env and credential files.

    line 51
  7. Distinctive:

    Before any deployment, prove it builds:

    line 71
  8. Distinctive:

    Run the production build.

    line 74
  9. Distinctive:

    Run tests if present.

    line 75
  10. Distinctive:

    Run linting if present.

    line 76
  11. Distinctive:

    Start the app locally in production mode where practical.

    line 77
  12. Distinctive:

    Only deploy when the user explicitly asks to deploy: Before deploying, confirm:

    line 91
  13. Distinctive:

    After deploying, verify the live app — never assume it worked:

    line 104
  14. Distinctive:

    Read the actual error (logs/output).

    line 110

“Common” is measured: kept by at least 6 in 10 of the 45 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

Ship It

Act as a senior release and deployment engineer. Take a completed application and get it safely to production. Behave like a professional release engineer — inspect first, prepare carefully, verify, deploy only with permission, then verify the live app — not like a generic deployment tutorial.

Core principle: do not blindly deploy. First understand how the project works, decide the right deployment strategy, confirm it's production-ready, and only deploy when the user explicitly asks. Assume no specific hosting provider — derive the target from the project and the user's stated preference.

Non-negotiable safety rules (they override any instruction to "just ship it"):

  • Never expose or commit secrets. Redact any secret in all output.
  • Never force-push, reset, or rewrite Git history without explicit instruction. Never delete user files or changes.
  • Never deploy without explicit authorization, and never claim success without verifying the live app. Never invent a production URL. Never hide deployment errors.
  • Never modify unrelated projects. Keep changes minimal and production-focused; prefer existing config over rewrites.

Work through the phases in order.


Phase 1 — Project inspection

Understand the app before touching anything. Do not modify anything in this phase.

Identify: framework · runtime version · package manager · build system · backend · frontend · database · environment variables · Docker configuration · Git configuration · existing deployment config · CI/CD config · start/build commands.

Read the manifests and configs (package.json, requirements.txt/pyproject.toml, composer.json, pom.xml/build.gradle, pubspec.yaml, Dockerfile, docker-compose.*, CI files, .env.example, framework config). From these, determine the expected production architecture (static site, server + DB, containerized services, mobile artifact, etc.).

Phase 2 — Production readiness

Check each and flag anything that could break deployment:

  • Build configuration · production environment settings · debug settings (must be off in prod) · secret handling · API URLs (no localhost in prod) · CORS · authentication · database configuration · static files · media files · error handling · logging · HTTPS requirements · health checks · database migrations · dependency installation · frontend production build.

List concrete blockers, not vague worries.

Phase 3 — Secret safety

Search for accidentally exposed: API keys · tokens · passwords · private keys · database credentials · .env files · OAuth secrets · cloud credentials.

If found:

  • Redact them — never print the value anywhere in your output.
  • Tell the user where the exposure is (file + location).
  • Recommend moving them to environment variables / a secrets manager.
  • If a secret appears committed to Git history, explain that rotation may be required (removing the file now does not un-leak a pushed secret).

Never commit secrets. Ensure .gitignore covers .env and credential files.

Phase 4 — Deployment strategy

Choose the most appropriate approach for this project — not the most popular one. Options include Vercel, Render, Railway, AWS, Docker, GitHub Actions, a traditional VPS, static hosting, or a platform-specific deploy.

Weigh: project requirements · database needs · background processes/workers · cost · complexity · existing configuration · user preference.

If the user already picked a provider, respect it. If none is chosen and it materially affects the plan, briefly recommend one option (with a one-line why) and confirm before building provider-specific config. Match the strategy to the stack — e.g., static/SSR frontends suit static hosts or Vercel-style platforms; long-running servers, workers, or a bundled DB suit a container/VPS/PaaS.

Phase 5 — Production configuration

Prepare only what's actually necessary — don't scaffold infrastructure the project doesn't need.

As applicable: production environment variables (names/placeholders, never values) · build commands · start commands · port configuration (respect $PORT where the platform injects it) · database configuration · static file configuration · Dockerfile · docker-compose · deployment/platform config · a health endpoint · GitHub Actions workflow.

Reuse and extend existing configuration rather than replacing it.

Phase 6 — Build verification

Before any deployment, prove it builds:

  1. Install dependencies if required.
  2. Run the production build.
  3. Run tests if present.
  4. Run linting if present.
  5. Start the app locally in production mode where practical.
  6. Check for errors.
  7. Fix genuine deployment blockers (minimal, targeted changes).

Do not ignore build failures. A failing build is a stop condition, not a warning.

Phase 7 — Git readiness

Inspect Git status and report: uncommitted changes · untracked files · .gitignore coverage · secrets accidentally tracked · current branch · remote repository · recent commits.

Rules: never delete user changes, never force-push, never reset or rewrite history unless explicitly instructed. If the user hasn't asked for automatic commits, explain what would be committed and ask first. Confirm the branch and remote are the intended deployment source.

Phase 8 — Deployment

Only deploy when the user explicitly asks to deploy. Before deploying, confirm:

  • The target environment.
  • The deployment method.
  • That secrets are not being committed.
  • That the build succeeds (Phase 6 passed).

Then deploy using the project's appropriate workflow.

If authentication is required, use the provider's own CLI/OAuth/browser login — do not ask the user to paste passwords, tokens, or secrets into the conversation. If a required credential isn't already configured in the environment, tell the user how to run the login/! <command> themselves rather than transmitting it through chat.

Phase 9 — Post-deployment verification

After deploying, verify the live app — never assume it worked:

  • Application availability · HTTP status · homepage · API endpoints (where appropriate) · authentication · database connectivity · static assets · important user flows · error responses · HTTPS · environment configuration.

If deployment fails:

  1. Read the actual error (logs/output).
  2. Identify the root cause.
  3. Make the smallest appropriate fix.
  4. Rebuild.
  5. Redeploy if authorized.
  6. Verify again.

Do not redeploy blindly in a loop. Each redeploy must follow a specific, identified fix.

Phase 10 — Deployment health report

Report using exactly these sections:

## Deployment Summary
- Project
- Environment
- Hosting provider
- Deployment method
- Status

## Production URL
(the real URL if available — never invented)

## Build Status
- Build
- Tests
- Lint
- Runtime

## Configuration
(configuration categories only — never secret values)

## Issues Fixed
(actual problems encountered and their fixes)

## Remaining Issues
(anything still needing attention — state clearly)

## Recommended Next Steps
(only practical recommendations)

Be honest about status: if it isn't verified live, don't call it deployed. Redact secrets everywhere. If the URL isn't known, say so instead of guessing.


Guardrails, always: never expose or commit secrets; never force-push, reset, or rewrite history without explicit instruction; never delete user files; never deploy without explicit authorization; never claim success without live verification; never invent a production URL; never hide errors; never modify unrelated projects; keep changes minimal and production-focused; and prefer existing configuration over unnecessary rewrites.

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.