Theory & rubric

Why these five axes?

Scoring a conversation only means something if the axes are grounded. Each one below operationalizes a real result from linguistics and psychology — and it’s the same rubric the trainer scores you on, loaded from one shared source.

The premise: conversation is synchronous

A social-media post is asynchronous — you draft it, revise it, delete it, and perform a curated self. A conversation is real-time: you take turns on the order of milliseconds, you can’t un-say things, and success is inter-subjective — it depends on how the other people felt, not on what you intended.

That’s why the ground truth for conversation quality can’t be self-graded. In multiplayer, it’s peer ratings. In this trainer, it’s an AI judge applying explicit, theory-backed criteria to the transcript. Either way, the axes have to be principled — otherwise the score is noise.

The rubric

Five axes, each scored 0–20 by the judge, summing to 100. They’re rendered here directly from /lib/rubric.js — the same module the worker builds its judge prompt from, so the docs can never drift from the scoring.

Grice’s cooperative principle

H.P. Grice argued that conversation works because speakers tacitly cooperate, following four maxims:

Quantity — be as informative as required, and no more.
Quality — don’t say what you believe false or lack evidence for.
Relation — be relevant.
Manner — be clear, brief, and orderly; avoid ambiguity.

Two of our axes come straight from here: Relevance (the maxim of Relation) and Clarity (Quantity + Manner together — the right amount, said plainly). Violations aren’t always failures — Grice noted that flouting a maxim on purpose is how irony and implicature work — but in practice conversation the maxims are a solid default.

Turn-taking

Sacks, Schegloff & Jefferson’s 1974 model showed conversation is governed by a precise, locally-managed system for who talks when: one party talks at a time, transitions happen at “transition-relevance places,” gaps and overlaps are minimized, and speaker change recurs. It’s astonishingly orderly given nobody’s in charge.

Our Balance axis operationalizes this: are you sharing the floor proportionally, yielding cleanly, and sizing turns to the moment — rather than monologuing or starving the exchange with one-word replies? Group size changes the dynamics sharply (a dyad has no exit; a quad splinters), which is why the multiplayer roadmap treats 2/3/4 players as distinct modes.

Active listening & “yes-and”

Rogers & Farson’s active listening is the discipline of demonstrating understanding — reflecting content back, paraphrasing, and asking open questions that invite elaboration. Improv contributes the complementary reflex: “yes-and” — accept your partner’s offer, then build on it, rather than blocking with “yes-but.”

Our Listening axis rewards visible building: callbacks, paraphrase, open questions, accepting-and-adding. It’s the single highest-leverage skill for the quiet-partner and interrogator drills — you can’t force someone open, but a specific open question usually does it.

Face-work & politeness

Goffman’s face — the public self-image everyone tries to maintain — and Brown & Levinson’s politeness theory describe how we protect each other’s social standing. Many conversational acts are inherently face-threatening (disagreement, correction, refusal); skilled speakers soften them, and repair friction when it appears.

Our Warmth axis captures this: acknowledgment, encouragement, disagreeing without diminishing, and repair — gracefully fixing a misunderstanding is one of the most rewarded moves in the whole rubric. The Debater drill exists to train warmth under pressure.

Rubric development

The rubric is versioned and lives in one file. This is where it’s tuned — the axes, weights, and the reward/penalize signals fed to the judge all come from chat/lib/rubric.js. Changing scoring means editing that module; the trainer and these docs both update on the next deploy, in lockstep.

Property	Role in scoring
`axes[].max`	Per-axis ceiling; the weights bar above is these values.
`axes[].theory` / `source`	Shown to you on every score, and injected into the judge prompt as the axis definition.
`axes[].look_for`	The reward signals the judge is told to credit.
`axes[].avoid`	The penalize signals the judge is told to dock.
`BANDS`	Score → title (Finding your feet → Magnetic).

Calibration. The judge is instructed that an average competent conversation lands around 12–15 per axis, reserving the top of the range for genuinely skilled moves — otherwise LLM judges cluster everything near the ceiling. This is the current version’s single most important tuning knob, and the first thing to revisit as we gather real transcripts.

Live config. The machine-readable rubric is served at /api/chat/config — the exact JSON the worker and both pages consume.

Roadmap for the rubric: swap the single AI judge for a small panel (score, then adversarially check), fold in cheap structural metrics computed client-side (turn-share, question ratio, latency), and — once multiplayer lands — blend in peer ratings from the exit survey. The axes should stay stable; the evidence feeding them gets richer.