Most coding tools react to typing.
Catnip reacts to running.

Typing-reactive feedback is noise

Open any modern editor and write a line of code. Before you finish the sentence, you'll see: red squigglies, autocomplete menus, inline warnings, ghost text, parameter hints. The editor is screaming at you — and you haven't even run anything yet.

Most of that feedback is wrong. Not maliciously — it's just premature. A linter flags an undefined variable before you've written the line that defines it. Autocomplete ranks suggestions based on what statically parses, not what actually works. The IDE is pattern-matching your text. It has no idea what your code will do when it runs.

def process_data(items):
    for item in items:
        result = transform(ite  ← red squiggly
                                ← autocomplete: item, items, iter, itertools...
                                ← warning: 'result' assigned but never used
                                ← hint: did you mean iter()?

This works fine when you wrote the code. You know what's noise and what's signal. But for AI-generated code, this mental filter doesn't exist — and the noise gets much worse.

Execution-reactive feedback is signal

Catnip doesn't care what you're typing. It watches what happens when your code runs. The cat is idle while you write. The cat reacts when you press ▶ Run.

That's not a design quirk — it's the entire point. The only honest feedback about code is what it does when it executes. Success, error, infinite loop, silent wrong answer — these are real states. Everything before the run is speculation.

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a

print(fibonacci(10))
# → 55

def fibonacci(n):
    if n == 0: return 0
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(5000))
# → RecursionError: maximum recursion depth exceeded

i = 0
while True:
    i += 1
    # forgot the break condition

Three different outcomes. Three different cat faces. The feedback maps to what actually happened, not what a static analysis tool predicted might happen.

Why this is the right primitive for AI-generated code

When you write code, you have a model in your head of what it should do. Typing-reactive tools help you express that model. But when AI writes code, there is no model in your head. You prompt, you get output, you have no idea if it works. The AI was confident. That confidence is not evidence.

In this context, typing-reactive feedback is almost useless. The AI-generated code is syntactically clean. It will pass all the linters. It might be completely wrong at runtime — wrong algorithm, wrong edge cases, wrong assumptions about the input format. None of that shows up before you run it.

The only honest evaluation of AI-generated code is execution. Does it run? Does it produce the right answer? Does it handle the edge case? These are empirical questions. You can only answer them by running the code. Catnip makes running the code the natural first reflex — not an afterthought.

The cat reacting to a successful run is a small thing. But it makes the feedback loop visceral and immediate: this code ran, and the world is fine — or it didn't, and the cat is judging you. That reaction is the whole primitive.