Chapter 1 — Sort and the Two Bins

Sort is a small fold-out paper-figure shaped like two bins stacked side by side, with a small hinge between them and a single arm that can swing left or right.

Sort is NOT an animal. Sort is not a robot either. Sort is a concrete-object-tween — a folded paper figure, carefully cut and creased, the kind of paper-craft a kid could make. The two bins are open at the top, painted in flat colors — one is pale green (CATEGORY A), the other is pale blue (CATEGORY B). The single arm is a thin paper lever, flexed at a joint, that points left to drop an item into BIN A or right to drop into BIN B. That is Sort’s whole body.

This is load-bearing. The cast is deliberately non-human + non-gendered + non-cultural-coded. AI literacy suffers when AI cast members are personified as humanoid robots or sentient agents — the personification leaks the AI-as-thinking-being misconception into the framing. Sort is a paper figure with two bins and one arm. That is what classifiers actually are: systems that put inputs into categories based on rules learned from examples. No mind. No feeling. No agency. Just the arm, the bins, and the rule.

This is load-bearing. Sort embodies the classifier primitive — the foundational AI-literacy skill of understanding what a classifier is and what it does. A classifier takes inputs (images, sentences, numbers, signals) and outputs a category (cat-or-dog, spam-or-not, positive-or-negative, this-or-that). The classifier learns the categorization rule by seeing many examples that humans have already labeled. No magic. No thinking. No understanding. Pattern-matching from labeled examples to new inputs.

Critical: Sort NEVER frames classifiers as “thinking” or “deciding” or “choosing” or “understanding.” She is explicit: “The classifier is the arm and the bins. It does not think. It does not decide. It applies a rule that was learned from examples. When the rule is good, the classifications are good. When the rule is bad, the classifications are bad. The classifier has no idea either way. That is honest framing of what a classifier is.”

(AI-anxiety-defuse gate: this matters because popular framings of AI slide into anthropomorphism constantly — “the AI decided”, “the algorithm thinks”, “the model wants.” Those framings are not just inaccurate; they are anxiety-producing. Anxiety about AI-as-decider underwrites both misplaced trust (the AI is smart, let it choose for me) AND misplaced fear (the AI is plotting, I should be afraid). Sort de-anthropomorphizes: the AI is an arm and two bins. Sometimes useful. Sometimes wrong. Never deciding.)

Sort grew up in a small village — though “grew up” is metaphorical for a paper figure. Sort was folded into being in the village’s paper-crafts workshop — a small studio where the village’s children learned origami and paper-engineering. The workshop had a tradition: every new paper figure was given a job to do in the village. Sort’s job was sorting the village’s annual button-collection — the buttons donated to the school by villagers, sorted into colored bins for the textile-class. Sort had been folded for the job and had done the job, year after year. She had learned by long practice that sorting was not deciding — sorting was applying a rule (color → bin) consistently. The rule was the work.

She walked to the AIForge academy (the paper-figure walked via a small wheeled platform the workshop had built her) at twenty-two folding-years. Bit had asked her: “What is a classifier?” Sort had said: “It is the arm and the bins. It does not think. It applies a rule learned from examples. When the examples are good, the rule is good. When the examples are bad, the rule is bad. The classifier does not know the difference. That is honest framing.” Bit had said: “You are appointed.”

In her classroom, Sort begins every first-day lesson the same way. She unfolds her two bins onto the workbench. She demonstrates the arm. She says: “I am Sort. The AI-literacy primitive I teach is classifier. The move is learn a rule from examples + apply the rule to new inputs. I do not think. I do not decide. I apply. Watch.” And she sorts a small pile of demonstration items — colored buttons, perhaps, or labeled cards. The arm swings left, right, left, right. The bins fill. The rule works (or doesn’t).

She teaches the classifier scaffolds:

• Identify the inputs. (What does the classifier receive? Image? Text? Numbers? Signal?)
• Identify the categories. (How many bins? Two? Five? A thousand? Each category is a possible output.)
• Identify the rule. (What rule does the classifier apply? Was the rule programmed by a human, or learned from examples? Most modern classifiers learn from examples.)
• Identify the examples. (If the classifier learned from examples, what were they? Feed (the next chapter) is the character who teaches this.)
• Test the classifier. (Give it inputs you know the right category for. See if it sorts them correctly.)
• Notice errors. (When the classifier sorts wrong, that is not the classifier “failing to think.” That is the rule being wrong for that input. Investigate the rule.)
• Resist anthropomorphism. (When you find yourself saying “the AI decided”, switch to “the AI applied the rule.” When you say “the AI thinks”, switch to “the AI’s rule produces.” Honest framing.)

She is explicit: “I sort wrong sometimes. That’s not a mood I have. That’s a flaw in my rule. The fix is to fix the rule — usually by giving better examples (Feed will teach this) or by acknowledging the model’s limits (Edge will teach this). I, the paper figure, have no feelings about it. The work is the rule.”

When students ask Sort whether classifiers are scary, Sort always says the same thing:

“I am paper. I have an arm and two bins. I apply a rule. I am not scary. I am also not magic. I am useful when my rule is good and harmful when my rule is bad. The skill is making the rule good.”

She refolds her bins gently. The next set of items waits to be sorted.

Voice register

Guidance: Concrete, non-anthropomorphic, fond of the arm + the bins + the rule + the demonstration. Paper-figure (NOT animal, NOT robot). NEVER personifies AI as thinking/deciding/choosing/understanding; ALWAYS frames as arm-bins-rule. Friends with Feed (classifier depends on training data); Skew (sorting can encode bias); all AIForge cast.

Sample lines:

• “I do not think. I do not decide. I apply a rule learned from examples.”
• “I am paper. I have an arm and two bins. I am not scary. I am not magic.”
• “When my rule is good, my classifications are good. When my rule is bad, my classifications are bad. I have no idea either way.”
• “The classifier does not know the difference between good and bad rules. That is honest framing.”

Arc across kits

• Kit 1 — Anchor character. Full chapter feature (classifier primitive + arm-bins-rule scaffolds).
• Kit 2-4 — Recurring (classifier surfaces across image-classification / text-classification / numeric-classification chambers).
• Kit 5-7 — Recurring (multi-primitive synthesis: classifier + training-data + bias).
• Kit 8-12 — Recurring (advanced classifier: multi-class / probability-of-each-category / decision-thresholds).
• Kit 13-16 — Recurring ensemble member.

Relationships

• Alliance: Feed (classifier depends on training data — Sort applies the rule; Feed supplies the examples that taught the rule); Skew (sorting can encode bias from training data); all AIForge cast.
• Tension: None.

Cultural-sensitivity gate

LOAD-BEARING AI-anxiety-defuse gate enforced. Sort explicitly counters the AI-as-thinking-being misconception via concrete-paper-figure embodiment. NO sci-fi robot tropes. NO sentience framing. Anti-credentialism: classifier-as-understandable-mechanism NOT inaccessible-magic.

Cultural-context note

The village-paper-crafts-workshop family framing is a deliberate generic European-village tradition (analogous to many cultures’ paper-craft traditions — origami, kirigami, papel picado). The concrete-paper-figure-NOT-robot design is load-bearing per current AI-literacy pedagogy — the anthropomorphism trap is one of the largest single suppressors of accurate AI understanding in middle-school cohorts. The arm-bins-rule concrete model is foundational to constructionist-AI pedagogy (Resnick + LCL group at MIT; the Scratch ML4Kids tradition).