Native SDK: agent skill
Native SDK
Skills for the experimental Native SDK: the agent reads version-matched guidance from the installed CLI for building desktop apps in TypeScript
- 7,803 ★ on the repository
- Last commit
- Apache-2.0
Extended access
Why this level
- The discovery skill pre-allows the agent to run `native` and `npx @native-sdk/cli`, which build and launch apps on your computer
- The CLI may download a pinned Zig version when no suitable one is on `PATH`
- Through `native automate` the agent drives the window of a running app and reads its state
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/native-sdkDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- The discovery skill pre-allows the agent to run `native` and `npx @native-sdk/cli`, which build and launch apps on your computer
- The CLI may download a pinned Zig version when no suitable one is on `PATH`
- Through `native automate` the agent drives the window of a running app and reads its state
This is third-party code. Review the repository files before installing.
What it does
Native SDK from Vercel Labs is a toolkit for desktop apps: logic is written in TypeScript, the interface in `.native` markup, and the build produces a native executable. The skill teaches an agent to work with that toolkit. Installation drops a short discovery skill, native-sdk, into the agent's skills directory, and the agent then reads the detailed guidance from the CLI itself with `native skills list` and `native skills get`. Six skills are built in. core covers project structure, the `app.json` manifest, the JavaScript bridge, permissions, windows, WebViews, packaging and debugging. native-ui describes markup, bindings and the `Model`, `Msg`, `update` loop. ts-core explains the allowed TypeScript subset and effects, ts-services handles services that touch files and processes, and zig gives Zig 0.16 idioms indexed by compile error. The automation skill shows how to snapshot and verify a running app through `native automate`. For an ordinary app from `native init`, the documentation advises giving the agent native-ui and ts-core, and adding core with `--full` for WebViews, packaging and native capabilities.
Who it is for. For developers building desktop apps on Native SDK with an agent who want it to know the markup syntax, the TypeScript core rules and the CLI commands of the right version.
Good fit when
- You create an app with `native init` and ask the agent to write a screen in `src/app.native` and logic in `src/core.ts`
- The agent has to attach a WebView or an existing web frontend to the app
- The app must be packaged for distribution, with permissions and windows set in `app.json`
- A running app needs checking through `native automate`: take a snapshot, wait for readiness, run a smoke test
- The agent hit a Zig 0.16 compile error in a core or a toolkit extension
Not a fit when
- You need a mobile app: the toolkit's mobile support is experimental and still evolving
- You need a mobile or web project on another framework: the skill covers only Native SDK
- Node.js 24 or later is missing: the CLI will not install through npm without it
- You need a stable base for a product: the author marks the toolkit as experimental, and capabilities differ by platform
Example request
Create a counter app on Native SDK, add a reset button and check through automation that the value goes back to zeroLimitations
The skill does not hold the detailed guidance: the entry file only points the agent at the installed CLI, and without `@native-sdk/cli` on the system there is nothing for the agent to read. In return the text always matches the toolkit version in the project. Skills are not copied into the workspace on their own: `native init` does not do it, so you hand a skill over explicitly, for example by redirecting the output of `native skills get native-ui` into a file.
The `native` command needs a suitable Zig: the CLI takes it from `PATH` or offers to download the pinned version. macOS has the deepest support, Linux and Windows are exercised in CI, and mobile embedding is experimental.
The discovery skill is marked hidden in its SKILL.md.
License Apache-2.0.
How to disable. Delete the native-sdk skill folder from your agent's skills directory. Skills you exported by hand with `native skills get` live in the files you redirected them to, for example `.claude/skills/native-ui/SKILL.md`; delete those files. The CLI itself is removed with `npm uninstall -g @native-sdk/cli`.
FAQ
Why is the skill so short after installation?
Installation adds only the discovery skill. The agent reads the detailed guidance from the CLI with `native skills` commands, so it always matches the toolkit version the project uses.
Which skills does the CLI carry?
Six: core, native-ui, ts-core, ts-services, automation and zig. `native skills list` prints them, `native skills get <name>` prints one, and the `--all` flag prints every skill at once.
Does fetching skills work offline?
Yes. The documentation says `native skills get` needs only the installed CLI, so it works offline.
What is inside the app that `native init` creates?
A counter in three files: `src/core.ts` with the model, messages and update function, `src/app.native` with markup and bindings, and `app.json` with the app identity, windows, permissions and security settings.
How do I export a skill into a project folder?
Create a directory and redirect the output: `mkdir -p .claude/skills/native-ui`, then `native skills get native-ui > .claude/skills/native-ui/SKILL.md`.
Can the app core be written in Zig?
Yes. Create the project with `native init my_app --template zig-core`. TypeScript is the default path, and the zig skill is for an existing Zig core and toolkit extensions.
Discussion
No questions or reviews yet.
Related
SkillsAn agent reference for cross-platform desktop apps that feel native: eight tenets, four layers, a WebView survival guide and a 75-item ship audit
Builder Skills
Skills for agents
A set of small skills from Builder.io for agent work habits: visual plans and diff recaps, docs-first checks, cross-agent review and clean status updates
Skills from the Dart team: tests and mocks, analysis and dart fix, CLI apps, FFI, documentation and package conflict fixes for an AI agent
Tech Leads Club Agent Skills
Agent Skills
A vetted skill registry with a CLI that installs into twenty-plus agents and an MCP server for on-demand skill lookup
Dimillian Skills
Skills
A set of 16 engineering skills for agents: Apple platform work, macOS packaging, React performance, code review and refactoring
A skill set from the Kotlin team for agents: Java to Kotlin conversion, build migrations and correct use of backend frameworks
README in short
A short description of the toolkit, a quick start with CLI installation and a counter app, an explanation of the app model with messages and effects, and a list of examples: a chatbot, a soundboard, a system monitor and a calculator. It ends with links to documentation on markup, components, services, testing, automation and packaging. A separate documentation page covers the agent skills, and the repository carries contributor guidance and agent rules in AGENTS.md.
README badge
Original SKILL.md
--- name: native-sdk description: Discovery skill for the Native SDK, the complete toolkit for building native desktop applications. Apps are authored in TypeScript + declarative Native markup (.native) by default and compiled to native code with no JS runtime in the binary; Zig cores are an explicit alternative, and WebViews are the optional web-content path. Use when the user asks what the Native SDK is, how to build a Native SDK app, author native UI, scaffold an app, configure app.json or legacy app.zon, add bridge commands, embed web content, package an app, test a running app, or automate a Native SDK app. allowed-tools: Bash(native:*), Bash(npx @native-sdk/cli:*) hidden: true --- # Native SDK The Native SDK is the complete toolkit for building native desktop applications. **The primary authoring path is TypeScript app logic in `src/core.ts` plus declarative Native markup in `.native` files.** The TypeScript core is checked and compiled ahead of time to native code, so the shipped binary contains no browser, WebView, JS runtime, or interpreter. Zig is how the toolkit itself works and is a first-class, explicitly chosen app-core alternative (`--template zig-core`); it is not the default inferred from the SDK's implementation. Every app embeds a deterministic automation server, so agents can snapshot, drive, and screenshot the running window. Desktop is the mature surface (macOS deepest, Linux and Windows exercised in CI); mobile embedding is experimental. WebView surfaces coexist as the optional path for embedding web content or hosting an existing web frontend. ## Start here This file is a discovery stub for agents that installed the Native SDK once with a skills installer such as `npx skills add native-sdk`. Before implementing or explaining Native SDK app work, use the installed CLI to discover and load the current skill content: ```bash native skills list native skills get core native skills get native-ui native skills get ts-core ``` Use `native skills get core` for initial orientation. For the default app-authoring path, load **both** `native-ui` (views, bindings, the app loop) and `ts-core` (the TypeScript subset, effects, subscriptions, and modules) before implementing. Load `ts-services` too when the tree has `src/services/` or ordinary TypeScript needs filesystem/process/JSON/regex/Map/Date/class work behind `Cmd.request`. Use `native skills get core --full` when work reaches lower-level runtime wiring, WebViews, bridge/security, native capabilities, packaging, or debugging. Use `native skills get automation` when testing a running app, taking snapshots, requesting reloads, or using the built-in automation server. Use `native skills get zig` only for an existing Zig core, a toolkit extension, SDK implementation work, or a Zig 0.16 compile error. ## Quick orientation ```bash npm install -g @native-sdk/cli native init my_app cd my_app native dev ``` `native init my_app` generates the primary three-file app: `app.json`, `src/app.native` (the markup view), and `src/core.ts` (`Model`, `Msg`, `update`). Existing `app.zon` manifests remain supported. Inspect the tree before editing an existing app and preserve the core language it already uses. `src/main.zig` means the app explicitly uses the Zig-core template; web-frontend shells additionally carry `frontend/` and usually owned build/runtime wiring.