# AI use cases for Kill Switch (dom96/KillSwitch)

Repo: [dom96/KillSwitch](https://github.com/dom96/KillSwitch) | Use cases: 4 | Page: https://dedupedai.com/use-cases/dom96-killswitch/

KillSwitch is an esoteric programming language, with its specification and reference Rust implementation, designed to be hard for LLMs and coding agents to generate or modify.

This file holds every use case of this repo. Each one starts with a "## " heading and ends with its URL.

- Run a Kill Switch program from the command line: https://dedupedai.com/use-cases/dom96-killswitch/run-killswitch-program/
- Check whether two words are anagrams: https://dedupedai.com/use-cases/dom96-killswitch/check-anagram-pairs/
- Run the Kill Switch test suite after a code change: https://dedupedai.com/use-cases/dom96-killswitch/verify-changes-with-test-suite/
- Read the Kill Switch spec and LLM benchmark results: https://dedupedai.com/use-cases/dom96-killswitch/study-killswitch-spec-and-benchmarks/

## How to run a Kill Switch program from the command line with Kill Switch

Repo: [dom96/KillSwitch](https://github.com/dom96/KillSwitch) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Install the reference interpreter and run the bundled fizzbuzz.ks example.

**Who it is for:** A developer curious about esoteric languages who wants to see Kill Switch code execute on their own machine.

**The problem:** Kill Switch code cannot be run until the reference implementation is built and available.

**The outcome:** The bundled tests/fizzbuzz.ks program runs through the killswitch command.

### Steps

1. Clone the repo from https://github.com/dom96/KillSwitch and open a terminal in the repo folder.
2. Run `cargo install --path .` to install the killswitch command.
3. Run `killswitch run tests/fizzbuzz.ks` to execute the example.
4. If you did not install it, run `cargo run -- run tests/fizzbuzz.ks` instead.

### Prompt to paste into your agent

```text
In the dom96/KillSwitch repo, build the project with cargo and run `cargo run -- run <path to a .ks file>`, using tests/fizzbuzz.ks if no path is given. Report the printed output and any error text. Verify that the process exits without an error.
```

### Caveat

The README names cargo and a Rust build as the setup path, so this use case does not work without a Rust toolchain.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/dom96-killswitch/run-killswitch-program/

## How to check whether two words are anagrams with Kill Switch

Repo: [dom96/KillSwitch](https://github.com/dom96/KillSwitch) | Difficulty: Intermediate | Time: 15 minutes | Basis: From the README

Use the built-in anagram command to test word pairs from a terminal.

**Who it is for:** A word-game player or puzzle maker who needs to confirm that two words use the same letters.

**The problem:** Checking anagrams by hand is slow when you have many word pairs to compare.

**The outcome:** The anagram command reports whether each pair of words is an anagram of the other.

### Steps

1. Install the tool with `cargo install --path .` from the repo folder, or skip this if you will use cargo run.
2. Run `killswitch anagram test tset` to check one pair.
3. Run `cargo run -- anagram testly tsetly` if the tool is not installed.
4. Repeat the command with each word pair you want to check.

### Prompt to paste into your agent

```text
Using the dom96/KillSwitch repo, run `cargo run -- anagram <word1> <word2>` for each pair in <word pair list>. Report the line the command prints for each pair. Verify that every reported result matches the letter counts of the two words.
```

### Caveat

The README shows the anagram command only as a utility, so it is a side tool and not part of the language's programs.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/dom96-killswitch/check-anagram-pairs/

## How to run the Kill Switch test suite after a code change with Kill Switch

Repo: [dom96/KillSwitch](https://github.com/dom96/KillSwitch) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Run cargo test to confirm the interpreter still passes its tests, with output for eval tests.

**Who it is for:** A contributor or maintainer who edited the Rust interpreter and needs to check nothing broke.

**The problem:** Without running tests, changes to the interpreter can break behavior without any visible sign.

**The outcome:** The full test suite runs, and the evaluation tests print their output for review.

### Steps

1. Open a terminal in the repo folder after making your change.
2. Run `cargo test` to run the full test suite.
3. Run `cargo test eval::tests -- --show-output` to run the evaluation tests and see their output.
4. Fix any failing test before you commit the change.

### Prompt to paste into your agent

```text
In the dom96/KillSwitch repo, run `cargo test` and then `cargo test eval::tests -- --show-output`. Report the pass and fail counts and the names of any failing tests. Verify that no test fails before you suggest any commit.
```

### Caveat

The README gives the test commands but does not describe what each test covers, so passing tests do not prove full correctness.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/dom96-killswitch/verify-changes-with-test-suite/

## How to read the Kill Switch spec and LLM benchmark results with Kill Switch

Repo: [dom96/KillSwitch](https://github.com/dom96/KillSwitch) | Difficulty: Beginner | Time: 15 minutes | Basis: From the README

Review the language specification and the LLM benchmark site to compare how models handle Kill Switch tasks.

**Who it is for:** A researcher or AI evaluator who wants to see how well LLMs perform on an esoteric language task.

**The problem:** Judging how LLMs handle an unfamiliar language needs the language rules and published results side by side.

**The outcome:** You have the spec's rules in hand and the model results from the benchmarks site for comparison.

### Steps

1. Open SPEC.md in the repo to read the language specification.
2. Visit https://killswitch-lang.org for the official project information.
3. Visit https://bench.killswitch-lang.org to see LLM model benchmarks for Kill Switch tasks.
4. Note which spec rules the benchmark tasks depend on before you draw any conclusions.

### Prompt to paste into your agent

```text
Read SPEC.md in the dom96/KillSwitch repo and the benchmark results at https://bench.killswitch-lang.org. Summarize the main language rules and list the models and scores the benchmark shows for <task type>. Verify that each claim you report is written on the spec or benchmark pages.
```

### Caveat

The benchmark site is linked from the README, but the README does not describe how the benchmarks were run, so treat results as published by the project.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/dom96-killswitch/study-killswitch-spec-and-benchmarks/