Agent skill

Jazz UI Development

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

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

MITAuto-check passedDevelopment

Install Jazz UI Development

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

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

GitHub CLI
$ gh skill install garden-co/classic-jazz jazz-ui-development --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-ui-development .claude/skills/jazz-ui-development && 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-ui-development
GitHub stars
2.5k
Token cost
~1.7k tokens
SKILL.md length
670 words
Files
6 (incl. references)
Skills in repo
8
Repo updated
First seen
Licence
MIT

At a glance

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

  • Works in 3 steps: Check $isLoaded: Ensure you are checking… → Deep Loading: If nested data is missing,… → Provider Check: Ensure the component is…
  • Optimizing Jazz applications
  • SKILL.md covers When to Use This Skill, Do NOT Use This Skill For, Key Heuristic for Agents and Framework Guides, plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Jazz UI Development is an agent skill from garden-co/classic-jazz. Use this skill when building, debugging, or optimizing Jazz applications. It covers Jazz's bindings with various different UI frameworks, as well as how to use Jazz without a framework. Look here for details on providers and context, hooks and reactive data fetching, authentication, and specialized UI components for media and inspection.

Its SKILL.md is about 1.7k tokens, which your agent loads only when the skill is triggered. The skill folder holds 6 other files, including reference files (for example `references/expo.md`, `references/react-native.md` and `references/react.md`).

It sits in Development, covering Cross-platform mobile apps and Debugging. It works with React, JavaScript, React Native and Svelte. 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
  • Tasks that involve Cross-platform mobile apps
  • Tasks that involve Debugging

Example prompts

  • “/jazz-ui-development”

Workflow steps

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

  1. Check $isLoaded: Ensure you are checking if (coValue.$isLoaded) before rendering.
  2. Deep Loading: If nested data is missing, use resolve in your hook (e.g. useCoState(..., { resolve: { items: true } })).
  3. Provider Check: Ensure the component is wrapped in the appropriate .

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

    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

Jazz UI Development loads about 1.7k tokens when it runs, and up to ~7.8k if it reads all its reference files. Until then it costs about 90 tokens; SKILL.md has 670 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~90
When it runs · the whole SKILL.md, loaded when a task matches
~1.7k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~7.8k

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). 670 words, ~1,747 tokens.

Download SKILL.mdSave it as .claude/skills/jazz-ui-development/SKILL.md (or your agent's skills folder). This skill also uses 5 other files; get the full folder from GitHub.
name
jazz-ui-development
description
Use this skill when building, debugging, or optimizing Jazz applications. It covers Jazz's bindings with various different UI frameworks, as well as how to use Jazz without a framework. Look here for details on providers and context, hooks and reactive data fetching, authentication, and specialized UI components for media and inspection.

Jazz UI Development

When to Use This Skill

  • Building user interfaces that display or interact with Jazz data
  • Setting up authentication providers and contexts
  • Debugging reactivity, data loading, or sync issues in the UI
  • Optimizing performance of data subscriptions
  • Handling media (images, files) in the UI

Do NOT Use This Skill For

  • Defining data schemas (use jazz-schema-design)
  • Complex permission logic or sharing workflows (use jazz-permissions-security)
  • Testing questions (use jazz-testing)

Key Heuristic for Agents

Use this skill when the user asks about rendering data, handling user input, managing authentication state, or framework-specific integration (React, Svelte, etc.). If the issue is "data not appearing" but permissions are correct, look here for loading and subscription patterns.

Framework Guides

Select the guide for your specific framework:

Universal CoValue API

These APIs are available on all CoValue instances, regardless of the framework.

Core Properties

All CoValues (CoMaps, CoLists, etc.) have these properties directly on the instance:

  • $isLoaded (boolean): Returns true if the CoValue is fully loaded and ready to read.
  • .toJSON(): Returns a plain JavaScript object representation of the CoValue. Use this for debugging only, not for rendering.
The .$jazz Namespace

Every CoValue instance has a .$jazz property containing metadata and utility methods.

Metadata
  • .$jazz.id (ID<CoValue>): The globally unique ID of the CoValue (e.g., co_zXy...).
  • .$jazz.owner (Group): The Group that owns this CoValue. Access control is determined by membership in this group.
  • .$jazz.createdAt (number): Creation timestamp (ms since epoch).
  • .$jazz.createdBy (ID<Account> | undefined): ID of the creating account.
  • .$jazz.lastUpdatedAt (number): Last update timestamp (ms since epoch).
Loading & Inspection
  • .$jazz.loadingState ("loading" | "loaded" | "unavailable" | "unauthorized"): The current loading state.
  • .$jazz.ensureLoaded({ resolve: { ... } }): Waits for nested references to load. Returns a promise with a new instance where requested fields are guaranteed available.
ts
const detailedPost = await post.$jazz.ensureLoaded({
  resolve: {
    comments: {
      $each: {
        author: true 
      }
    }
  }
});
  • .$jazz.refs (CoMap/CoRecord only): Access nested CoValues as references (with IDs) without loading them.
  • .$jazz.has(key) (CoMap/CoRecord only): Checks if a key exists.
Subscription & Sync
  • .$jazz.subscribe(callback): Manually subscribe to changes. Returns an unsubscribe function. Prefer framework-specific hooks (e.g., useCoState) over this.
  • .$jazz.waitForSync(): Promise that resolves when changes are synced to peers. Useful for critical saves or logout flows.
Version Control
  • .$jazz.isBranched (boolean): Whether the CoValue is currently in a local branch.
  • .$jazz.branchName (string): The name of the current branch.
  • .$jazz.unstable_merge(): Merges a branch back into the main history.
Show full SKILL.md (263 more words)Show less

Working with Data Types

CoMap / CoRecord
  • Read: Access properties like a standard JS object (e.g., user.name).
  • Write:
    • .$jazz.set(key, value)
    • .$jazz.delete(key)
    • .$jazz.applyDiff(diff)
CoList
  • Read: Access by index (list[0]), iterate (map, forEach).
  • Write:
    • .$jazz.push(item)
    • .$jazz.unshift(item)
    • .$jazz.splice(...)
    • .$jazz.remove(index or predicate)
CoText (CoPlainText / CoRichText)
  • Read: toString() or use directly in template.
  • Write:
    • insertAfter(index, text)
    • deleteRange({ from, to })
    • .$jazz.applyDiff(newText)
CoFeed
  • Read: Iterate over feed.all (returns per-session feeds).
  • Write: .$jazz.push(item) (Append-only).
ts
// Subscribing to all entries across all accounts
const allEntries = Object.values(feed.perAccount).flatMap(accountFeed => Array.from(accountFeed.all));

// Pushing a new entry
feed.$jazz.push({ message: "Hello", timestamp: Date.now() });
DiscriminatedUnion
  • Read: Check the discriminator property (e.g. type) to narrow the type.
  • Write: Overwrite the property with a new object of the desired variant.
ts
const list = co.list(MyUnion);
const item = list[0];

if (item.type === "text") {
  console.log(item.value); // item is narrowed to TextVariant
} else if (item.type === "image") {
  console.log(item.image.$jazz.id); // item is narrowed to ImageVariant
}
FileStream
  • Read: Use toBlob() or consume chunks.
  • Write: Use createFromBlob(blobOrFile) or start(metadata) -> push(chunk) -> end().
ImageDefinition
  • Read: Use <Image> component (framework specific) or loadImageBySize.
  • Write: use the createImage function from jazz-tools/media
tsx
<Image imageId={productImage.$jazz.id} width={300} />

Troubleshooting

"Data not appearing" or "Value is undefined"
  1. Check $isLoaded: Ensure you are checking if (coValue.$isLoaded) before rendering.
  2. Deep Loading: If nested data is missing, use resolve in your hook (e.g. useCoState(..., { resolve: { items: true } })).
  3. Provider Check: Ensure the component is wrapped in the appropriate <JazzProvider />.
"Infinite re-render loops"
  1. Selector Stability: Ensure your select function in useCoState is stable or returns stable references.
  2. Expensive Selectors: Move computations to useMemo instead of doing them inside the select function.
  3. Equality Function: Use equalityFn to prevent unnecessary updates if the selected data hasn't changed semantically.
"Reactivity not triggering"
  1. Direct Mutations: Ensure you are using .$jazz.set() or .$jazz.push() instead of direct property assignment (e.g. obj.key = val won't sync).
  2. Deep Updates: Remember that updating a nested scalar doesn't trigger a change in the parent CoValue unless that parent property is replaced.

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

  • SKILL.md
  • references/expo.md
  • references/react-native.md
  • references/react.md
  • references/svelte.md
  • references/vanilla.md

Open the folder on GitHubat commit 4f90501

Compare with similar skills

Jazz UI Development 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 UI Development compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Jazz UI Development this skillgarden-co/classic-jazz2.5k—~1.7kAutomated safety check: PassMIT
React Devtoolssanity-io/sanity6.4k3 repos~2.1kAutomated safety check: PassMIT
Diagnosing Stacktrace SymbolicationPostHog/posthog40k—~2.2kAutomated safety check: PassCustom licence
Lunora Realtimeanolilab/lunora282—~2.7kAutomated safety check: PassCustom licence
API Designmargelo/react-native-skills175—~7.2kAutomated safety check: PassNone
Data Client Setupreactive/data-client2k—~2.2kAutomated safety check: PassApache-2.0

Similar skills

  • React Devtools

    sanity-io/sanity

    Official

    React DevTools CLI for AI agents. An agent skill from sanity-io/sanity.

    6.4k GitHub starsUsed in 3 repos~2.1k tokens
    MobileAuto-check passed
  • Official

    Help users debug PostHog Error Tracking stack-trace symbolication for any supported platform — JavaScript/TypeScript web, React Native (Hermes), Android (Proguard / R8), or iOS / macOS (dSYM).

    40k GitHub stars~2.2k tokensUpdated today
    MobileAuto-check passed
  • Lunora Realtime

    anolilab/lunora

    Wires Lunora's live data into a client app. An agent skill from anolilab/lunora.

    282 GitHub stars~2.7k tokensUpdated today
    MobileAuto-check passed
  • API Design

    margelo/react-native-skills

    Design and review predictable public APIs for TypeScript, JavaScript, React, and React Native libraries.

    175 GitHub stars~7.2k tokensUpdated 1 mo ago
    MobileAuto-check passed
  • Data Client Setup

    reactive/data-client

    Install and set up @data-client/react or @data-client/vue in a project.

    2k GitHub stars~2.2k tokensUpdated today
    MobileAuto-check passed
  • Native Data Fetching

    CherryHQ/cherry-studio-app

    A skill your agent uses when implementing or debugging ANY network request, API call, or data fetching.

    4k GitHub starsUsed in 6 repos~2.9k tokens
    DevelopmentAuto-check: notes

More from garden-co/classic-jazz

All 8 skills in this repo
  • Jazz Performance

    garden-co/classic-jazz

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

    2.5k GitHub stars~1.9k tokensUpdated 1 mo ago
    Auto-check passed
  • 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
  • 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

Questions about Jazz UI Development

What does Jazz UI Development do?

A skill your agent uses when building, debugging, or optimizing Jazz applications. Jazz UI Development is an agent skill from garden-co/classic-jazz. Use this skill when building, debugging, or optimizing Jazz applications.

When should I use Jazz UI Development?

Jazz UI Development fits situations like: optimizing Jazz applications; tasks that involve Cross-platform mobile apps; tasks that involve Debugging.

How do I install Jazz UI Development in Claude Code?

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

How do I install Jazz UI Development in Codex?

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

Can I use Jazz UI Development 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-ui-development -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-ui-development, .gemini/skills/jazz-ui-development, .github/skills/jazz-ui-development and .opencode/skills/jazz-ui-development in your project.

What does Jazz UI Development need to run?

SKILL.md names no scripts, command-line tools or credentials: Jazz UI Development is instructions for the agent only.

Does Jazz UI Development 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 Jazz UI Development 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 UI Development use?

Jazz UI Development 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 UI Development use?

About 1.7k tokens (SKILL.md is roughly 7k 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 6.1k tokens, read only when the agent opens those files.

What are the alternatives to Jazz UI Development?

Skills that share tags, products or a category with Jazz UI Development: React Devtools (sanity-io/sanity, 6.4k stars), Diagnosing Stacktrace Symbolication (PostHog/posthog, 40k stars), Lunora Realtime (anolilab/lunora, 282 stars) and API Design (margelo/react-native-skills, 175 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Jazz UI Development?

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.