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

Jazz Performance

by garden-co in garden-co/classic-jazz

A skill your agent uses when optimizing Jazz applications for speed, responsiveness, and scalability.

MITAuto-check passedDatabases

Install Jazz Performance

skills CLI
$ npx skills add garden-co/classic-jazz --skill jazz-performance -a claude-code

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

GitHub CLI
$ gh skill install garden-co/classic-jazz jazz-performance --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/garden-co/classic-jazz.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.cursor/skills/jazz-performance .claude/skills/jazz-performance && 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
jazz-performance
GitHub stars
2.5k
Token cost
~1.9k tokens
SKILL.md length
585 words
Files
3 (incl. references)
Skills in repo
8
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when optimizing Jazz applications for speed, responsiveness, and scalability.

  • Works in 2 steps: Node-API Crypto (fastest) - Node.js,… → WASM Crypto - Edge runtimes See WASM
  • Optimizing Jazz applications for speed
  • SKILL.md covers When to Use This Skill, Do NOT Use This Skill For, Key Heuristic for Agents and Core Concepts, plus 8 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Jazz Performance is an agent skill from garden-co/classic-jazz. Use this skill when optimizing Jazz applications for speed, responsiveness, and scalability. Covers crypto setup, efficient data modeling, and UI patterns to prevent lag.

Its SKILL.md is about 1.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 3 other files, including reference files (for example `references/node-api.md` and `references/wasm.md`).

It sits in Databases, covering Database schema design. It works with React and WebAssembly. The repository describes itself as: A new kind of database that's distributed across your frontend, containers, serverless functions and its own storage cloud. The licence is MIT.

When your agent uses it

  • Optimizing Jazz applications for speed
  • Tasks that involve Database schema design

Example prompts

  • “/jazz-performance”

Requirements

  • Node.js

Workflow steps

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

  1. Node-API Crypto (fastest) - Node.js, Deno. See Node-API
  2. WASM Crypto - Edge runtimes See WASM

What it can do on your machine

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

    No scripts in the folder and no shell commands in SKILL.md (its code samples are typescript).

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

  • Network

    Links to these hosts (documentation or services it may open):

    • jazz.tools

    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

Jazz Performance loads about 1.9k tokens when it runs, and up to ~2.7k if it reads all its reference files. Until then it costs about 47 tokens; SKILL.md has 585 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~47
When it runs · the whole SKILL.md, loaded when a task matches
~1.9k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~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 garden-co/classic-jazz at commit 4f90501, republished under its MIT licence (© garden-co). 585 words, ~1,944 tokens.

Download SKILL.mdSave it as .claude/skills/jazz-performance/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
jazz-performance
description
Use this skill when optimizing Jazz applications for speed, responsiveness, and scalability. Covers crypto setup, efficient data modeling, and UI patterns to prevent lag.

Jazz Performance Optimization

When to Use This Skill

  • Diagnosing slowness: App feels heavy, loading >2 seconds, UI stutters during sync
  • Architecting Data Models: Choosing between CoValues and primitive Zod types
  • Bootstrapping Apps: Configuring crypto and WASM initialization
  • Scalability Issues: Slow loads with deep data nesting
  • UI Responsiveness: Re-render loops or heavy selectors

Do NOT Use This Skill For

  • Initial schema design (use jazz-schema-design skill unless performance is the concern)
  • Permission logic (use jazz-permissions-security)

Key Heuristic for Agents

If the user is asking about app speed, load times, UI lag, or choosing between scalar and collaborative types for performance reasons, use this skill.

Core Concepts

Performance in Jazz applications depends on three main factors: cryptographic initialization speed, data model efficiency, and UI rendering patterns. Optimizing requires understanding when to use collaborative types (CoValues) versus scalar types (Zod), managing group extension depth, and implementing efficient React/Svelte subscription patterns.

Cryptographic Initialization

In browsers and on mobile devices, the fastest crypto will automatically be initialised. On servers and edge runtimes, you should initialise crypto yourself to unlock maximum speed.

Priority
  1. Node-API Crypto (fastest) - Node.js, Deno. See Node-API
  2. WASM Crypto - Edge runtimes See WASM

Minimize Group Extensions

Problem: Deep dependency chains slow initial load. Avoid if not necessary.

ts
// ❌ SLOW: Inline CoValue creation creates a dependency chain
const task = Task.create({
  column: {
    board: { team: myTeam }
  }
});

// ✅ FASTER: Flat structure with references
const board = Board.create({ team: myTeam });
const column = Column.create({ board });
const task = Task.create({ column });
Use sameAsContainer

Apply for data that always shares parent permissions (UI state, tightly coupled data).

ts
import { setDefaultSchemaPermissions } from "jazz-tools";

setDefaultSchemaPermissions({
  onInlineCreate: "sameAsContainer",
});

USE EXTREME CAUTION: If you use sameAsContainer, you MUST be aware that the child and parent groups are one and the same. Any changes to the child group will affect the parent group, and vice versa. This can lead to unexpected behavior if not handled carefully, where changing permissions on a child group inadvertently results in permissions being granted to the parent group and any other siblings created with the same parent. As ownership cannot be changed, you MUST NOT USE sameAsContainer if you AT ANY TIME IN FUTURE may wish to change permissions granularly on the child group.

Best practice: Keep group extension depth under 3-4 levels.

Data Type Trade-offs

CoText vs. z.string()

Use CoText: Character-level collaborative editing (shared documents)
Use z.string(): Atomic updates (names, URLs, IDs, statuses)

Show full SKILL.md (236 more words)Show less
CoMap vs. z.object()

Use CoMap: Different users edit different keys simultaneously
Use z.object(): Single logical unit

ts
const Sprite = co.map({
  // ✅ FAST: Position updated as one unit
  position: z.object({ x: z.number(), y: z.number() }),
});

mySprite.$jazz.set('position', { x: 20, y: 30 });

UI Performance

Load what you need

Jazz automatically deduplicates subscriptions for you, meaning you can subscribe to data exactly where you need it.

Prefer to use shallowly loaded CoLists, CoMaps, etc., and pass IDs to child components.

tsx
const SomeItem = co.map({
  content: co.richText()
});
const SomeList = co.list(SomeItem);

// ❌ SLOW: List deeply loaded unnecessarily
const DisplayComponent = (props: { item: co.loaded<typeof SomeItem, {
  content: true
}> }) => {
  return <div>{props.item.content}</div>
}

const MyTopLevelComponent = () => {
  const ITEMS_PER_PAGE = 20;
  // **ALL list items are deeply loaded**
  const myDeeplyLoadedData = useCoState(SomeList, someListId, {
    resolve: {
      $each: {
        content: true
      }
    }
  });
  const [page, setPage] = useState(0);
  if (!myDeeplyLoadedData.$isLoaded) return <div>Loading...</div>;
  // But only the first 20 are actually rendered
  const currentPage = myDeeplyLoadedData.slice(
    page * ITEMS_PER_PAGE, 
    (page + 1) * ITEMS_PER_PAGE
  );
  return currentPage.map(item => <DisplayComponent key={item.$jazz.id} item={item} />)
}

// ✅ FAST: Deep loading only when a component is rendered
const DisplayComponent = (props: { itemId: string }) => {
  const myItem = useCoState(SomeItem, props.itemId, {
    resolve: {
      content: true
    }
  });
  if (!myItem.$isLoaded) return <div>Loading...</div>;
  return <div>{myItem.content}</div>
}

const MyTopLevelComponent = () => {
  const ITEMS_PER_PAGE = 20;
  const myShallowlyLoadedData = useCoState(SomeList, someListId);
  const [page, setPage] = useState(0);
  if (!myShallowlyLoadedData.$isLoaded) return <div>Loading...</div>;
  const currentPage = myShallowlyLoadedData.slice(
    page * ITEMS_PER_PAGE, 
    (page + 1) * ITEMS_PER_PAGE
  );
  return currentPage.map(item => <DisplayComponent key={item.$jazz.id} itemId={item.$jazz.id} />)
}

Performance Tip: Loading data where it's used (rather than passing deeply loaded data down) performs better because only rendered components trigger loads.

React: Avoiding Expensive Selectors

Selector functions run on every CoValue update, even when equalityFn prevents re-renders. Keep selectors lightweight—only track minimal dependencies. Move expensive operations to useMemo.

tsx
// ❌ SLOW: Expensive computation in selector
const project = useCoState(Project, id, {
  select: (p) => ({
    name: p.name,
    sortedTasks: p.tasks.sort(expensiveSort) // Runs on every update!
  })
});

// ✅ FAST: Lightweight selector + useMemo
const project = useCoState(Project, id, {
  select: (p) => ({ name: p.name, tasks: p.tasks }),
  equalityFn: (a, b) => a.name === b.name && a.tasks.length === b.tasks.length
});

const sortedTasks = useMemo(() => 
  project.tasks.sort(expensiveSort), 
  [project.tasks]
);

Quick Checklist

  • WASM initialized asynchronously with loading state
  • Using Node-API crypto where supported
  • sameAsContainer set for inline objects
  • CoText only for collaborative text, z.string() otherwise
  • CoMap only when keys edited independently, z.object() otherwise
  • React selectors thin, heavy work in useMemo
  • Group extension depth under 3-4 levels

Common Pitfalls

❌ Over-CoValueing: Every string/object as CoText/CoMap bloats sync

❌ Synchronous WASM: Blocks UI on load

❌ Deep Nesting: >4 levels without sameAsContainer

❌ Heavy Selectors: Expensive computation inside selector functions (selectors run on every CoValue update, even when equalityFn prevents re-renders)

Quick Reference

Fastest Load: z.string(), z.object(), sameAsContainer

Fastest Crypto: Node-API/WASM/RNCrypto

Smoothest UI: Thin selectors + useMemo (React)

Group Depth: Keep under 3-4 levels

References

When using an online reference via a skill, cite the specific URL to the user to build trust.

© garden-co, 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 2 other files (references) in .cursor/skills/jazz-performance of garden-co/classic-jazz.

  • SKILL.md
  • references/node-api.md
  • references/wasm.md

Open the folder on GitHubat commit 4f90501

Compare with similar skills

Jazz Performance 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.

Jazz Performance compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Jazz Performance this skillgarden-co/classic-jazz2.5k—~1.9kAutomated safety check: PassMIT
Effect TStellahq/opensession392—~3.7kAutomated safety check: PassMIT
Dotlottie WebLottieFiles/dotlottie-web892—~3.5kAutomated safety check: PassMIT
Edit Timeline StudioMartinDelophy/ai-video-editor907—~7kAutomated safety check: PassMIT
Develop Timeline Studio PluginMartinDelophy/ai-video-editor907—~989Automated safety check: PassMIT
Edit Timeline Studio BrowserMartinDelophy/ai-video-editor907—~2.6kAutomated safety check: PassMIT

Similar skills

  • Effect TS

    tellahq/opensession

    Write idiomatic Effect v4 TypeScript verified against the pinned effect@4.0.0-rc.112 source.

    392 GitHub stars~3.7k tokensUpdated today
    Testing & QAAuto-check passed

  • Dotlottie Web

    LottieFiles/dotlottie-web

    Implement Lottie animations using dotLottie runtimes (@lottiefiles/dotlottie-web and @lottiefiles/dotlottie-react).

    892 GitHub stars~3.5k tokensUpdated 2 days ago
    Media & CreativeAuto-check passed

  • Edit Timeline Studio

    MartinDelophy/ai-video-editor

    Analyze images, video, speech, motion, products, and websites; route local vision, audio, depth, tracking, matting, identity, and restoration models; auto-edit, replicate, enhance, caption, voice…

    907 GitHub stars~7k tokensUpdated 2 days ago
    Media & CreativeAuto-check passed

  • Develop Timeline Studio Plugin

    MartinDelophy/ai-video-editor

    Design, evaluate, implement, or review image and video generation connectors for Timeline Studio.

    907 GitHub stars~989 tokensUpdated 2 days ago
    Media & CreativeAuto-check passed

  • Edit Timeline Studio Browser

    MartinDelophy/ai-video-editor

    Use native WebMCP tools to edit the project open in Timeline Studio.

    907 GitHub stars~2.6k tokensUpdated 2 days ago
    Media & CreativeAuto-check passed

  • Fullstack Dev

    HHU3637kr/skills

    Full-stack backend architecture and frontend-backend integration guide.

    145 GitHub starsUsed in 3 repos~8.6k tokens
    Backend & APIsAuto-check: notes

More from garden-co/classic-jazz

All 8 skills in this repo

  • Jazz Testing

    garden-co/classic-jazz

    A skill your agent uses when you need to write, review, or debug automated tests for applications built on the Jazz framework.

    2.5k GitHub stars~1.6k tokensUpdated 1 mo ago
    Auto-check passed

  • Jazz UI Development

    garden-co/classic-jazz

    A skill your agent uses when building, debugging, or optimizing Jazz applications.

    2.5k GitHub stars~1.7k tokensUpdated 1 mo ago
    Auto-check passed

  • Benchmarking

    garden-co/classic-jazz

    A skill your agent uses when writing or running performance benchmarks for Jazz packages.

    2.5k GitHub stars~3.2k tokensUpdated 1 mo ago
    Auto-check passed

  • Jazz Permissions Security

    garden-co/classic-jazz

    A skill your agent uses when designing data schemas, implementing sharing workflows, or auditing access control in Jazz applications.

    2.5k GitHub stars~2.9k tokensUpdated 1 mo ago
    Auto-check passed

  • Jazz Schema Design

    garden-co/classic-jazz

    Design and implement collaborative data schemas using the Jazz framework.

    2.5k GitHub stars~3.2k tokensUpdated 1 mo ago
    Auto-check passed

  • Changeset

    garden-co/classic-jazz

    Generate changeset files for versioning and changelog management in this monorepo.

    2.5k GitHub stars~538 tokensUpdated 1 mo ago
    Auto-check passed

Works with

Categories

Questions about Jazz Performance

What does Jazz Performance do?

A skill your agent uses when optimizing Jazz applications for speed, responsiveness, and scalability. Jazz Performance is an agent skill from garden-co/classic-jazz. Use this skill when optimizing Jazz applications for speed, responsiveness, and scalability.

When should I use Jazz Performance?

Jazz Performance fits situations like: optimizing Jazz applications for speed; tasks that involve Database schema design.

How do I install Jazz Performance in Claude Code?

Run `npx skills add garden-co/classic-jazz --skill jazz-performance -a claude-code`. Or copy the skill folder (.cursor/skills/jazz-performance in garden-co/classic-jazz) into .claude/skills/jazz-performance in your project. Claude Code loads it when a task matches its description.

How do I install Jazz Performance in Codex?

Run `npx skills add garden-co/classic-jazz --skill jazz-performance -a codex`. Or copy the skill folder (.cursor/skills/jazz-performance in garden-co/classic-jazz) into .agents/skills/jazz-performance in your project. Codex loads it when a task matches its description.

Can I use Jazz Performance 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 garden-co/classic-jazz --skill jazz-performance -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/jazz-performance, .gemini/skills/jazz-performance, .github/skills/jazz-performance and .opencode/skills/jazz-performance in your project.

What does Jazz Performance need to run?

SKILL.md names no scripts, command-line tools or credentials: Jazz Performance is instructions for the agent only. Our summary lists: Node.js.

Does Jazz Performance access the network?

SKILL.md names 1 domain. As links in the text: jazz.tools. This is read from the text; nothing was executed.

Is Jazz Performance 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 Jazz Performance use?

Jazz Performance 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 Jazz Performance use?

About 1.9k tokens (SKILL.md is roughly 7.8k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 725 tokens, read only when the agent opens those files.

What are the alternatives to Jazz Performance?

Skills that share tags, products or a category with Jazz Performance: Effect TS (tellahq/opensession, 392 stars), Dotlottie Web (LottieFiles/dotlottie-web, 892 stars), Edit Timeline Studio (MartinDelophy/ai-video-editor, 907 stars) and Develop Timeline Studio Plugin (MartinDelophy/ai-video-editor, 907 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Jazz Performance?

garden-co (a GitHub organization) maintains it in garden-co/classic-jazz, which has 2,534 GitHub stars. The repository holds 8 skills in this directory. The repository was last updated on September 7, 2026.

Source: garden-co/classic-jazz on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.