New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

SDK Parity

by ALT-F4-LLC in ALT-F4-LLC/vorpal

Test parity between Rust, Go, and TypeScript SDK builds by comparing artifact digests

Apache-2.0Auto-check passed

Install SDK Parity

skills CLI
$ npx skills add ALT-F4-LLC/vorpal --skill sdk-parity -a claude-code

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

GitHub CLI
$ gh skill install ALT-F4-LLC/vorpal sdk-parity --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/ALT-F4-LLC/vorpal.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/sdk-parity .claude/skills/sdk-parity && 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
sdk-parity
GitHub stars
124
Token cost
~2.7k tokens
SKILL.md length
1,071 words
Files
1
Skills in repo
2
Repo updated
First seen
Licence
Apache-2.0

At a glance

Test parity between Rust, Go, and TypeScript SDK builds by comparing artifact digests

  • Works in 12 steps: Parse Arguments → Validate Artifact Name → Prepare Lima VM (Linux-Only Artifacts) → …
  • SKILL.md covers Usage, Instructions, Prerequisites and Notes, plus 2 more sections
  • Calls make, go and python

What it does

SDK Parity is an agent skill from ALT-F4-LLC/vorpal. Test parity between Rust, Go, and TypeScript SDK builds by comparing artifact digests

Its SKILL.md is about 2.7k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It works with Rust, TypeScript and Linux. The repository describes itself as: Build system that works as code. The licence is Apache-2.0.

Example prompts

  • “/sdk-parity”

Requirements

  • Python 3

Workflow steps

12 steps, taken from the step headings in SKILL.md.

  1. Parse Arguments
  2. Validate Artifact Name
  3. Prepare Lima VM (Linux-Only Artifacts)
  4. Determine Socket Path
  5. Stop Any Existing Services
  6. Start Services
  7. Run Rust SDK Build
  8. Run Go SDK Build
  9. Run TypeScript SDK Build
  10. Stop Services
  11. Compare Digests
  12. Report Results

What it can do on your machine

Read from SKILL.md and the folder at commit 77ac6ad. 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

    Shell commands in SKILL.md call:

    • make
    • go
    • python

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

  • Network

    No URLs in SKILL.md.

    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

SDK Parity loads about 2.7k tokens when it runs. Until then it costs about 24 tokens; SKILL.md has 1,071 words of instructions outside code blocks.

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

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); files beside SKILL.md are not scanned.

SKILL.md

The full file from ALT-F4-LLC/vorpal at commit 77ac6ad, republished under its Apache-2.0 licence (© ALT-F4-LLC). 1,071 words, ~2,699 tokens.

Download SKILL.mdSave it as .claude/skills/sdk-parity/SKILL.md (or your agent's skills folder).
name
sdk-parity
description
Test parity between Rust, Go, and TypeScript SDK builds by comparing artifact digests

SDK Parity Testing

Test consistency between Rust, Go, and TypeScript SDK builds by comparing artifact digests.

Usage

/sdk-parity [artifact-name]

Default artifact: vorpal

Instructions

When this skill is invoked:

1. Parse Arguments

Extract the artifact name from the arguments. If no argument is provided, use vorpal as the default.

2. Validate Artifact Name

The artifact must be one of the following known artifacts:

  • vorpal-container-image (linux only)
  • vorpal-job
  • vorpal-process
  • vorpal-shell
  • vorpal-user
  • vorpal-website
  • vorpal

If the artifact name is not in this list, report an error and list the valid options.

3. Prepare Lima VM (Linux-Only Artifacts)

Classify the artifact:

  • Linux-only: vorpal-container-image
  • All platforms: all other artifacts

If the artifact is linux-only, run the following steps before starting services:

  1. Check if the vorpal-aarch64 Lima instance is running:
bash
limactl list --format '{{.Name}}:{{.Status}}' | grep 'vorpal-aarch64'
  1. If the instance is not running, start it:
bash
make lima
  1. Sync the project to the Lima VM:
bash
make lima-sync

If the artifact is not linux-only, skip this section entirely.

4. Determine Socket Path

The socket path is derived from the makefile variable VORPAL_SOCKET. It follows the pattern:

/tmp/vorpal-<directory-basename>.sock

where <directory-basename> is the basename of the current working directory (e.g., /tmp/vorpal-sdk-parity.sock). Run make -n -p | grep '^VORPAL_SOCKET' to confirm the exact value if needed.

For linux-only artifacts: The socket path follows the same pattern but exists inside the Lima VM. Commands that check or manipulate the socket must run via limactl shell vorpal-aarch64.

5. Stop Any Existing Services

Remove any existing socket file and kill associated processes to ensure a clean state.

For linux-only artifacts:

bash
limactl shell vorpal-aarch64 bash -c 'VORPAL_SOCK="/tmp/vorpal-vorpal.sock"; if [ -e "$VORPAL_SOCK" ]; then fuser -k "$VORPAL_SOCK" 2>/dev/null || true; rm -f "$VORPAL_SOCK"; fi'

For non-linux artifacts:

bash
VORPAL_SOCK="/tmp/vorpal-$(basename "$PWD").sock"
if [ -e "$VORPAL_SOCK" ]; then fuser -k "$VORPAL_SOCK" 2>/dev/null || true; rm -f "$VORPAL_SOCK"; fi
6. Start Services

For linux-only artifacts:

Start Vorpal services inside the Lima VM in the background using run_in_background: true:

bash
limactl shell vorpal-aarch64 bash -c "cd ~/vorpal && target/debug/vorpal system services start"

Then wait for the socket file to appear inside the VM (up to 60 seconds):

bash
VORPAL_SOCK="/tmp/vorpal-vorpal.sock"
for i in {1..60}; do limactl shell vorpal-aarch64 bash -c "[ -S \"$VORPAL_SOCK\" ]" && echo "Services ready after ${i}s" && break; [ $i -eq 60 ] && echo "ERROR: Services failed to start (socket not found inside Lima VM: $VORPAL_SOCK)" && exit 1; sleep 1; done

For non-linux artifacts:

Start Vorpal services in the background using run_in_background: true:

bash
make vorpal-start

Then wait for the socket file to appear (up to 60 seconds):

bash
VORPAL_SOCK="/tmp/vorpal-$(basename "$PWD").sock"
for i in {1..60}; do [ -S "$VORPAL_SOCK" ] && echo "Services ready after ${i}s" && break; [ $i -eq 60 ] && echo "ERROR: Services failed to start (socket not found: $VORPAL_SOCK)" && exit 1; sleep 1; done

If services fail to start, report the error and stop.

7. Run Rust SDK Build

For linux-only artifacts:

bash
limactl shell vorpal-aarch64 bash -c "cd ~/vorpal && target/debug/vorpal build <artifact-name>"

For non-linux artifacts:

bash
make VORPAL_ARTIFACT="<artifact-name>" vorpal

Capture the output and extract the digest from the build result. The digest appears in the output as a hash value.

8. Run Go SDK Build

For linux-only artifacts:

bash
limactl shell vorpal-aarch64 bash -c "cd ~/vorpal && target/debug/vorpal build --config 'Vorpal.go.toml' <artifact-name>"

For non-linux artifacts:

bash
make VORPAL_ARTIFACT="<artifact-name>" VORPAL_FLAGS="--config 'Vorpal.go.toml'" vorpal

Capture the output and extract the digest from the build result.

9. Run TypeScript SDK Build

For linux-only artifacts:

bash
limactl shell vorpal-aarch64 bash -c "cd ~/vorpal && target/debug/vorpal build --config 'Vorpal.ts.toml' <artifact-name>"

For non-linux artifacts:

bash
make VORPAL_ARTIFACT="<artifact-name>" VORPAL_FLAGS="--config 'Vorpal.ts.toml'" vorpal

Capture the output and extract the digest from the build result.

10. Stop Services

Always stop services after builds complete (whether successful or not).

For linux-only artifacts:

bash
limactl shell vorpal-aarch64 bash -c 'VORPAL_SOCK="/tmp/vorpal-vorpal.sock"; if [ -e "$VORPAL_SOCK" ]; then fuser -k "$VORPAL_SOCK" 2>/dev/null || true; rm -f "$VORPAL_SOCK"; fi'

For non-linux artifacts:

bash
VORPAL_SOCK="/tmp/vorpal-$(basename "$PWD").sock"
if [ -e "$VORPAL_SOCK" ]; then fuser -k "$VORPAL_SOCK" 2>/dev/null || true; rm -f "$VORPAL_SOCK"; fi
11. Compare Digests

Compare all extracted digests (Rust, Go, and TypeScript). All digests must match for the test to pass.

12. Report Results

Display a summary table:

## SDK Parity Test Results

| SDK        | Digest            |
|------------|-------------------|
| Rust       | <rust-digest>     |
| Go         | <go-digest>       |
| TypeScript | <ts-digest>       |

**Status:** PASS (digests match)

Or if they don't match:

**Status:** FAIL (digests differ)

If an SDK was skipped (e.g., TypeScript for vorpal-shell), note it in the table:

| TypeScript | skipped (not supported) |

Prerequisites

  • Vorpal.toml, Vorpal.go.toml, and Vorpal.ts.toml must exist in the working directory

Notes

  • Services are always started and stopped as part of the skill — never assume they are already running
  • Run builds sequentially (Rust first, then Go, then TypeScript) to avoid resource contention
  • If any build fails, stop services, report the failure, and do not attempt comparison
  • Extract the full digest hash from each build output for accurate comparison
  • Lima VM commands use vorpal-aarch64 which assumes Apple Silicon (aarch64). On x86_64 hosts, the VM name would be vorpal-x86_64 — adjust commands accordingly.
Show full SKILL.md (525 more words)Show less

Serializer fixture parity (offline, no services)

The build-based flow above exercises the full pipeline end-to-end. A second, lightweight arm validates only the digest-parity SERIALIZER against shared fixtures with NO running services. This is the load-bearing cross-SDK invariant: every SDK hand-writes a serializer and must produce byte-identical SHA-256 artifact digests for the same artifact definition.

Shared assets (additive home; new SDK arms extend, never rewrite):

  • sdk/python/tests/fixtures/digest-parity/artifacts.json — language-neutral artifact fixtures. Optional fields (digest, entrypoint, script) are presence-encoded: a key PRESENT (even "") means proto-present; a key ABSENT means proto-absent (serializes to null).
  • sdk/python/tests/fixtures/digest-parity/digests.json — golden digests produced by the canonical TypeScript reference serializer (serializeArtifact/computeArtifactDigest in sdk/typescript/src/context.ts) over those fixtures.

Python arm: python sdk/python/tests/test_parity.py builds each fixture as a proto Artifact, serializes via vorpal_sdk.context, and asserts the digest equals the golden. Exits 0 on parity, non-zero (with the produced JSON) on any mismatch. Also runnable under pytest.

Regenerating goldens (only after a deliberate, cross-SDK-coordinated format change): run the TS reference serializer over artifacts.json and overwrite the digest values in digests.json. Never edit a golden to match a single SDK in isolation — that hides a real cross-SDK divergence.

Coordination: the builder-output parity arm (DKT-19) extends this section additively with its own builder-input fixtures; it does not modify the serializer fixtures or goldens above.

Cross-SDK BUILDER parity (build-target Python — DKT-19)

The serializer arm above proves the digest serializer agrees across SDKs. This arm proves the builders agree: the same minimal Python build-target project, built through each SDK's Python language builder (python.rs / python.go / python.ts), produces byte-identical artifact digests per system. It is the build-target analogue of the build-based vorpal flow (steps 6-12 above) — same machinery, a Python artifact instead of vorpal. Distinct from:

  • the serializer-fixture parity arm above (offline, no builders), and
  • DKT-16's sdk/python builder-output arm (the Python SDK's own builder output), and DKT-20's cross-LANGUAGE config parity. This arm is cross-SDK BUILDER parity.

Fixture project: the vorpal init Python template (cli/src/command/template/python/) is the minimal build-target project — reuse it; do not author a parallel fixture. Build it once per SDK via the build flow above (steps 6-12), substituting the Python artifact name for vorpal, with Vorpal.toml / Vorpal.go.toml / Vorpal.ts.toml selecting the Rust/Go/TS builder.

Invariant: within one system, Rust == Go == TS digest (PASS). Cross-system divergence is EXPECTED and NOT a failure (native/compiled-extension deps differ per platform; TDD §Testing Strategy untested-claims) — assert same-system only.

The one adaptation beyond fixture + artifact name: steps 6-12 compare a single cross-SDK digest per run. Here, run the build/compare PER SYSTEM and group the comparison by ArtifactSystem — for each system, assert the Rust/Go/TS builder digests are identical; never compare digests across systems. Everything else (start services, build per-SDK, extract digest) is reused unchanged.

RUNTIME-GATED. This arm cannot run until both land:

  • the cpython / uv toolchain is published on sdk.vorpal.build (DKT-25 — the mirror returns 403 today), and
  • the pinned 3.13.14 interpreter + uv 0.10.11 are provisioned in the build env (DKT-21; cpython.rs / uv.rs are intentionally unpinned until capture). Until then the build fails closed at the C1 mint gate (unpinned - use --unlock), so a build-and-compare run is not yet meaningful. Run this arm as part of the vorpal build-flow validation once DKT-21/DKT-25 close; the version-equality invariant it depends on is enforced now by sdk/python/tests/test_version_equality.py.

© ALT-F4-LLC, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/sdk-parity of ALT-F4-LLC/vorpal.

Open the folder on GitHubat commit 77ac6ad

Compare with similar skills

SDK Parity 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.

SDK Parity compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
SDK Parity this skillALT-F4-LLC/vorpal124—~2.7kAutomated safety check: PassApache-2.0
UI UX Pro Maxfutureboard/futureboard-studio110—~5.6kAutomated safety check: PassMIT
Firecrawl Page Scrape Integrationfirecrawl/firecrawl190k1 repos~944Automated safety check: PassISC
Apple Container Test RunnerRustPython/RustPython22k—~467Automated safety check: PassMIT
Pnpm Engineteambit/bit18k—~1.9kAutomated safety check: PassCustom licence
Build Teaql Appteaql/teaql-agent-kit2.8k—~4.6kAutomated safety check: PassMIT

Similar skills

  • UI UX Pro Max

    futureboard/futureboard-studio

    Comprehensive design guide for web, mobile, and desktop applications.

    110 GitHub stars~5.6k tokensUpdated yesterday
    Frontend & DesignAuto-check passed

  • Firecrawl Page Scrape Integration

    firecrawl/firecrawl

    Adds Firecrawl's /scrape endpoint to application code to pull markdown, HTML, links, screenshots or structured data from a single known URL.

    190k GitHub starsUsed in 1 repo~944 tokens
    Data & AnalyticsAuto-check passed

  • Apple Container Test Runner

    RustPython/RustPython

    Runs RustPython tests inside a Linux container built with Apple's container CLI, so macOS users can compare Linux results with their local ones.

    22k GitHub stars~467 tokensUpdated today
    Testing & QAAuto-check passed

  • Pnpm Engine

    teambit/bit

    Work on the pnpm Rust engine (@pnpm/napi, the pacquet crates) that bit install runs through.

    18k GitHub stars~1.9k tokensUpdated today
    DevelopmentAuto-check passed

  • Build Teaql App

    teaql/teaql-agent-kit

    Build or change a TeaQL application in Java, Rust, Go, Swift, Python, C/.NET, or TypeScript, including Kotlin/JVM applications that consume Java-generated libraries.

    2.8k GitHub stars~4.6k tokensUpdated 14 days ago
    MobileAuto-check passed

  • Testing Changes

    pnpm/pnpm

    Run the tests that cover a change in the pnpm repository, in the Rust workspace (pnpm/, pnpr/) or the TypeScript CLI (pnpm11/), and recognize the cases where a scoped run passes without testing…

    37k GitHub stars~1.1k tokensUpdated today
    DevelopmentAuto-check passed

More from ALT-F4-LLC/vorpal

  • E2E Test

    ALT-F4-LLC/vorpal

    Run end-to-end tests that validate Vorpal services and client builds.

    124 GitHub stars~1.3k tokensUpdated yesterday
    Auto-check: notes

Works with

Questions about SDK Parity

What does SDK Parity do?

Test parity between Rust, Go, and TypeScript SDK builds by comparing artifact digests. SDK Parity is an agent skill from ALT-F4-LLC/vorpal.

How do I install SDK Parity in Claude Code?

Run `npx skills add ALT-F4-LLC/vorpal --skill sdk-parity -a claude-code`. Or copy the skill folder (.claude/skills/sdk-parity in ALT-F4-LLC/vorpal) into .claude/skills/sdk-parity in your project. Claude Code loads it when a task matches its description.

How do I install SDK Parity in Codex?

Run `npx skills add ALT-F4-LLC/vorpal --skill sdk-parity -a codex`. Or copy the skill folder (.claude/skills/sdk-parity in ALT-F4-LLC/vorpal) into .agents/skills/sdk-parity in your project. Codex loads it when a task matches its description.

Can I use SDK Parity 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 ALT-F4-LLC/vorpal --skill sdk-parity -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/sdk-parity, .gemini/skills/sdk-parity, .github/skills/sdk-parity and .opencode/skills/sdk-parity in your project.

What does SDK Parity need to run?

Going by SKILL.md and its folder, SDK Parity needs the command-line tools its instructions call (make, go and python). Our summary lists: Python 3.

Does SDK Parity access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is SDK Parity 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. Review the folder before installing.

What licence does SDK Parity use?

SDK Parity is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does SDK Parity use?

About 2.7k tokens (SKILL.md is roughly 11k 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 SDK Parity?

Skills that share tags, products or a category with SDK Parity: UI UX Pro Max (futureboard/futureboard-studio, 110 stars), Firecrawl Page Scrape Integration (firecrawl/firecrawl, 190k stars), Apple Container Test Runner (RustPython/RustPython, 22k stars) and Pnpm Engine (teambit/bit, 18k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains SDK Parity?

ALT-F4-LLC (a GitHub organization) maintains it in ALT-F4-LLC/vorpal, which has 124 GitHub stars. The repository holds 2 skills in this directory. The repository was last updated on October 9, 2026.

Source: ALT-F4-LLC/vorpal on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.