Agent skill

Ship Loop

by LeoYeAI in LeoYeAI/openclaw-master-skills

Run a chained build→ship→verify→notify pipeline for multi-segment feature work.

MITAuto-check passed

Install Ship Loop

skills CLI
$ npx skills add LeoYeAI/openclaw-master-skills --skill ship-loop -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install LeoYeAI/openclaw-master-skills ship-loop --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/LeoYeAI/openclaw-master-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/ship-loop .claude/skills/ship-loop && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
ship-loop
GitHub stars
2.2k
Token cost
~3.8k tokens
SKILL.md length
897 words
Files
77 (incl. scripts)
Skills in repo
972
Repo updated
First seen
Licence
MIT

At a glance

Run a chained build→ship→verify→notify pipeline for multi-segment feature work.

  • Works in 5 steps: Repeat failures — same error_signature… → Repair-heavy segments — segments that… → Efficiency trends — cost/time per… → …
  • Implementing multiple features in sequence
  • SKILL.md covers Architecture: Three Loops +…, Security Notice, When to Use and Prerequisites, plus 15 more sections
  • Runs JavaScript and TypeScript scripts from its folder; calls git and pip; reaches production-url.com

What it does

Ship Loop is an agent skill from LeoYeAI/openclaw-master-skills. Run a chained build→ship→verify→notify pipeline for multi-segment feature work. Use when implementing multiple features in sequence, each as a coding agent task that gets committed, deployed, and verified before moving to the next. Prevents dropped handoffs between segments.

Its SKILL.md is about 3.8k tokens, which your agent loads only when the skill is triggered. The skill folder holds 83 other files, including scripts (for example `CONTRIBUTING.md`, `README.md` and `_meta.json`).

It works with SQLite. The repository describes itself as: 🧠 Curated collection of 1209+ best OpenClaw skills — weekly updated by MyClaw.ai. The licence is MIT.

When your agent uses it

  • Implementing multiple features in sequence
  • Each as a coding agent task that gets committed
  • Verified before moving to the next

Example prompts

  • “/ship-loop”

Requirements

  • Python 3
  • Node.js

Workflow steps

5 steps, taken from the first numbered list in SKILL.md.

  1. Repeat failures — same error_signature across multiple segments/runs
  2. Repair-heavy segments — segments that needed >1 repair loop (same error type)
  3. Efficiency trends — cost/time per segment trending up or down
  4. Stale learnings — learnings with score < 0.3 that haven't helped
  5. Decision gaps — situations that triggered MISSING_DECISION_BRANCH

What it can do on your machine

Read from SKILL.md and the folder at commit e5199b5. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 1 file in scripts/ (JavaScript and TypeScript, from the files we listed), which the agent can run.

    Shell commands in SKILL.md call:

    • git
    • pip

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • production-url.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Ship Loop loads about 3.8k tokens when it runs. Until then it costs about 71 tokens; SKILL.md has 897 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~71
When it runs · the whole SKILL.md, loaded when a task matches
~3.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from LeoYeAI/openclaw-master-skills at commit e5199b5, republished under its MIT licence (© LeoYeAI). 897 words, ~3,781 tokens.

Download SKILL.mdSave it as .claude/skills/ship-loop/SKILL.md (or your agent's skills folder). This skill also uses 76 other files; get the full folder from GitHub.
name
ship-loop
description
Run a chained build→ship→verify→notify pipeline for multi-segment feature work. Use when implementing multiple features in sequence, each as a coding agent task that gets committed, deployed, and verified before moving to the next. Prevents dropped handoffs between segments.

Ship Loop v5.0 — TARS Convergence

Orchestrate multi-segment feature work as a self-healing pipeline. Three nested loops ensure maximum autonomy: Loop 1 runs the standard code→preflight→ship→verify chain, Loop 2 auto-repairs failures via the coding agent, Loop 3 spawns experiment branches when repairs stall. A SQLite state backend provides crash recovery and cross-run analytics. A verdict router replaces hardcoded branching with a configurable decision table. A reflection loop audits historical effectiveness and auto-generates learnings.

Architecture: Three Loops + Event Queue + Verdict Router

┌───────────────────────────────────────────────────────────┐
│                  SHIP LOOP v5.0                           │
│                                                           │
│  LOOP 1: Ship Loop                                        │
│  code → preflight → ship → verify → emit(segment_shipped)│
│          │                                                │
│       on fail (verdict → action via VerdictRouter)        │
│          ▼                                                │
│  LOOP 2: Repair Loop                                      │
│  capture context → agent fix → re-preflight (max N)      │
│  ↳ emit events: repair_done | repair_failed               │
│  ↳ convergence detected → CONVERGED verdict → META        │
│  ↳ unknown error → record_decision_gap()                  │
│          │                                                │
│       exhausted                                           │
│          ▼                                                │
│  LOOP 3: Meta Loop                                        │
│  meta-analysis → N experiment branches → winner → merge   │
│  ↳ emit: meta_done                                        │
│                                                           │
│  🗄  SQLite (tars.db): runs, segments, events, learnings  │
│  📋  Event Queue: crash recovery via unprocessed events   │
│  🔀  Verdict Router: configurable verdict→action table    │
│  📚  Learnings Engine: scored lessons (score tracks use)  │
│  🪞  Reflect Loop: post-run analysis + recommendations    │
│  💰  Budget Tracker: token/cost tracking per run          │
└───────────────────────────────────────────────────────────┘

Security Notice

SHIPLOOP.yml is equivalent to running a script. The agent_command, all preflight commands (build, lint, test), and custom deploy scripts execute with your full user privileges. Ship Loop does not sandbox these commands. Never use on untrusted repos without reviewing the config. Treat SHIPLOOP.yml with the same caution as a Makefile or CI pipeline.

When to Use

  • Building multiple features for a project in sequence
  • Any work that follows: code → preflight → commit → deploy → verify → next
  • When you need checkpointing so progress survives session restarts
  • When you want self-healing: failures auto-repair before asking humans
  • When you want cost visibility and learning from past runs

Prerequisites

  • Python 3.10+ with pyyaml and pydantic installed
  • A git repository with a remote
  • A deployment pipeline triggered by push (Vercel, Netlify, etc.)
  • A coding agent CLI configured via agent_command in SHIPLOOP.yml

Installation

bash
pip install pyyaml pydantic

CLI Usage

bash
# Core pipeline
shiploop run              # Start or resume the pipeline
shiploop run --dry-run    # Preview what would happen
shiploop status           # Show segment states (reads from DB)
shiploop reset <segment>  # Reset a segment to pending

# Learnings
shiploop learnings list
shiploop learnings search "dark mode theme toggle"

# Budget
shiploop budget           # Show cost summary

# v5.0 NEW
shiploop reflect          # Run meta-reflection on recent run history
shiploop reflect --depth 20  # Analyze last 20 runs
shiploop events           # View event history for latest run
shiploop events <run_id>  # View event history for specific run
shiploop history          # View past run history from DB

# Options
shiploop -c /path/to/SHIPLOOP.yml run
shiploop -v run           # Verbose logging
shiploop --version        # Show version (5.0.0)

Pipeline Definition (SHIPLOOP.yml)

yaml
project: "Project Name"
repo: /absolute/path/to/project
site: https://production-url.com
branch: pr               # direct-to-main | per-segment | pr
mode: solo

agent_command: "claude --print --permission-mode bypassPermissions"

preflight:
  build: "npm run build"
  lint: "npm run lint"
  test: "npm run test"

deploy:
  provider: vercel        # vercel | netlify | custom
  routes: [/, /api/health]
  marker: "data-version"
  health_endpoint: /api/health
  deploy_header: x-vercel-deployment-url
  timeout: 300

repair:
  max_attempts: 3

meta:
  enabled: true
  experiments: 3

budget:
  max_usd_per_segment: 10.0
  max_usd_per_run: 50.0
  max_tokens_per_segment: 500000
  halt_on_breach: true

# v5.0 NEW: Reflection config
reflection:
  enabled: true       # run reflect loop after pipeline
  auto_run: true      # automatically run, not just on CLI command
  history_depth: 10   # how many past runs to analyze

# v5.0 NEW: Custom verdict routing
router:
  agent_fail: retry      # override default (fail) with retry
  deploy_fail: fail      # override default (retry) with fail

segments:
  - name: "feature-name"
    status: pending
    prompt: |
      Your coding agent prompt here.
    depends_on: []

SQLite State Backend (v5.0)

State is now stored in .shiploop/tars.db (SQLite, WAL mode). SHIPLOOP.yml is config-only.

Tables
TablePurpose
runsPipeline execution records (id, project, started_at, status, cost)
segmentsSegment execution records per run (status, commit, touched_paths)
run_eventsEvent queue for crash recovery and audit trail
learningsFailure/success lessons with effectiveness scores
usageToken and cost records per agent invocation
decision_gapsSituations the system didn't know how to handle
Event Types
EventWhen emitted
agent_startedAgent invocation begins
preflight_passedAll preflight steps pass
preflight_failedAny preflight step fails
repair_doneRepair loop succeeded
repair_failedRepair loop failed or exhausted
meta_doneMeta loop winner merged
segment_shippedSegment fully complete
segment_failedSegment permanently failed
deploy_failedDeploy or verification failed
file_overlap_warningSegment may touch files changed by prior segment

Crash recovery: On startup, unprocessed events are replayed to restore pipeline state.

Verdict Router (v5.0)

The orchestrator no longer uses if/else chains. Every outcome maps to a Verdict, and a VerdictRouter maps verdicts to Action values.

Default Routing Table
VerdictDefault Action
successship
preflight_failrepair
agent_failfail
deploy_failretry
repair_successship
repair_exhaustedmeta
meta_successship
meta_exhaustedfail
budget_exceededfail
convergedmeta ← skip remaining repairs, jump to meta
no_changesfail
unknownpause_and_alert

Override via router: section in SHIPLOOP.yml (see above).

Meta-Reflection Loop (v5.0)

Runs automatically after pipeline completion (when reflection.auto_run: true) or manually via shiploop reflect.

What It Analyzes
  1. Repeat failures — same error_signature across multiple segments/runs
  2. Repair-heavy segments — segments that needed >1 repair loop (same error type)
  3. Efficiency trends — cost/time per segment trending up or down
  4. Stale learnings — learnings with score < 0.3 that haven't helped
  5. Decision gaps — situations that triggered MISSING_DECISION_BRANCH
Auto-creates learnings from patterns

If an error signature appears 3+ times across runs, the reflect loop auto-generates a AUTO-<sig> learning flagging it for human review.

bash
shiploop reflect --depth 20

═════════════════════════════════════════════════════
🪞  Ship Loop Reflection Report
   Generated: 2026-03-27T06:30:00Z
   Runs analyzed: 10
═════════════════════════════════════════════════════

📊 Efficiency
   Total cost:     $12.4200
   Segments run:   8
   Avg/segment:    $1.5525

🔁 Repeat Failures (2)
   abc123def456… × 3
   ...

💡 Recommendations
   ⚠️  Error signature abc123de… repeated 3× across segments: auth, api, db.
   📉 2 stale learning(s) (score < 0.3): L002, L004.
   ✅ No issues detected in recent history. Pipeline looks healthy!

═════════════════════════════════════════════════════
Show full SKILL.md (380 more words)Show less

Playbook Evolution (v5.0)

When a repair fails with an error that doesn't match any existing learning, the system records a decision_gap:

python
learnings.record_decision_gap(
    segment="auth",
    context="Repair exhausted with unmatched error: ...",
    verdict="repair_exhausted_unknown_error",
    run_id="...",
)

Decision gaps surface in shiploop reflect output and the decision_gaps DB table. Operators use them to add new learnings or router overrides.

Convergence Detection (v5.0 Enhanced)

Same-segment: if two consecutive repair attempts produce the same error hash → CONVERGED verdict → router jumps to META (skipping remaining repair attempts).

Cross-segment: before starting a segment, the orchestrator checks if any already-shipped segment touched the same files (via touched_paths in DB). If overlap detected, a file_overlap_warning event is emitted.

Learnings Scoring (v5.0)

score (default 1.0)
  +0.1 when injected and segment succeeds first-try
  -0.2 when injected and segment fails the same way

Search results are sorted by combined keyword-relevance × score. Learnings with score < 0.3 are flagged as stale in reflection.

bash
shiploop learnings list  # shows all learnings with scores

State Machine

States per segment:
  pending → coding → preflight → shipping → verifying → shipped
                  ↘ repairing (Loop 2) → preflight
                  ↘ experimenting (Loop 3) → preflight → shipping
                  ↘ failed

SHIPLOOP.yml checkpointed after every transition (for backward compat). SQLite is the primary state store.

Deploy Providers

ProviderHow it works
vercelPolls routes for HTTP 200, checks x-vercel-deployment-url header
netlifyPolls routes for HTTP 200, checks x-nf-request-id header
customRuns deploy.script with SHIPLOOP_COMMIT and SHIPLOOP_SITE env vars

Budget Tracking

Token usage and estimated costs tracked per agent invocation in SQLite (falls back to metrics.json).

bash
shiploop budget

💰 Budget Summary: Portfolio
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
  Total cost:       $3.84
  Budget remaining: $46.16
  Total records:    12

  By segment:
    dark-mode: $0.42
    contact-form: $3.42
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Critical Rules

  1. Never break the chain — after a segment ships, immediately start the next
  2. Preflight is mandatory — no exceptions, no "ship now fix later"
  3. Explicit staging only — never git add -A, only changed files from git diff
  4. Prompts via file — never shell arguments (prevents injection)
  5. SQLite is source of truth — SHIPLOOP.yml config-only; runtime state in tars.db
  6. Agent command from config — always read from agent_command, never hardcode
  7. Budget-aware — track costs, enforce limits, fail gracefully

Project Structure

skills/ship-loop/
├── SKILL.md                  # This file
├── pyproject.toml
├── shiploop/
│   ├── __init__.py           # __version__ = "5.0.0"
│   ├── cli.py                # CLI (run, status, reset, reflect, events, history, ...)
│   ├── config.py             # SHIPLOOP.yml parsing + validation (Pydantic v2)
│   ├── orchestrator.py       # Main state machine + event queue + verdict routing
│   ├── db.py                 # NEW: SQLite state backend (tars.db)
│   ├── router.py             # NEW: Verdict→Action router
│   ├── learnings.py          # Learnings engine (SQLite + scoring + decision gaps)
│   ├── budget.py             # Cost/token tracking (SQLite backend)
│   ├── git_ops.py            # git operations + get_touched_paths()
│   ├── agent.py              # Agent runner
│   ├── deploy.py             # Deploy verification
│   ├── preflight.py          # Build + lint + test runner
│   ├── reporting.py          # Status messages + reports
│   ├── ship_utils.py         # Ship and verify helper
│   └── loops/
│       ├── ship.py           # Loop 1: code → preflight → ship
│       ├── repair.py         # Loop 2: repair + decision gap detection
│       ├── meta.py           # Loop 3: meta-analysis + experiments
│       ├── reflect.py        # NEW: post-run reflection + recommendations
│       └── optimize.py       # Optimization loop
├── providers/
│   ├── vercel.py
│   ├── netlify.py
│   └── custom.py
└── tests/
    ├── test_config.py
    ├── test_orchestrator.py
    ├── test_git_ops.py
    ├── test_budget.py
    ├── test_learnings.py
    └── ...

Changelog

v5.0.0 (2026-03-27) — TARS Convergence
  • SQLite state backend: tars.db replaces metrics.json + learnings.yml for runtime state
  • Event queue: all phase transitions emit events; unprocessed events enable crash recovery
  • Verdict router: configurable Verdict → Action table replaces if/else chains in orchestrator
  • Meta-reflection loop: shiploop reflect analyzes run history, finds patterns, auto-generates learnings
  • Playbook evolution: MISSING_DECISION_BRANCH detection → decision_gaps table
  • Cross-segment convergence: touched_paths tracked per segment for overlap warnings
  • Learnings scoring: score field (+0.1 on success, -0.2 on failure), sorted by score
  • New CLI commands: reflect, events, history
  • New config sections: reflection, router
v4.0.0
  • Python CLI replaces bash scripts
  • Pydantic v2 config validation
  • Budget tracking with per-segment and per-run limits
  • Error convergence detection (hash-based)
  • Deploy provider plugins (Vercel, Netlify, Custom)

© LeoYeAI, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 76 other files (scripts) in skills/ship-loop of LeoYeAI/openclaw-master-skills.

  • SKILL.md
  • CONTRIBUTING.md
  • README.md
  • _meta.json
  • docs/README.md
  • docs/astro.config.mjs
  • docs/package-lock.json
  • docs/package.json
  • docs/public/favicon.svg
  • docs/src/content.config.ts
  • docs/src/content/docs/concepts/architecture.md
  • docs/src/content/docs/concepts/budget.md
  • docs/src/content/docs/concepts/learnings.md
  • docs/src/content/docs/getting-started/installation.md
  • … and 63 more

Open the folder on GitHubat commit e5199b5

Compare with similar skills

Ship Loop next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Ship Loop compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Ship Loop this skillLeoYeAI/openclaw-master-skills2.2k—~3.8kAutomated safety check: PassMIT
MCP Server BuildershareAI-lab/learn-claude-code78k5 repos~1.2kAutomated safety check: PassMIT
Copilot Session Failure Analysisdotnet/maui23k—~3.4kAutomated safety check: PassMIT
RTK Rust Design Patternsrtk-ai/rtk83k—~1.9kAutomated safety check: PassApache-2.0
OpenWork Desktop CDP Driverdifferent-ai/openwork24k—~465Automated safety check: PassCustom licence
OpenRig Upgrade Proceduremvschwarz/openrig5.9k1 repos~2.9kAutomated safety check: PassApache-2.0

Similar skills

  • MCP Server Builder

    shareAI-lab/learn-claude-code

    Walks through building MCP servers in Python or TypeScript that expose tools, resources and prompts to Claude, with templates, registration and testing.

    78k GitHub starsUsed in 5 repos~1.2k tokens
    Agent WorkflowsAuto-check passed
  • Mines local Copilot CLI session logs for dotnet/maui to rank costly or failing runs, tag recurring failure modes, propose repo edits and emit guard evals.

    23k GitHub stars~3.4k tokensUpdated today
    Agent WorkflowsAuto-check passed
  • Describes seven Rust design patterns for the RTK CLI filter modules, with when to use each, RTK examples, and notes on when a pattern is overkill.

    83k GitHub stars~1.9k tokensUpdated today
    DevelopmentAuto-check passed
  • OpenWork Desktop CDP Driver

    different-ai/openwork

    Drives a running OpenWork desktop window over CDP from the shell to evaluate JS, take screenshots, start sessions and send prompts for hand checks.

    24k GitHub stars~465 tokensUpdated today
    Testing & QAAuto-check passed
  • OpenRig Upgrade Procedure

    mvschwarz/openrig

    Walks an agent through upgrading the OpenRig CLI and daemon one observed step at a time, keeping live seats alive and reconciling managed plugin files.

    5.9k GitHub starsUsed in 1 repo~2.9k tokens
    DevOps & CloudAuto-check passed
  • Add Memory Kind

    EverMind-AI/EverOS

    Walks through adding a new persisted memory kind to EverOS: choose storage among Markdown, SQLite and LanceDB, pick a Markdown strategy, then wire schemas, repos and writers.

    13k GitHub stars~2.6k tokensUpdated yesterday
    DatabasesAuto-check passed

More from LeoYeAI/openclaw-master-skills

All 972 skills in this repo
  • DevOps Pipeline Management

    LeoYeAI/openclaw-master-skills

    Manages pipelines on a DevOps quality and efficiency platform through its OpenAPI: list workspaces and templates, create, update, run and cancel pipelines, and read run records.

    2.2k GitHub stars~4.2k tokensUpdated 2 mo ago
    Auto-check: notes
  • Feishu Document Collaboration

    LeoYeAI/openclaw-master-skills

    Patches OpenClaw's Feishu extension so an edited document triggers an isolated agent session that reads the doc and replies inline, turning it into a live chat space.

    2.2k GitHub stars~2k tokensUpdated 2 mo ago
    Auto-check passed
  • Files Memory System

    LeoYeAI/openclaw-master-skills

    Multi-context memory management system for OpenClaw agents with group-isolated storage, global shared memory, workspace organization, and group-specific skills isolation.

    2.2k GitHub stars~3.8k tokensUpdated 2 mo ago
    Auto-check passed
  • GEO-Claw AI Visibility Agent

    LeoYeAI/openclaw-master-skills

    Runs a brand's AI-search visibility work end to end: diagnosing how AI platforms represent it, repositioning it, producing AI-optimized content and monitoring ongoing mentions.

    2.2k GitHub stars~4.7k tokensUpdated 2 mo ago
    Auto-check passed
  • Google Workspace CLI

    LeoYeAI/openclaw-master-skills

    Installs and authenticates the gws CLI, then automates Gmail, Drive, Sheets, Calendar, Docs, Chat and Tasks with ready-made recipes, persona bundles and security audits.

    2.2k GitHub stars~2.6k tokensUpdated 2 mo ago
    Auto-check: notes
  • HealthFit Health Advisors

    LeoYeAI/openclaw-master-skills

    Runs four advisor roles, a fitness coach, nutritionist, data analyst and TCM practitioner, to build a health profile and track workouts, diet and wellness over time.

    2.2k GitHub stars~4.4k tokensUpdated 2 mo ago
    Auto-check passed

Works with

Questions about Ship Loop

What does Ship Loop do?

Run a chained build→ship→verify→notify pipeline for multi-segment feature work. Ship Loop is an agent skill from LeoYeAI/openclaw-master-skills. Run a chained build→ship→verify→notify pipeline for multi-segment feature work.

When should I use Ship Loop?

Ship Loop fits situations like: implementing multiple features in sequence; each as a coding agent task that gets committed; verified before moving to the next.

How do I install Ship Loop in Claude Code?

Run `npx skills add LeoYeAI/openclaw-master-skills --skill ship-loop -a claude-code`. Or copy the skill folder (skills/ship-loop in LeoYeAI/openclaw-master-skills) into .claude/skills/ship-loop in your project. Claude Code loads it when a task matches its description.

How do I install Ship Loop in Codex?

Run `npx skills add LeoYeAI/openclaw-master-skills --skill ship-loop -a codex`. Or copy the skill folder (skills/ship-loop in LeoYeAI/openclaw-master-skills) into .agents/skills/ship-loop in your project. Codex loads it when a task matches its description.

Can I use Ship Loop in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add LeoYeAI/openclaw-master-skills --skill ship-loop -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/ship-loop, .gemini/skills/ship-loop, .github/skills/ship-loop and .opencode/skills/ship-loop in your project.

What does Ship Loop need to run?

Going by SKILL.md and its folder, Ship Loop needs JavaScript and TypeScript for the scripts in its folder and the command-line tools its instructions call (git and pip). Our summary lists: Python 3; Node.js.

Does Ship Loop access the network?

SKILL.md names 1 domain. In commands or code: production-url.com; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Ship Loop safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Ship Loop use?

Ship Loop is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Ship Loop use?

About 3.8k tokens (SKILL.md is roughly 15k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Ship Loop?

Skills that share tags, products or a category with Ship Loop: MCP Server Builder (shareAI-lab/learn-claude-code, 78k stars), Copilot Session Failure Analysis (dotnet/maui, 23k stars), RTK Rust Design Patterns (rtk-ai/rtk, 83k stars) and OpenWork Desktop CDP Driver (different-ai/openwork, 24k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Ship Loop?

LeoYeAI (a GitHub user) maintains it in LeoYeAI/openclaw-master-skills, which has 2,159 GitHub stars. The repository holds 972 skills in this directory. The repository was last updated on July 20, 2026.

Source: LeoYeAI/openclaw-master-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.