You've built a Skill. It runs. It works. Your users like it.

But here's a question you probably haven't been able to answer: how good is it, really?

Not "does it complete the task" — you already know that. But compared to every other approach to the same problem, where does your Skill actually land? Is it in the top 10%? The bottom half? Would a different implementation handle edge cases better?

Without a measurement you didn't write yourself, you genuinely don't know. Your Skill has a ceiling — and you can't see it.

That's exactly the gap Rotifer's Gene + Arena system is built to close.

From Skill to Gene in Three Commands

A Gene is a Skill that has been compiled to WebAssembly IR, given a machine-readable phenotype manifest, and registered in the Rotifer ecosystem. The process takes about five minutes.

Install the Rotifer CLI and create a workspace — every Rotifer command runs inside one:

npm install -g @rotifer/playground
rotifer init my-agent && cd my-agent

Wrap an existing ClawHub Skill into a Gene scaffold with one command. The first argument is the local Gene name you want; --from-clawhub takes the Skill's ClawHub slug:

rotifer wrap my-gene --from-clawhub <clawhub-slug>

This creates a local Gene directory with your Skill's code and a generated phenotype.json describing its inputs, outputs, and declared domain. Review it — the domain tag decides which Genes yours is compared against.

The same command wraps a Skill you already have on disk, no ClawHub round trip needed:

rotifer wrap my-gene --from-skill ~/.cursor/skills/my-skill/

Compile the Gene to WebAssembly IR:

rotifer compile my-gene

The compiler validates your phenotype and emits a portable WASM binary:

✓ Gene 'my-gene' compiled to Rotifer IR
  Gene ID: 5896324aba8548d6...
  Domain: general
  Fidelity: Native
  IR Hash: f076a966815b2c54...
  Output: ./genes/my-gene/gene.ir.wasm
  Size: 1199.9 KB

If compilation fails, the error is almost always a missing dependency declaration in phenotype.json or a function signature the WASM compiler can't handle. The error message tells you exactly which line.

Submitting to Arena

Submit the compiled Gene by name — Arena resolves it from your workspace:

rotifer arena submit my-gene

Arena runs the Gene in a WASM sandbox, checks its output against its declared schema, and records what it measured:

✓ Gene 'my-gene' submitted to Arena
  Domain: general
  Fidelity: Native
  V(g): 1.0000
  Success Rate: 100.0%
  Latency Score: 0.1067
  Admission: PASSED
  Execution: Sandbox verified (3 runs)
  Recorded as: estimated

Read that last line carefully, because the CLI means it. The run is real: the Gene executed in the sandbox, its output was checked, and its latency and cost were recorded. But two of the inputs to the fitness formula — community utilization and robustness under adversarial inputs — are still placeholders, and the reference scale its efficiency terms are measured against is provisional. So the score is filed as an estimate and does not yet rank, and it is left out of the record above for that reason. What you get today is a reproducible execution record and a safety grade, not a verdict.

Check where your Genes stand:

rotifer arena list --domain general

  Local Arena Rankings
  #   Name                  Domain    F(g)     V(g)     Fidelity
  ──────────────────────────────────────────────────────────────
  1   my-gene               general   1.0000   1.0000   Native

Add --cloud to look at the published registry instead of your own workspace.

What the Score Actually Means

F(g) is not a rating someone gave your Skill. It is computed from an actual execution: correctness against the declared schema, success rate across sandbox runs, latency and resource cost. V(g) is a separate static safety grade — it is not a quality score, and a Gene can be perfectly safe and still useless.

That separation is the point. It changes how you improve a Skill:

Look at which sandbox runs failed and why
Compare your phenotype against what the domain actually requires
Make a targeted change, recompile, resubmit
Watch the numbers move

Iterating against a measurement is a different activity from iterating against a hunch — even while the measurement is still being sharpened.

Fidelity: The Next Level

Native fidelity means the logic compiled directly to WASM with no API wrapper. A Wrapped Gene keeps a layer of overhead and potential failure points between the Gene interface and your actual logic — and it has to declare that in its phenotype, because consumers are entitled to know which one they are installing.

If you want to close the gap, the path is rotifer wrap → optimize → rotifer compile → resubmit.

But you don't have to. An honest Wrapped Gene that does its job beats a Native one that doesn't — and a wrong fidelity declaration is the one failure the ecosystem cannot route around.

Try It Yourself

The whole flow — wrap, compile, submit, check — takes about five minutes for a Skill you've already built.

npm install -g @rotifer/playground
rotifer init my-agent && cd my-agent
rotifer wrap my-gene --from-clawhub <clawhub-slug>
rotifer compile my-gene
rotifer arena submit my-gene
rotifer arena list

If you run it, we want to see what came back — the Gene name, its domain, and the numbers. The ecosystem is only as interesting as the Genes in it.

Your Skill has a ceiling. Now you have the tools to start measuring it.