How ChatJevPT works

Jev doesn't write text. It answers typed questions with probabilities. ChatJevPT asks it, over and over, what the next character of the answer should be, and appends the winner. The four levels ("dumb as a ___") differ in how they ask.

The loop, at every level

The browser drives it: one request per character, so the answer types out live and Stop is instant. Each request goes through the chosen level, which returns one character, or END.

Browser sends the question, the answer so far and (with memory on) earlier turns

The level picks the next character (sections below)

Is it END? Yes → answer finished

Append the character and show it

200 characters reached? Yes → answer finished

No → ask again for the next character

When the answer finishes, one more Jev call grades it (see Rating).

The levels side by side

	Doornail	Rock	Stump	Post
Jev requests per character	1	1–3 (a tournament)	2 (+ sense check, runoffs)	1–3 (+ sense check, runoffs)
Options	Every character	Every character	Only those code allows	Kinds first, then characters of that kind
Option labels	The character	The whole answer it makes, e.g. "Par"	The text it makes, e.g. "The sky is blu…"	Kind names, then as Stump
Real words only	No	No	Yes	Yes
Checks (done, word, repeat, sense)	No	No	Yes	Yes
Memory of earlier turns	No	No	Optional	Optional
Instructions editable in the Lab	Yes	Yes	No	No

Doornail the naive one

One Choice per character over every character: A–Z, 0–9, a space, a line break, . , ! ? : ; ' - and, once something is written, END. Each option is labelled with the character itself (a space is labelled "space") and described in one line, like "The letter A." Jev sees only the question and the answer so far. The most probable option wins; a tie is a coin flip.

No word list, no rules, no checks, no memory. Whatever Jev says goes, including double spaces.

One Choice over every character

Most probable wins (coin flip on a tie)

What Jev is told

Rock

The same characters as Doornail, but each option is the whole answer it would make, so Jev ranks phrases rather than picking a letter to add: after "Pa", the options are "Par", "Pas", "Pa ", "Pa." and so on, plus "Pa" (done) to stop. Jev isn't shown the answer so far on its own, just the question and how many characters are left. Still no word list, no checks and no memory.

Each character is a three-round tournament, asking the same question each time: one Choice over every option, then a fresh Choice over only the top 5, then over the top 2. The more probable of the final two wins. If in any earlier round the top option is ahead of the runner-up by 0.5 or more (say 0.7 against 0.2), it wins right there and the rest is skipped. Options are listed in a fresh random order in every request, so their position can't sway Jev. A tie at a cut-off, or in the final, is decided at random. Hover a character in a Rock answer to see the top of each round.

Round 1: one Choice over the answers each character makes ("Par", "Pas", "Pa." …), in random order

Top option ahead of the next by 0.5 or more? It wins; stop

Round 2: the same Choice over only the top 5

Top option ahead of the next by 0.5 or more? It wins; stop

Round 3: the same Choice over only the top 2

More probable of the final two wins (coin flip on a tie)

What Jev is told

Stump default

Code enforces the mechanical rules first, so Jev never sees an option that breaks them. Then two rounds: a screening round of yes/no questions (one per candidate, plus the checks), and a ranking Choice among the survivors.

The rules code enforces

Real words only. A letter is offered only if the word can still become one of the 60,000 most common English words, and a word can end only once it is one.
Capitals at the start of sentences and lines (code owns case; Jev only picks letters).
Spacing: spaces and line breaks only after a word or number, never doubled.
Numbers: digits continue, 3.14 and 1,000 work, no letters glued onto numbers.
Punctuation only where it fits: no space before a period, apostrophes and hyphens only inside words.
No stutters ("sss", "ndndnd") and no word longer than 18 letters.

One character, step by step

Code builds the allowed options

In parallel

Screening request

One yes/no per candidate: "still heading toward a sensible answer?"
done: does the answer already fully answer the question? (if it could end here)
word_done: is this short word finished? (while spelling a word of ≤ 4 letters)
repeat_ok: does the question ask for repetition? (when the answer starts repeating)

Sense check (after each finished word)

Sees only the answer text, no question: "does this make sense so far?"

Sense below 0.35, and repetition not asked for? Yes → stop: "Jev got too spicy"

Answer repeating and repeat_ok below 0.5? Yes → the repeated word can't be finished

word_done below 0.5? Yes → only letters (or ' -): keep spelling

done at or above 0.6? Yes → END

Screen: keep candidates scoring 0.3 or more (at least the best 2), plus END if it's allowed

Only one left? Yes → pick it

Ranking Choice over the survivors. Labels are the text each makes ("The sky is blu…"), shuffled every call, each described with real words it leads to.

A tie at the top? Yes → up to 2 runoffs between only the tied options, then a coin flip

The winner is the next character

What Jev is told

Screening (per candidate)

done

word_done

repeat_ok

Sense check

Ranking

Written as the task, a blank line, then one rule per line starting with "- ". Runoffs add "These options tied in an earlier round; choose the single best one."

Post experiment

Post splits each character into "what kind?" and "which one?". It keeps all of Stump's rules and checks; the checks just ride along with the kind round instead of the screening round.

Code builds the allowed options (Stump's rules)

In parallel

Kind Choice: Letter, Number, Space, Line break, Punctuation or End of answer (only kinds code allows here, each described in context), with Stump's done, word_done and repeat_ok in the same request

Sense check (after each finished word)

Same checks as Stump: spicy, repeat, unfinished word, done Spicy or done → stop; others rule kinds out

The most probable kind still allowed wins

A tie between kinds? Yes → up to 2 runoffs, then a coin flip

Only one character of that kind? (space, line break, END, or a single fitting mark) Yes → pick it, no more requests

Screening: Stump's yes/no per character, that kind's characters only

Only one passes? Yes → pick it

Ranking Choice over the survivors, with runoffs on a tie, as in Stump

The winner is the next character

A letter usually costs three requests (kind, screening, ranking); a space costs one. Hovering a Post character shows the kind round's probabilities too.

What Jev is told

Kind

Screening, the checks and ranking use Stump's prompts (edit them under Stump).

Rating

When an answer finishes, one Score question (with the chat's earlier turns, if memory is on) tags it Terrible, Bad, Solid, Good or Perfect. It's the same at every level.

What Jev is told

Numbers and prompts on this page come straight from the running code. Price: $0.042 per million input tokens (output is free). Memory sends up to 6 earlier turns.