Zerolang skill for agents
Zerolang
A short Vercel Labs skill that finds or installs the Zero compiler and loads instructions matched to its version, so the agent edits through the graph
- 5,393 ★ on the repository
- Last commit
- Apache-2.0
Broad access
Why this level
- If the compiler is missing, the skill downloads an install script from the network and runs it in the shell
- The agent runs built programs with `zero run`, with access to your machine's input and output
- The author warns about experimental status and possible security holes
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/zerolangDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- If the compiler is missing, the skill downloads an install script from the network and runs it in the shell
- The agent runs built programs with `zero run`, with access to your machine's input and output
- The author warns about experimental status and possible security holes
This is third-party code. Review the repository files before installing.
What it does
The `zero` skill from the Zerolang repository is the entry point to an experimental programming language for agents. By itself it is a short stub: it checks whether `zero` is on `PATH` or at `~/.zero/bin/zero`, and only if not installs the compiler with a `curl` command and the `zerolang.ai/install.sh` script. It does not replace a compiler that is already installed, because environments often pin a version and a swap breaks the stores and workflows built for it. The agent then asks the compiler for instructions matched to that exact build with `zero skills` and `zero skills get`. Topics load one at a time and at most once per session: `agent` (the read, edit and verify loop), `language` (syntax, types, effects, generics), `graph` (the `zero.graph` store, queries and edit operations), `diagnostics`, `packages`, `builds`, `testing` and `stdlib`. The standard library reference includes ready validators for RFC 3339 time, IPv4 and IPv6 addresses, regular expressions and strict UTF-8, and the skill asks to look there before hand-writing any parsing. A Zero program is stored as a semantic graph, and `.0` files are a readable projection. The agent reads the graph with `zero query` and `zero view`, changes it through `zero patch` (a targeted replacement inside a function, a whole body replacement, adding a parameter with every call site updated) and verifies with `zero check`, `zero test` and `zero run`. Stale graph hashes and wrong types are rejected before anything is written.
Who it is for. For developers trying the Zero language in agents with skill support and ready to work with an experimental compiler in an isolated environment.
Good fit when
- You want the agent to write or fix a Zero program, for example `build hello world for zerolang`
- The agent should edit code through the graph instead of retyping whole functions
- A suitable compiler build is already installed and the agent must use it instead of installing a new one
- You need a ready time, address or string validator from the standard library reference instead of hand-written parsing
- You want to see how work looks in a language where the program is a graph and not a text file
Not a fit when
- You need a language for production systems: the author calls Zero an experiment and promises breaking changes, rough edges and security issues
- You write in another language: the skill only helps with Zero and gives nothing for TypeScript, Python or Go
- The machine holds working data or access to production systems: the compiler is meant to run in isolated workspaces
- There is no network: without a ready `zero` the skill downloads an install script from `zerolang.ai`
Example request
Install the zerolang skill and write a Zero program that prints hello world, then run itLimitations
The project is among the Vercel Labs experiments and carries a warning: expect breaking changes and security holes, work in isolated folders and keep production systems and sensitive data away. The skill can do nothing without the compiler, and the compiler is installed by a script downloaded from the network and piped to `bash`, so it is worth reading before running.
The skill file is deliberately thin and itself warns that it is not a command reference. The current instructions live inside the compiler and change with its version; with several binaries, call `zero skills` on the one that will run the project. `.0` files are generated from the graph, so the agent should edit them by hand only when no `zero patch` operation expresses the change, and then run `zero import`. Apache-2.0 license.
How to disable. Remove the skill from your agent's skill manager. The compiler lives separately in `~/.zero/bin`: delete that folder and remove it from `PATH` if you no longer need it.
FAQ
Why is the skill so short?
The instructions depend on the compiler version, so the main text lives inside `zero` itself and is served by `zero skills get`. The skill only finds the binary and sends the agent to the right topics, so the details never drift from the real build.
What does `zero patch` do?
It applies a checked edit to the program graph. It can replace a fragment inside a function (`--replace-in-fn`), replace a whole body (`--replace-fn`), add a parameter with every call site updated and create a function. A stale graph hash, unexpected fields and type errors reject the edit before anything is written.
Do I need to read files with the `.0` extension?
Not for routine work. It is a human projection of the graph: export it with `zero export` and check it with `zero verify-projection`. If a person edits the projection, `zero import` brings the changes back into the graph, and then `zero check` is needed.
Where are ready validators instead of hand-written parsing?
In the `stdlib` topic, the largest signature reference. A single module section loads with `zero skills get stdlib --topic std.time`. It has `std.time` for RFC 3339 with the exact leap-second rule, `std.inet` for IPv4, IPv6 and hostnames, `std.regex` and `std.unicode`.
How do I check that the right version is installed?
Run `zero --version` after installing. With several binaries call `zero skills` on the one that will run the project: the content is fixed for a given build, so there is no need to load an already received topic again in a session.
Discussion
No questions or reviews yet.
Related
SkillsThe author's personal set: shared agent rules and dozens of skills for GitHub, the browser, macOS, messaging and releases, plus a sync script
A mirror of Lauren Tan's pstack set from Cursor: over 50 skills, the poteto-mode with 23 playbooks and 24 principles for strict agent work on code
OpenClaw Agent Skills
openclaw-agent-skills
Shared skills for coding agents that work on OpenClaw projects: review and other workflows. A narrow topic for people who write OpenClaw code
Dimillian Skills
Skills
A set of 16 engineering skills for agents: Apple platform work, macOS packaging, React performance, code review and refactoring
Orval skill for agents
Orval skill
The official Orval skill: the agent sets up generation of TypeScript clients, Query hooks, Zod schemas and MSW mocks from an OpenAPI spec
Two skills for coding agents: wtf audits a project before shipping, better-codex keeps the agent disciplined while working on code
README in short
The Zerolang description opens with a security warning and an example of an ordinary conversation with an agent. It then explains the idea of a program database as a graph, shows the agent loop that talks to the compiler, lists what already works, covers installing the compiler and the skill, the daily command loop, speed and memory goals and building the project from source. The repository holds conformance checks, Rosetta task benchmarks and the data behind the built-in instructions.
README badge
Original SKILL.md
---
name: zero
description: Install Zero and load version-matched workflows with zero skills.
---
# Zero
Zero is an agent-first programming language. zero.graph is the program; `.0` files are projections of it. Edit through `zero patch`.
Install this skill once in an agent's skill manager. Keep it thin; Zero's own CLI serves the version-matched workflow for each installed compiler.
Use the zero already on PATH or at `~/.zero/bin/zero` when one exists; environments often pin a specific compiler, and replacing it silently breaks version-matched stores and workflows. Install only when zero is missing:
```sh
command -v zero >/dev/null 2>&1 || { curl -fsSL https://zerolang.ai/install.sh | bash; }
export PATH="$PATH:$HOME/.zero/bin"
zero --version
```
## Version-Matched Skills
This file is only a discovery stub. Do not treat it as the full Zero workflow
or as command reference.
Before editing, checking, testing, or repairing Zero code, ask the installed compiler for the skill content that matches that exact binary:
```sh
zero skills
zero skills get zero
zero skills get zero --full
zero skills get stdlib --topic std.time # one section instead of the whole topic
```
If the user has multiple Zero binaries, use the same binary that will run the project:
```sh
/path/to/zero skills
/path/to/zero skills get zero --full
```
Use `zero skills get <name>` to load only what the task needs, and fetch each
topic at most once per session: the content is fixed for a given compiler
binary, so refetching a loaded topic returns the same text. Topics and
approximate served sizes:
- `zero` (~2 KB): this discovery stub
- `agent` (~4 KB): read-edit-verify loop, zero query usage, edit surfaces, verification
- `language` (~6 KB): syntax, types, effects, control flow, generics
- `graph` (~9 KB): zero.graph store, query/view, patch operations, import/export/merge
- `diagnostics` (~4 KB): reading diagnostics, zero explain, typed fix plans