The Collicutt Software Company
Software products, developer tools, and applied security engineering
Vary - A novel programming language
Catch the tests that LLMs lie about
You ask an LLM to write tests for your code. It generates a full suite. Coverage hits 90%. Everything passes. You merge it.
A week later, a bug ships. You look at the tests and realize they were checking almost nothing. They asserted that functions returned without errors, but never verified the actual results. The LLM wrote tests that looked right but lied about what they proved.
This is the problem Vary solves. By building mutation testing directly into the language, Vary can flip your bytecode and check whether your tests notice. If a mutation survives, your test was never really protecting you. Run `vary mutate` and find out which tests are real and which ones are theater.
Vary is a statically-typed language that compiles to JVM bytecode. Clean syntax, type inference, null safety at compile time, no semicolons. The compiler has mutation testing built in: it flips bytecode instructions and checks whether your tests notice. If they don't, those tests were never protecting you. One CLI binary handles running, checking, testing, formatting, and mutating. Nothing extra to install.
Features
| Capability | Description |
|---|---|
| Built-in mutation testing | Run `vary mutate` to flip bytecode and check test strength — part of the compiler, not a plugin |
| Bytecode-level mutation | Flips JVM instructions to verify your tests catch real bugs, not just run without errors |
| Clean syntax | Readable braces, type inference, and no semicolons |
| Null safety | Null checks enforced at compile time |
| Unified CLI | One binary handles run, check, test, format, and mutate |
| JVM target | Compiles to standard JVM bytecode |
| VS Code extension | Editor support with syntax highlighting and diagnostics |
Curtis Collicutt
Curtis Collicutt runs The Collicutt Software Company. He works across product engineering, developer experience, and cybersecurity, with a bias toward tools that make complex systems easier to reason about and safer to run.