Void reads one plain rules file. That's the whole surface — and worth knowing before you install anything.

How this maps onto Void

A single .voidrules file — not a Skills system.

Void is an open-source VS Code fork, and its confirmed context mechanism is a single .voidrules file at the project root — the same one-file-of-plain-text shape as Cursor's original .cursorrules, which Cursor itself later replaced with directory-based Project Rules. We could not find current, maintainer-published documentation spelling out exactly how .voidrules is spliced into a request; what we found instead is a Void GitHub issue (voideditor/void#585) from a user reporting that an overly long .voidrules file could make the model stop responding or burn excess tokens, and a separate feature request (voideditor/void#643) proposing a modern, directory-based rules system closer to Cursor's or Windsurf's. That proposal was never shipped.

There is no confirmed SKILL.md or Agent Skills discovery mechanism in Void — nothing like the .claude/skills/, .cursor/skills/, or .gemini/skills/ directories other companion pages on this site install into. Undercut still ships as a SKILL.md file (that's the canonical, versioned copy in the repo), but for Void the practical install is folding that file's text into the one place Void is documented to read: the root .voidrules file. Given the token-bloat report above, keep it short if you're already running a large .voidrules.

Undercut's tier names — cheap, standard, frontier, apex — stay generic on purpose. Void is a bring-your-own-key editor wired to whichever provider you configure, so models.md gives a rule of thumb rather than one fixed mapping: cheap resolves to the smallest/fastest model on your roster, standard to your default work model, frontier to the highest-reasoning model you've configured, apex to a single batched tie-break call. Nothing here sits between Void and your model backend — it's plain text Void reads into context, no proxy, no network hop, nothing to route around if you remove it.

Install for Void

Free. MIT. Nothing installs, nothing proxies your traffic.

Option 1 — append to .voidrules (recommended, matches Void's confirmed mechanism)

Run this from the repo root. This puts the routing policy in the one file Void is documented to read.

Option 2 — manual copy, no network call

Prefer not to pipe a download straight into a file? Open skills/firstpass/SKILL.md on GitHub, copy its body, and paste it into .voidrules at your project root yourself (create the file if it doesn't exist yet).

Validate it yourself

1. 1Read the published results — testing/README.md and the raw JSON in testing/results/
2. 2Reproduce for free, no API key, no spend: node src/main.js --mock
3. 3Open a small session in your Void build and confirm it actually reads .voidrules back to you before trusting it on real work

Zero lock-in. It's plain text in a rules file — delete the block and you're back to status quo.

Six flags assign a tier. Three triggers are the only way up.

This is a named, versioned spec — not internal logic we could quietly change. When the rubric changes (a new flag, a different cap), the version number moves and the changelog says why.

Every unit of work gets scored against six flags, then assigned the cheapest tier that can plausibly handle it. It only moves up a tier when something objective proves it needs to — a failed check, a measured disagreement, an explicit uncertainty flag. It never moves up on a guess, and it never moves back down mid-task.

 unit of work
      |
  6-flag rubric
      |
  +---+----+
  | 0 flags|--> cheap
  | 1-2    |--> standard
  | 3+/own |--> frontier
  +---+----+
      | fail x2 / disagree / uncertain
      v
  escalate +1 tier
  (residue only)
      |
  still unresolved?
      v
  single batched
  apex tie-break

Why it holds up

Flags steer. Verification and escalation decide.

Even when the rubric flags are scored imperfectly, the escalator still routes work to the right tier almost every time — because a wrong flag only ever costs one extra cheap attempt, never a wrong answer or a big bill.

Honest limits

What this doesn't do.

Not a proxy, not a gateway, doesn't auto-flag in production (whatever's behind Void scores the flags itself, and that path is unmeasured for Void specifically — see below), and doesn't promise a dollar figure for your workload. This page describes a policy, not a guarantee: nothing here proves Void will route correctly on your workload, only that the same rubric is verifiable and reproducible against the mock harness linked above.

Void-specific: Void's own GitHub repository was archived and its README marks the project deprecated and no longer accepting contributions, so treat everything above as a description of the last documented behavior, not an actively maintained integration — future Void releases, if any, aren't something we can test against. We could not confirm a native SKILL.md or Agent Skills discovery mechanism in Void the way other companion pages on this site can for their tools; the .voidrules mechanism described above comes from a maintainer-facing GitHub issue thread, not a published spec, and a directory-based rules system that would have superseded it (#643) was proposed but never shipped. A separate report (#585) says an overly long .voidrules file can degrade responses or burn tokens — keep the pasted policy text short if you hit that. We have not run Void ourselves to confirm any of this end-to-end; verify against your own build before relying on it. Full list of general limits, with the finance/procurement note and the paid-tier disclosure, is on the main page.