More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    /ship: 5-Agent Feature Pipeline for Claude Code

    1

    Runs a feature through planner, coder, tester, reviewer and documenter subagents and ends with a reviewed local commit

    Free

    1 useSecurity scanned
    /ship: 5-Agent Feature Pipeline for Claude Code

    /ship: 5-Agent Feature Pipeline for Claude Code

    Example session with this skill installed

    /ship add an endpoint that shows a logged-in user how much of their daily and monthly transaction limits they have already used

    • Read your context and instructions
    • Compiled the ship

    /ship run summary

    Condensed from a real run on a Java/Spring backend. Service, class and file names are generalized.

    Branch: feat/transaction-limit-usage in both services
    Final verdict: SHIP (round 2)
    Commits: one local commit per service on the feature branch. Nothing pushed or merged.

    Stages

    StageResult
    PlannerSpec with 4 open questions (which roles get access, what to show when an account isn't linked, how zero limits behave, what to return when the limits service is down). Run paused, I answered, run resumed.
    CoderChanges in 2 services, following each service's existing ports/adapters layout and router config style. Reused the existing Redis client and only added methods to it; no existing method was changed.
    TesterRESULT: PASS. 64 tests in service A, 158 in service B, including container tests on real PostgreSQL 14 and Redis 7.
    Reviewer (round 1)NEEDS WORK: 1 medium, 7 low findings, e.g. a predeploy permission check that missed wildcard routes, a non-JSON request answered with 500 instead of 415, a runtime error that should have returned 503.
    Reviewer (round 2)SHIP. All 8 resolved with file:line evidence; 2 low and 4 info items left as non-blocking notes.
    Documenter5 doc files: OpenAPI path + schema + index entry, an API guide, a README section. Post-docs check: only documentation changed, nothing reverted.

    Example reviewer finding (round 1)

    [MEDIUM] The predeploy SQL check only matched exact route strings. Real policies use Ant-style wildcards (/**, /*/**), so an overlapping wildcard permission would pass the check. Convert patterns the same way the gateway does and add tests for the wildcard cases.

    Non-blocking notes it left for me

    • Two services read the shared internal key from differently named environment variables. Pick one name.
    • Reset times use the JVM default zone in one service. Confirm the host timezone before deploy.

    Next steps

    1. Review the diff on feat/transaction-limit-usage.
    2. Run the predeploy check on staging before applying the seed.
    3. Push and open a PR when you're happy. /ship never does this for you.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    What it does

    /ship <feature request> takes one feature through five subagents, one after another. Each one does a single job and writes a small handoff file in .pipeline/ that the next one reads, so every stage starts with a clean, focused context.

    StageModelCan editWrites
    Planneropusonly its spec.pipeline/spec.md (files, signatures, edge cases, patterns to copy, open questions)
    Codersonnetcodecode + .pipeline/changes.md (starts with the repo conventions it found)
    Testersonnetteststests + .pipeline/test-results.md (RESULT: PASS/FAIL)
    Revieweropusnothing (read-only).pipeline/review.md (VERDICT: SHIP / NEEDS WORK / BLOCK)
    Documentersonnetdocs/ onlyOpenAPI spec, a "how it works" doc, Mermaid diagrams

    Why I built it

    When one agent plans, codes, tests and reviews a whole feature, it half forgets the plan, writes tests that agree with its own code, and then says everything looks fine. Splitting the work fixed most of that for me on real Java/Spring backend work.

    Rules it follows

    • Stops instead of guessing. Open questions in the spec, failing tests, or any verdict other than SHIP halt the run and come back to you.
    • Follows your codebase. The coder studies 2-3 similar existing features first (layers, package layout, naming, DTO and error shapes) and writes them down. No new APIs, controllers, services or dependencies unless the spec needs them.
    • Feature branch only. On main/dev/release it creates feat/<slug> first. It never commits to, merges into or pushes a protected branch. Subagents can't run branch or commit commands at all.
    • Ends with a local commit. Nothing is pushed or merged. You review the diff.
    • Docs come from the code. The documenter may only touch docs/, README and CHANGELOG; anything else it changes is reverted.

    What's in the zip

    • SKILL.md: the orchestrator
    • agents/: planner, coder, tester, reviewer, documenter definitions
    • LICENSE: MIT

    Install

    1. Unzip into ~/.claude/skills/ (you get ~/.claude/skills/ship/).
    2. Recommended: copy ship/agents/*.md into ~/.claude/agents/. Installed subagents get their tool limits enforced by Claude Code (read-only reviewer, no-code planner). Without them the skill still runs each stage with a general-purpose subagent and checks the limits itself.
    3. Restart Claude Code, open a git repo, and run /ship <feature request>.

    Limits

    It's not magic: read the spec it writes and review the diff. It needs a git repository and a project whose tests can run locally.

    Source and issues: https://github.com/Altafhossain72/claude-ship-pipeline

    Built for Claude Code; the five-stage delegation relies on Claude Code subagents. Needs a git repository and tests that can run locally. It stops and asks when the spec has open questions, so it is not fully hands-off. It never pushes or merges; you review the diff yourself.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    1 use

    Times used to date

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 28 days ago

    • Free with an Agensi account

    Requires

    Claude Code
    Git
    @redocly/cli
    Node.js

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    File Scopes

    .pipeline/**
    docs/**
    src/**

    Shell: runs git (status, diff, branch, local commit) and the project's own build/test commands. Read/Write files: reads the codebase, writes code, tests, docs/ and handoff files in .pipeline/. No network access, no environment variables, no external services.

    Listed28 days ago

    What's inside

    Frequently Asked Questions

    One agent doing planning, code, tests and review in one long context tends to forget the plan and approve its own work. Here each stage is a separate subagent with one job and a clean context, and they hand off through small files in .pipeline/. The reviewer is read-only and checks the real git diff against the spec.

    Recommended, not required. Copy ship/agents/*.md into ~/.claude/agents/ so Claude Code enforces each role's tool limits (for example the read-only reviewer). Without them, the skill runs each stage with a general-purpose subagent using the same role instructions and checks the limits itself.

    No. On main, dev or a release branch it creates feat/<slug> first, and the run ends with a local commit on that branch. It never pushes, merges or opens a PR. That stays with you.

    That is the coder's first job. Before writing code it studies 2-3 similar features in your repo (layering, package layout, naming, DTO and error shapes) and lists them at the top of .pipeline/changes.md. It does not add new APIs, controllers, services or dependencies unless the spec asks for them, and the reviewer flags duplicates as NEEDS WORK.

    The tester writes RESULT: FAIL with the failing output to .pipeline/test-results.md and the run stops there. It does not patch the production code to make tests pass. You decide what to fix, then run /ship again.

    SKILL.md (the orchestrator), the five subagent definitions in agents/, and an MIT license. It is free, and the same files are on GitHub: github.com/Altafhossain72/claude-ship-pipeline

    New in Agents & Orchestration