nim skills for coding agents

Your agent’s Nim compiles. It passes the test. It still segfaults.

Fast, low-cost coding agents get Nim’s ownership hooks, C interop and test setup wrong, and review and happy-path tests miss it. Verified Nim Skills drop into Claude Code, Codex, Cursor and other agents. Every testable claim in them is proven by a compiler-run test.

verified on Nim 2.3.1 · Nimony 0.6.3

proc `=wasMoved`(w: var Writer) =
  w.data = nil     # destroy is now a no-op...
                   # pos and capacity stay stale

var b = move(a)
a.writeByte 'z'    # reusing a moved-from value is legal
runtime
SIGSEGV: Illegal storage access. (Attempt to read from nil?)

The next legal write goes through nil. The advice behind it, “=wasMoved only needs to make =destroy a no-op”, passes review and the destroy test. The verified skill resets every field, and a test reproduces the crash and proves the fix.

the problem

Three Nim bugs that review won’t catch

All three compile, look idiomatic and pass a quick test. Only running the code caught them.

The pattern holds across the catalog. On 12 of 17 skills, the agent without the skill failed a check that the skill-guided agent passed. Other failures include C-library builds that work on only one machine and fuzz harnesses missing required flags.

blind trials

Same cheap model: 18 of 20 solved with our skills, 3 of 20 without

Four hard Nim tasks, each run five times with the skill and five times without: a bug report with a reproducer, a C-to-Nim port, cross-module error handling and a manually managed container. Every run was blind and sandboxed. Deterministic checks scored it, and the plan was fixed before the first run.

with verified skills

18/20 passed

Every task solved in most runs.

without skills

3/20 passed

Three of the four tasks never solved.

cost per solved task

$0.05 vs $0.21

Four times cheaper per solved task. The skill-guided agent reads more per attempt and finishes far more often.

A larger model without skills passed 0 of 6 on two of the tasks. The audit is what you pay for: on three earlier tasks, the unverified drafts of the same skills passed 1 of 3 each, and the verified skills passed 3 of 3. Full results.

why this wins

The alternatives don’t check their work

“I’ll generate my own skill”

Self-written skills don’t verify themselves

Skills that models wrote for themselves gave no average gain in SkillsBench. Curated skills added about 16 points. Our own careful drafts failed the compiler audit in over a hundred places.

“I have a docs MCP”

Docs say what exists, not what is safe

Docs describe the hooks. They don’t warn your agent that its =wasMoved leaves stale fields, or that its address guard misses aliasing. Keep the MCP for lookup and add the skills for safety.

“I’ll use a bigger model”

More cost per call, same blind spots

A frontier model costs more on every request and still has not seen the compiler build you installed last week. Verified guidance costs a flat monthly fee.

Why verified skills win, with sources.

why a subscription

Re-verified every time the compiler moves

The test suite runs again on new Nim and Nimony builds, so compiler drift reaches you as a fix in your next update. The same tests catch compiler bugs: verifying our Nimony error-handling skill exposed seven, all fixed upstream within two days of our reports.

Planning for Nim 3? The catalog already covers Nimony error handling and compiler plugins.

what you get

What the subscription adds to the public skills

The public skills stay free for non-commercial use. They are separate community work, not a free tier.

 Verified Nim SkillsPublic skills
Claims tested against the current compilersAll testable claimsNot systematically
Audit corrections applied and retestedYesSome synced, no guarantee
Nimony: error handling, pluginsYesPlugins and native release only
Re-verified on new compiler buildsWhile subscribedBest effort
Use in commercial workInternal useNon-commercial only

Catalog areas: ownership hooks, error handling, API design, C bindings and wrappers, testing, fuzzing, debugging, defect analysis, bug reporting, porting, performance, code organization, style, doc comments, Atlas, and Nimony error handling and plugins.

setup

In your agent in three steps

Works with Claude Code, Codex, Cursor, GitHub Copilot, OpenCode, Windsurf and more.

1

Subscribe

Check out with Polar. Invoices carry your company name and VAT ID.

2

Connect GitHub

Accept the read-only invite to the private catalog.

3

Run NYX

The open-source installer puts the skills where your agent looks, and nyx update pulls each re-verification. Setup guide.

pricing

Costs less than one hour of your review time a month

Team

Two or more developers, one invoice.

$10 / seat / month, billed yearly · or $15 month to month

  • Same catalog, one GitHub account per seat
  • Reassign seats when people leave
  • One company invoice

Minimum 2 seats. Seats are set up by email.

Pricing details and billing questions

faq

Questions

How do I justify this to my engineering manager?

Agent-written Nim that crashes on an unusual path costs a review cycle when you are lucky and an incident when you are not. The skills target exactly those paths. We build and test them on low-cost models, so the agent you already pay for gets them right.

How do you know the skills are right?

Each testable claim has a program that the real compiler builds and runs, and the suite runs again on new compiler builds. When a test exposes a wrong statement, including in our own earlier versions, we fix it and ship it in your next update.

I already use Context7 or another docs MCP. Do I need this?

Yes, and keep the MCP. Docs tell the agent what exists. The skills tell it what is safe on today’s compiler, what to avoid and how to isolate a failure.

Will my agent actually use the skills?

Add a two-line pointer to AGENTS.md or CLAUDE.md and it will load the matching skill. Copy the pointer.

Which agents are supported?

Anything NYX installs into: Claude Code, Codex, Cursor, OpenCode, GitHub Copilot, Crush, Pi, Cline, Windsurf, Roo Code, Continue and others. Full list.

What happens if I cancel?

Repository access ends at the end of the paid period and updates stop. You keep the versions you received under the license. NYX deletes nothing.

Can I get a refund?

No refunds once repository access has been granted: the files are yours to keep. EU and UK consumers can withdraw for a full refund before access is granted. Statutory rights for faulty or undelivered content always apply. See the refund terms.

Stop reviewing the same agent bugs

Give your agent Nim guidance the compiler has already checked.