More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    carveout

    1

    Hand one part of a closed TypeScript repository to a contractor or an agent as a folder that installs, builds and tests on its own, and take a checked patch back. They never see the rest.

    Free

    Security scanned

    carveout

    Example session with this skill installed

    Hand packages/jira/src/selection-jql.ts to a contractor. They must not see the rest of the repository.

    • Read your context and instructions
    • Compiled the carveout

    Planned the slice and showed you what goes out before writing anything, then cut it:

    $ carveout handoff packages/jira/src/selection-jql.ts
    Verdict: ready: it installs, builds, and its tests pass before any edit
    Tests: 15 of 15 test(s) pass before any edit
    Shows 15 files, 2,980 lines
    Names: 3 rename(s) hide the repository's
    

    15 files out of 709: the entry point, its test, and 13 pure modules copied so the test runs on real code. Everything else it touches is a .d.ts stub with a recording mock. Send the folder without node_modules and keep the receipt.

    When the work comes back

    $ carveout patch ../returned --output change.patch
    carveout: 2 changed, 0 new and 0 deleted files
    

    A shortcut is held before anything runs it:

    $ carveout patch ../returned
    carveout: kept out:
      packages/jira/src/selection-jql.ts,
      could pass a test without the code passing it
      (process.execArgv matched against a test runner)
    exit 6
    

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

    About this skill

    To let someone outside work on one feature of a closed repository, you usually give them the whole repository, CI secrets and all. carveout gives them one folder instead: the files the change needs, at their repository paths, with every module it imports from the rest replaced by a .d.ts stub and a recording mock. The folder installs, builds and runs its tests on its own, and the work comes back as a patch you read before anything runs it.

    On a 245,000-line repository, the median slice showed 0.7% of it (11% with tests and pure code). 52 of 52 real commits replayed through a slice came back as patches that apply, and 6 of 6 agents working in a sealed folder shipped a patch that passed the owner's hidden tests.

    What it does

    • Plans before it cuts. plan lists every file that would go out; you agree it, and --private keeps a folder closed.
    • Hands off at a fixed scope. handoff cuts, checks and says whether the folder is ready: its tests pass before any edit. A TASK.md says what the work is and when it is accepted.
    • Hides whose code it is. A public cut writes the folder in pseudonyms: package names, scopes, authors and the remote are renamed, under a table that maps back byte for byte.
    • Takes the work back safely. patch turns the returned folder into a patch without running any of its code, and holds CI, hook, manifest and lockfile edits, weakened or deleted tests, code that spots a test run, and new reach.
    • Runs your hidden acceptance tests against the returned work, in a container with no network.
    • Keeps a long job going. refresh brings in the repository's new commits; widen cuts wider, with the work kept.

    Requirements

    Node 22.12 or later, git and npm, in a TypeScript repository (npm, pnpm or Yarn workspaces; node:test or Vitest). Docker to run a returned folder's code. The skill runs the open-source carveout CLI from npm (MIT) and asks before installing it. No model calls: the CLI is deterministic.

    Limits

    TypeScript only. A Jest test is left out of the slice and named. Under Node, an eager import.meta.glob of modules finds nothing.

    TypeScript only: a slice with JavaScript sources is cut but reported as unsupported. Jest tests are left out of a slice and named. Under Node, an eager import.meta.glob of modules finds nothing. With pnpm or Yarn, versions come from the package.json files rather than a lockfile.

    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

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 5 days ago

    • Free with an Agensi account

    Requires

    Node.js
    Git
    npm

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access

    Terminal: runs the open-source carveout CLI (MIT, npm), pinned to a version; the skill asks before installing it. Network: the npm registry, for the CLI and for online cuts that check which packages are public. Files: reads the repository and writes the slice folder you choose; a returned folder's code runs only in Docker, with no network, or not at all. No model calls.

    Listed5 days ago

    What's inside

    Frequently Asked Questions

    By performing static analysis on your import graph, the skill isolates only the code necessary for a feature to run, replacing sensitive internal dependencies with secure, mocked stubs. This allows you to hand off specific tasks to the AI or external talent without sharing your entire proprietary monorepo.

    Any coding agent that loads SKILL.md skills and can run a terminal command: Claude Code, Codex, Cursor, Copilot and others. It needs Node 22.12+, git and npm, in a TypeScript repository using npm, pnpm or Yarn, with node:test or Vitest tests.

    The slice is computed, not guessed: carveout walks the import graph with the TypeScript compiler, writes a .d.ts stub and a recording mock for every module the slice imports from the rest, and checks that the folder installs, builds and passes its tests before it goes out. The CLI makes no model calls.

    `patch` turns the returned folder into a patch without running any of its code, and holds CI, hook, manifest and lockfile edits, weakened or deleted tests, code that could pass a test without the code passing it, and new network or disk reach. `check --accept` then runs your own hidden acceptance tests against it, in a container with no network. Read the patch, apply it on a branch, and let your CI decide.

    The skill is one SKILL.md: the steps your agent follows. It runs the open-source carveout CLI from npm (MIT), pinned to a version, and asks before installing it. Everything is free.

    Only TypeScript is stubbed; a slice that includes JavaScript sources is cut but reported as unsupported. Tests run under node:test or Vitest; a Jest test is left out of the slice and named. An eager import.meta.glob of modules finds nothing under Node.

    New in Code Quality & Review