New: 97,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

Official agent skill

Record Demo

by apify in apify/mcpc

Record or regenerate the mcpc demo GIFs (the README hero docs/images/mcpc-demo.gif and the focused tapes in docs/vhs/) with VHS.

OfficialApache-2.0Auto-check: notesAgent Workflows

Install Record Demo

skills CLI
$ npx skills add apify/mcpc --skill record-demo -a claude-code

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

GitHub CLI
$ gh skill install apify/mcpc record-demo --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/apify/mcpc.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/record-demo .claude/skills/record-demo && 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
record-demo
GitHub stars
981
Token cost
~3.3k tokens
SKILL.md length
1,429 words
Files
1
Skills in repo
2
Repo updated
First seen
Licence
Apache-2.0

At a glance

Record or regenerate the mcpc demo GIFs (the README hero docs/images/mcpc-demo.gif and the focused tapes in docs/vhs/) with VHS.

  • Works in 10 steps: mcpc — empty state (no sessions, no… → mcpc connect mcp.json:filesystem — local… → mcpc — session list (now shows the live… → …
  • Asked to create
  • SKILL.md covers The hero flow (mcpc-demo.tape), Style conventions (the current…, VHS gotchas (these will bite… and Stdio servers in a headless /…, plus 8 more sections
  • Calls ffmpeg, npx and npm; reaches mcp.apify.com; needs APIFY_TOKEN and GITHUB_TOKEN

What it does

Record Demo is an agent skill from apify/mcpc, published by the product's own GitHub organization. Record or regenerate the mcpc demo GIFs (the README hero docs/images/mcpc-demo.gif and the focused tapes in docs/vhs/) with VHS. Use whenever asked to create, refresh, restyle, shorten, or fix a terminal demo/animation/GIF of mcpc. The tapes drive real mcpc commands; for the authenticated step this skill ALWAYS prompts for a short-lived, low-permission TEST token first (never production). Captures the VHS + mcpc gotchas learned the hard way — read it fully before editing a tape.

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

It sits in Agent Workflows, covering MCP servers. It works with Apify, Model Context Protocol and Bash. The repository describes itself as: The most compatible MCP CLI client: tools, resources, prompts, completions, async tasks, skills, and notifications over stdio and Streamable HTTP (MCP 2026-07-28 and 2025-11-25)… The licence is Apache-2.0.

When your agent uses it

  • Asked to create
  • Fix a terminal demo/animation/GIF of mcpc

Example prompts

  • “/record-demo”

Requirements

  • Node.js
  • A credential in APIFY_TOKEN
  • Pre-approved tools (allowed-tools): Bash, Read, Write, Edit, AskUserQuestion

Workflow steps

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

  1. mcpc — empty state (no sessions, no profiles)
  2. mcpc connect mcp.json:filesystem — local stdio server (auto-names @filesystem)
  3. mcpc — session list (now shows the live session)
  4. mcpc @filesystem tools-list
  5. mcpc @filesystem tools-list --json — JSON output, syntax-highlighted, no jq
  6. mcpc connect mcp.apify.com -H "Authorization: Bearer $APIFY_TOKEN" — remote HTTP server (auto-names @apify)
  7. mcpc @apify tools-list
  8. mcpc @apify tools-get search-actors — inspect one tool's input schema
  9. mcpc @apify tools-call search-actors keywords:="web scraper" limit:=3
  10. mcpc @apify close

What it can do on your machine

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

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Bash
    • Read
    • Write
    • Edit
    • AskUserQuestion

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • ffmpeg
    • npx
    • npm
    • pnpm
    • openssl
    • ffprobe

    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:

    • mcp.apify.com

    Also links to:

    • github.com
    • console.apify.com
    • kornel.ski

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

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • APIFY_TOKEN
    • GITHUB_TOKEN

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

Context cost

Record Demo loads about 3.3k tokens when it runs. Until then it costs about 124 tokens; SKILL.md has 1,429 words of instructions outside code blocks.

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

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: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Bash, Read, Write, Edit, AskUserQuestion

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 apify/mcpc at commit 7edff31, republished under its Apache-2.0 licence (© apify). 1,429 words, ~3,292 tokens.

Download SKILL.mdSave it as .claude/skills/record-demo/SKILL.md (or your agent's skills folder).
name
record-demo
description
Record or regenerate the mcpc demo GIFs (the README hero docs/images/mcpc-demo.gif and the focused tapes in docs/vhs/) with VHS. Use whenever asked to create, refresh, restyle, shorten, or fix a terminal demo/animation/GIF of mcpc. The tapes drive real mcpc commands; for the authenticated step this skill ALWAYS prompts for a short-lived, low-permission TEST token first (never production). Captures the VHS + mcpc gotchas learned the hard way — read it fully before editing a tape.
allowed-tools
Bash, Read, Write, Edit, AskUserQuestion

record-demo: VHS demo GIFs for mcpc

The tapes in docs/vhs/*.tape are VHS scripts that drive a real shell session — VHS types each command, runs it against a live MCP server, captures the terminal, and renders a GIF. The README hero is docs/images/mcpc-demo.gif, built from docs/vhs/mcpc-demo.tape.

This file is the accumulated know-how. Read all of it before touching a tape — most rules below were discovered by hitting the wall, and skipping them wastes whole render cycles (~1–2 min each).

The hero flow (mcpc-demo.tape)

A basic-use story across both transports:

  1. mcpc — empty state (no sessions, no profiles)
  2. mcpc connect mcp.json:filesystem — local stdio server (auto-names @filesystem)
  3. mcpc — session list (now shows the live session)
  4. mcpc @filesystem tools-list
  5. mcpc @filesystem tools-list --json — JSON output, syntax-highlighted, no jq
  6. mcpc connect mcp.apify.com -H "Authorization: Bearer $APIFY_TOKEN" — remote HTTP server (auto-names @apify)
  7. mcpc @apify tools-list
  8. mcpc @apify tools-get search-actors — inspect one tool's input schema
  9. mcpc @apify tools-call search-actors keywords:="web scraper" limit:=3
  10. mcpc @apify close

Ten commands run ~45s; there is no hard 30s cap for this flow.

Style conventions (the current standard — match these)

  • No # comments in the visible script. The commands are self-descriptive.
  • No | head, no 2>/dev/null on visible commands. Show real output even if long — it scrolls naturally. (connect ≈ 86 lines incl. an "Available commands" list, tools-call search-actors ≈ 56, filesystem tools-list --json ≈ 300.)
  • Continuous session — never clear between steps. Put a single blank-line Enter before each command (after the first) so it's separated from the previous output, like a real terminal session.
  • Colored prompt + bold-white typed commands. In the hidden setup block:
    Type 'export PS1="\[\e[1;38;2;25;230;77m\]$\[\e[0m\] \[\e[1;97m\]"'
Enter
Type "trap 'tput sgr0' DEBUG"
Enter
    • PS1 is a bold bright-green $, then ends with \[\e[1;97m\] so the typed input renders bold bright-white.
    • The DEBUG trap runs tput sgr0 before every command so the bold-white input does not bleed into command output.
  • Empty state needs a clean home — hidden: Type 'export MCPC_HOME_DIR="$(mktemp -d)"' so mcpc shows "No active MCP sessions / No OAuth profiles".
  • Color is automatic for non-piped commands — mcpc detects the TTY and emits color (256-color, plenty vivid). You only need export FORCE_COLOR=3 (+ COLORTERM=truecolor for exact hex) when a command is piped (mcpc turns color off when stdout isn't a TTY). The current tapes avoid pipes, so they don't need it. (The CLI palette lives in src/cli/output.ts, RAINBOW_SATURATION, bumped to 78% for vividness — that's where the demo colors come from.)

VHS gotchas (these will bite you)

  • ASCII prompt symbols only. Multibyte glyphs (❯, », ▶) break bash prompt rendering under VHS and show up as garbage like 92m]. Use $ (or >), styled with color + bold.
  • Type quoting: use single quotes around any command containing double quotes. A \" inside a double-quoted Type breaks VHS's parser. e.g. Type 'mcpc @apify tools-call search-actors keywords:="web scraper" limit:=3' and Type 'export PS1="\[\e[…m\]$\[\e[0m\] "'.
  • Output/Screenshot paths: must not start with a digit (Output 1-foo.gif fails to parse) and must not be long absolute paths (the parser chokes). Use short, letter-leading, relative names and run vhs from docs/vhs/.
  • Screenshot is unreliable (frequently exits 2 even though the GIF rendered fine). Don't depend on it — pull frames from the finished GIF instead: ffmpeg -y -ss <seconds> -i x.gif -vframes 1 frame.png, then Read the PNG.
  • Renders are slow (~1–2 min each: real-time timeline + Chromium + ffmpeg encode). Render tapes one at a time — a for loop over several blows the 5-minute command timeout. Extracted frames often land mid-typing; sample a few timestamps around when output should be on screen.
  • Hidden connects leak into the recording if bash falls behind. When a tape connects in the hidden setup (so the feature commands run against a ready session, e.g. tools/scripting/grep), a slow connect lets VHS type ahead; bash then echoes the buffered commands and runs the clear after Show, so the setup spills into frame. Pattern that works: type the connect(s), then one generous Sleep (7–8s) so they finish, then clear, then another Sleep (~1.5s) before Show. (Tapes that connect visibly as their first command don't need this — their hidden setup is just fast exports + clear.)

Stdio servers in a headless / proxied box

  • npx-launched stdio servers are too slow here. npx -y <pkg>'s registry round-trip exceeds mcpc's 60s connect handshake, so connect times out (MCP error -32001). Fixes: pre-install the server (npm i -g <pkg>) and put the direct binary in mcp.json (e.g. mcp-server-filesystem, starts in ~0.3s — also a cleaner session header), or use npx --prefer-offline -y <pkg> once the npm cache is warm (~5s; plain npx -y still does the slow registry check even when cached).
  • Puppeteer does NOT work for headless recording. @modelcontextprotocol/server-puppeteer launches Chromium eagerly on startup and hangs/times out as root in the container. Use @modelcontextprotocol/server-filesystem instead (14 recognizable tools, instant). docs/vhs/mcp.json defines the filesystem entry via its global binary — install it first: npm i -g @modelcontextprotocol/server-filesystem.

Auth token (the authenticated step)

  • Always prompt for the token first. Insist on a short-lived, low-permission token from a TEST / throwaway account — never production. Apify: https://console.apify.com/settings/integrations. Tell the user to revoke it as soon as the recording is done.
  • Pass it inline, for the render only: APIFY_TOKEN=… vhs mcpc-demo.tape. The tape references $APIFY_TOKEN (never the literal), typed inside single quotes so bash expands it at run time — the value is never on screen, never in the GIF, never committed. Always verify a connect frame shows $APIFY_TOKEN, not the value.
  • connect auto-names the session: mcp.apify.com → @apify, mcp.json:filesystem → @filesystem. No @name needed.
  • No-token alternative (public, anonymous): mcpc connect "https://mcp.apify.com/?tools=search-actors,fetch-actor-details,docs".
Show full SKILL.md (536 more words)Show less

Skills demo server (skills.tape, security.tape)

No public server serves the MCP Skills extension yet, so skills.tape records against the e2e test server (test/e2e/server/index-v2.ts, 2026-07-28, which serves the git-workflow / refunds / daily skill fixtures) under the name mcp.example.com. mcpc forces HTTPS for non-localhost hosts, so front it with TLS:

bash
WITH_SKILLS=true PORT=13456 pnpm exec tsx test/e2e/server/index-v2.ts &
echo "127.0.0.1 mcp.example.com" >> /etc/hosts
openssl req -x509 -newkey rsa:2048 -nodes -keyout key.pem -out cert.pem -days 2 \
  -subj "/CN=mcp.example.com" -addext "subjectAltName=DNS:mcp.example.com"
# then run any small HTTPS → http://127.0.0.1:13456 reverse proxy on 127.0.0.1:443
export NODE_EXTRA_CA_CERTS="$PWD/cert.pem" NO_PROXY="mcp.example.com,$NO_PROXY"
cd docs/vhs && vhs skills.tape

The connect stays hidden: its output names the test server ("e2e-test-server").

Keychain warning (headless only)

On a box with no keyring, the bearer-token connect prints [keychain] OS keychain unavailable, falling back to file-based credential storage …. It is environment-specific (won't appear on a normal desktop with a keyring) and there is no env var to suppress it — it's a logger.warn in src/lib/auth/keychain.ts gated only by keychain availability and JSON mode. A dbus-run-session + gnome-keyring-daemon wrapper does not fix it in this sandbox (raising the dbus fd limit is blocked). Options: leave it (honest), or add a targeted 2>/dev/null to just that one connect command.

Prerequisites

bash
mcpc --version            # the CLI being demoed (npm i -g @apify/mcpc, or build + pnpm link this repo)
vhs --version             # brew install vhs (needs ttyd + ffmpeg on PATH)
mcp-server-filesystem     # npm i -g @modelcontextprotocol/server-filesystem (the stdio demo server)

Headless + root: VHS drives a Chromium (go-rod auto-downloads it to ~/.cache/rod) that refuses to start without --no-sandbox. If renders fail to launch Chromium, wrap the binary once:

bash
CHROME=$(find ~/.cache/rod/browser -name chrome -type f | head -1)
mv "$CHROME" "$CHROME-real"
printf '#!/bin/sh\nexec "$(dirname "$0")/chrome-real" --no-sandbox --disable-gpu --disable-dev-shm-usage "$@"\n' > "$CHROME"
chmod +x "$CHROME"

(Run vhs once first to trigger the Chromium download.)

Render and verify

bash
cd docs/vhs
APIFY_TOKEN=…   vhs mcpc-demo.tape                                   # real-time; be patient
ffprobe -v error -show_entries format=duration -of csv=p=0 mcpc-demo.gif   # check length
ffmpeg -y -ss 12 -i mcpc-demo.gif -vframes 1 /tmp/f.png             # spot-check a frame, then Read it
cp mcpc-demo.gif ../images/mcpc-demo.gif                            # update the README hero

Check each frame class: empty state, stdio connect + session list, tools-list, JSON, remote connect (token NOT visible), tool-call result, close. Then revoke the token.

Optimize the GIF size (do this before committing)

VHS GIFs are large (the hero is ~5 MB raw). Shrink them losslessly-ish with gifsicle (kornel.ski/lossygif) — --lossy drops imperceptible inter-frame detail and cuts ~60% off a text-terminal GIF with no visible quality loss:

bash
# in place; lossy=200 ≈ 60% smaller, text stays crisp (verified by frame diff)
for f in docs/images/mcpc-demo.gif docs/vhs/*.gif; do
  [ "$f" = docs/vhs/mcpc-demo.gif ] && continue   # ignored raw hero
  gifsicle -O3 --lossy=200 -b "$f"
done

After optimizing, re-extract a colored frame (ffmpeg -ss 12 …) and eyeball it — lossy=200 is the sweet spot; going much higher smears the antialiased text. When the optimized hero lands on main, bump the README cache-buster (mcpc-demo.gif?v=N → ?v=N+1): GitHub's camo image proxy caches by full URL, so a new ?v= is what makes it re-fetch the smaller file instead of serving the old cached copy.

What's committed

  • docs/images/mcpc-demo.gif — the README hero (canonical copy).
  • docs/vhs/*.gif — the per-feature recordings are committed too, so they're easy to find and reuse. .gitignore ignores only docs/vhs/mcpc-demo.gif (the hero's raw output, since it's committed under docs/images/).
  • proxy.gif needs a token to record and isn't committed until recorded.

The tapes

TapeRecords
mcpc-demo.tapeHero basic-use flow (stdio + remote) → docs/images/mcpc-demo.gif
quickstart.tapeMinimal connect → list → call
tools.tapetools-list / tools-get / tools-call, inline JSON, stdin
scripting.tape--json piped through jq (code mode)
grep.tapeDynamic tool discovery with mcpc grep across two sessions (Apify + filesystem)
proxy.tapeMCP proxy / AI sandboxing (keeps a bearer token on purpose)
skills.tapeMCP Skills extension: skills-list / skills-get / resources-directory-read against the e2e test server served as mcp.example.com
security.tapeAuto-discovery skipping a checked-in .mcp.json entry that reads ${GITHUB_TOKEN} (fixture: security.mcp.json, copied into a mktemp -d HOME so no real configs are discovered); needs mcp.example.com for the trusted entry

All focused tapes follow the same conventions as the hero (bold $ prompt, bold-white commands, no comments, blank-line separation, mktemp home). quickstart/tools/scripting/grep are token-free (public ?tools= URL); grep also connects a local filesystem stdio server so it can search across two sessions. proxy.tape keeps a bearer token because demonstrating that you can proxy a credentialed session without leaking the token is its entire point (it's the one focused tape that needs a token to record).

© apify, 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 skills/record-demo of apify/mcpc.

Open the folder on GitHubat commit 7edff31

Compare with similar skills

Record Demo 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.

Record Demo compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Record Demo this skillapify/mcpc981—~3.3kAutomated safety check: NotesApache-2.0
Crush Configurationcharmbracelet/crush29k—~3.7kAutomated safety check: PassCustom licence
Openspec AwareChorus-AIDLC/Chorus1.2k—~7.2kAutomated safety check: NotesAGPL-3.0
Ue Code AuthoringJasonMa0012/MooaToon749—~1.9kAutomated safety check: NotesCustom licence
Releasejgravelle/jcodemunch-mcp2.7k—~6.5kAutomated safety check: PassCustom licence
Tool Selectiondatabricks-solutions/ai-dev-kit1.9k—~519Automated safety check: PassCustom licence

Similar skills

  • Crush Configuration

    charmbracelet/crush

    Explains how to configure the Crush coding agent with crushrc or crush.json, covering providers, models, LSPs, MCP servers, hooks, permissions and config precedence.

    29k GitHub stars~3.7k tokensUpdated today
    Agent WorkflowsAuto-check passed

  • Openspec Aware

    Chorus-AIDLC/Chorus

    OpenSpec-mode authoring for Chorus PM workflows in Hermes. An agent skill from Chorus-AIDLC/Chorus.

    1.2k GitHub stars~7.2k tokensUpdated today
    Agent WorkflowsAuto-check: notes

  • Ue Code Authoring

    JasonMa0012/MooaToon

    A skill your agent uses when writing or modifying UE C++ (classes, actors, components, subsystems, interfaces, function libraries) with Rider MCP available.

    749 GitHub stars~1.9k tokensUpdated 19 days ago
    DevelopmentAuto-check: notes

  • Release

    jgravelle/jcodemunch-mcp

    Publishing a jMunch release (jcodemunch-mcp, jdocmunch-mcp, jdatamunch-mcp, jragmunch-cli), reviewing/merging/closing PRs, and responding to the community.

    2.7k GitHub stars~6.5k tokensUpdated today
    Agent WorkflowsAuto-check passed

  • Tool Selection

    databricks-solutions/ai-dev-kit

    Evaluates whether the agent selected appropriate MCP tools instead of shell workarounds.

    1.9k GitHub stars~519 tokensUpdated 1 mo ago
    Agent WorkflowsAuto-check passed

  • Orchard

    okooo5km/Skills4U

    Use the local Orchard app to interact with macOS Apple apps and services: Calendar, Reminders, Clock, Mail, Contacts, Notes, Music, Weather, Messages, Location/Maps, and Apple Shortcuts.

    183 GitHub stars~5k tokensUpdated today
    Agent WorkflowsAuto-check: warnings

More from apify/mcpc

  • Mcpc

    apify/mcpc

    Official

    Use the mcpc CLI to work with MCP (Model Context Protocol) servers from the shell - connect to a server as a persistent session, then list and call tools, read resources, get prompts, and run async…

    981 GitHub stars~3.5k tokensUpdated yesterday
    Auto-check passed

Works with

Categories

Questions about Record Demo

What does Record Demo do?

Record or regenerate the mcpc demo GIFs (the README hero docs/images/mcpc-demo.gif and the focused tapes in docs/vhs/) with VHS. Record Demo is an agent skill from apify/mcpc, published by the product's own GitHub organization.gif and the focused tapes in docs/vhs/) with VHS.

When should I use Record Demo?

Record Demo fits situations like: asked to create; fix a terminal demo/animation/GIF of mcpc.

How do I install Record Demo in Claude Code?

Run `npx skills add apify/mcpc --skill record-demo -a claude-code`. Or copy the skill folder (skills/record-demo in apify/mcpc) into .claude/skills/record-demo in your project. Claude Code loads it when a task matches its description.

How do I install Record Demo in Codex?

Run `npx skills add apify/mcpc --skill record-demo -a codex`. Or copy the skill folder (skills/record-demo in apify/mcpc) into .agents/skills/record-demo in your project. Codex loads it when a task matches its description.

Can I use Record Demo 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 apify/mcpc --skill record-demo -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/record-demo, .gemini/skills/record-demo, .github/skills/record-demo and .opencode/skills/record-demo in your project.

What does Record Demo need to run?

Going by SKILL.md and its folder, Record Demo needs the command-line tools its instructions call (ffmpeg, npx, npm, pnpm, openssl and ffprobe) and credentials named APIFY_TOKEN and GITHUB_TOKEN. Our summary lists: Node.js; A credential in APIFY_TOKEN. Its frontmatter pre-approves these tools: Bash, Read, Write, Edit, AskUserQuestion.

Does Record Demo access the network?

SKILL.md names 4 domains. In commands or code: mcp.apify.com; the agent is likely to contact it when it follows the instructions. As links in the text: github.com, console.apify.com and kornel.ski. This is read from the text; nothing was executed.

Is Record Demo safe to install?

Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Record Demo use?

Record Demo 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 Record Demo use?

About 3.3k tokens (SKILL.md is roughly 13k 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 Record Demo?

Skills that share tags, products or a category with Record Demo: Crush Configuration (charmbracelet/crush, 29k stars), Openspec Aware (Chorus-AIDLC/Chorus, 1.2k stars), Ue Code Authoring (JasonMa0012/MooaToon, 749 stars) and Release (jgravelle/jcodemunch-mcp, 2.7k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Record Demo?

apify (a GitHub organization, an official publisher) maintains it in apify/mcpc, which has 981 GitHub stars. The repository holds 2 skills in this directory. The repository was last updated on October 6, 2026.

Source: apify/mcpc on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.