AI Metaphors, Traceability, and The Reader

note

While working on RTS, I found myself drawn to reflection on the Reader Response Criticism movement. Reader-response theorists challenged the centrality of the author. By exploring content generation with generative AI, RTS challenges the existence of one. The AI model's output can't be traced to a sovereign mind but only to statistical pattern-matching. That absence reveals how much of what we normally attribute to authorial presence may, in fact, be the reader's work. So in many ways the approach to AI literacy within the design of RTS shares some commitments and aligns loosely with reader-response theory in that the reader's role in making meaning is centered. The twist is that in generative AI there is no author at all. There's synthetic coherence with absent intention. This makes the act of reading even more pronounced, more revealing. What reflective stance should we take when we find ourselves constructing meaning from a plausible, but authorless, synthesis of our own words? In RTS, reflection on one's interpretation of that construction is central.

RTS (Research to Story) as a web application openly integrates generative AI into the student inquiry process. But it doesn't do so under the assumption that the system is "understood" or that it understands. Early versions of this documentation described RTS as attempting to use features of a particular LLM's API configuration as a way of promoting AI transparency, but that term now feels misleading. RTS doesn't (and can't) reveal the inner workings of generative models. What it can do is reveal the phenomenon of understanding that surrounds them and invite students to examine that phenomenon.

RTS exposes features like token counts, "thought" summaries, and model traces not because these features make the model legible. Instead, they make visible the ways fluency gets mistaken for cognition. RTS turns traceability into a site of critical reflection.

note

Want the full conceptual framing? See the forthcoming AI Literacy in RTS section. This document focuses on how metaphor, interface design, and metadata exposure work together to create pedagogical moments for critical AI engagement.

Why Metaphor Matters in Generative AI

Much of the language we use to talk about AI is metaphorical and highly anthropomorphic. We say the model "thinks," "understands," "hallucinates," or "plans." The problem here is that these words are not technical descriptions. They are better understood as framing devices and ways of making something alien feel familiar. But in the context of education, scholarship, and student interpretation, metaphor cannot be considered neutral. It shapes what we believe.

The Risk of Unexamined Metaphors

When metaphors go unacknowledged, they become invisible scaffolding for our assumptions:

• A model that "reasons" appears capable of inference.
• A model that "hallucinates" seems quirky rather than brittle.
• A model that "understands" invites trust.

These metaphors do more than attempt description: they naturalize and normalize. In doing so, they obscure the actual mechanics of generative systems: statistical pattern-matching without awareness, intention, or semantic comprehension. When we use these metaphors, we don't just describe what the model is doing, we build stories around what we think it's doing. And those stories determine how we relate to it.

AI Literacy Must Address Metaphor

AI literacy must be preoccupied with teaching students to:

• Identify metaphor in system design and explanation
• Interrogate its effects
• Understand how metaphor operates as framing devices that influence trust, interpretation, and meaning

Syntheses Are Not Truths

In RTS, the AI-generated syntheses are therefore presented as texts—language artifacts shaped by a combination of a student's input, the model's training, and the structure of the prompt. They're worth reading not because the model "understands," but because the act of reading helps surface how coherence is constructed without intention.

The synthesis that is generated is not presented as a demonstration of AI cognition. It's a provocation. A structure students can read, question, disagree with, revise. The fact that it came from a system without intention is part of what makes it interesting to read more closely.

note

What RTS is doing is staging a relationship between interpretability and synthetic coherence. To read a model critically is to read the metaphors that surround it and to ask who they serve.

On Language: Alternatives to Anthropomorphic Framing

RTS encourages students to name metaphor and consider more precise phrasing.

Cognition & Understanding Metaphors

Metaphor	Interpretive Context in RTS
AI "thinking"	Shorthand for inference trace. Used to foreground synthetic coherence without cognition.
Thought summary	A model-generated synthesis. Treated as rhetorical surface, not evidence of inner reflection.
Model "reasoning"	Read as mimicry of argument structure. A performance of logic, not logical intent.
"Understands the prompt"	Pattern recognition framed as success in instruction-following—not comprehension.
"Knows your topic"	Fluency mistaken for grasp. Used in RTS to stage interpretive questions about projection.

Intentionality & Agency Metaphors

Metaphor	Interpretive Context in RTS
"Intent" or "purpose"	Reframed as prompt-shaped output. The model does not initiate or choose; it continues.
"AI as collaborator"	Treated as metaphor for co-composition. Not a partner with goals, but a prompt-responsive system.
"Voice" or "style"	Imitated discourse pattern. RTS asks students: What does this voice suggest? How is it persuasive?

Process & Learning Metaphors

Metaphor	Interpretive Context in RTS
"Learning" (as in fine-tuning)	Defined as statistical weight adjustment not conceptual understanding. Clarified to avoid personification.
"Hallucination"	Treated as failure in continuity or data retrieval. Used to destabilize the expectation of factual grounding.
"AI output cost"	Token counts are shown not as "effort," but as a way to visualize the computational shapeof linguistic prediction.

Metaphors of Navigation & Function

Metaphor	Interpretive Context in RTS
"Black box"	Common framing for opaque systems. RTS pushes past it by asking: What do we do with the surface?
"Transparent AI"	Problematic. RTS reframes "transparency" as interpretive exposure, not legibility of internal process.
"Trace" or "path"	Used deliberately to describe visible artifacts of model output generation—not signs of linear logic or plan.

The Interface as AI Literacy Instrument

RTS treats the user interface itself as another pedagogical surface (I’m designing it, why not make it more than just a way to access features, but a way to teach critical AI engagement through every interaction?). The interface embodies my conceptual stance toward AI metaphor and interpretability.

Design Philosophy: Interface as Frame-Maker

Rather than hiding computational processes or making AI feel seamless, RTS deliberately surfaces the machinery through interface choices. Every loading state, label, and metadata panel is designed to:

1. Resist anthropomorphism - Language choices prime students to read outputs as statistical artifacts
2. Make computation visible - Token costs, processing traces, model versions shown consistently
3. Sustain critical distance - Persistent educational framing prevents unreflective acceptance
4. Center student agency - Interface reinforces that meaning-making happens on the reader's side

The goal isn't to make AI "transparent" (impossible), but to make the act of reading AI outputs into an explicit pedagogical event.

1. Mechanistic Loaders: Teaching Through Waiting

Traditional loading spinners use anthropomorphic cues: thinking dots, animated faces, "AI is thinking..." messages. RTS replaces these with mechanistic loaders that visually represent computational processes without implying cognition.

Three Loader Variants: Token Bars (Reflection Rounds)

• Three horizontal bars that "breathe" in width
• Visual metaphor: sequencing, assembly, arrangement
• Paired with spinner text: "Sequencing probability traces — no ideas here, just patterns"
• Pedagogical effect: Students see pattern-matching work, not thinking

⠀Shimmer Lines (Synthesis Generation)

• Horizontal lines with gradient shimmer effect
• Visual metaphor: text being prepared for display
• Paired with spinner text: "A plausible story is forming — coherence without comprehension"
• Pedagogical effect: Synthesis framed as assembly, not insight generation

⠀Ring Spinner (Fallback)

• Minimal rotating circle
• Universal "loading" signal
• Used when motion-reduced preferences detected
• Maintains non-anthropomorphic stance even in simplified form

Technical Implementation:

import { MechanisticLoader } from '@/components/MechanisticLoader';

// During question generation
<MechanisticLoader
variant="token-bars"
text={getSpinnerByRound(FLOW, 'questions', round)}
subtext="Preparing question candidates from patterns…"
/>

// During synthesis
<MechanisticLoader
variant="shimmer"
text={getSpinnerByRound(FLOW, 'synthesis', round)}
subtext="Assembling synthesis text…"
/>

Accessibility:

• role="status" and aria-live="polite" for screen readers
• Respects prefers-reduced-motion (disables animations)
• Consistent height to prevent layout shift
• Low CPU usage (simple CSS keyframes)

2 Round-Aware Spinner Text: Micro-Lessons in Process

Loading states become teachable moments through carefully crafted spinner text that varies by:

• Flow (Movement 1, Spark of Inquiry, Puzzles and Unknowns, etc.)
• Phase (question generation vs. synthesis)
• Round (progressive messaging across 4 rounds)

Example Progression - Spark of Inquiry:

• Round 1: "Constructing an origin story out of statistical echoes."
• Round 2: "Your spark is being wrapped in plausible sentences — keep your match lit." *
• Round 3: "Coherence ahead: it only looks like memory."
• Round 4: "The illusion of beginnings is being spun from probability weights."
• Synthesis: "A plausible story is forming — coherence without comprehension."

Pedagogical Strategy:

• Early rounds: Introduce core concepts (statistical, patterns, probability)
• Middle rounds: Name the interpretive trap (sounds like memory, looks like understanding)
• Late rounds: Reinforce student agency (your spark, you interpret)
• Synthesis: Frame output as provocation, not conclusion

Technical Implementation: Centralized registry ensures consistency and easy updating:

// /lib/spinners.ts
export const SPINNERS: SpinnerConfig = {
sparkOfInquiry: {
questions: [
"Constructing an origin story out of statistical echoes.",
"Your spark is being wrapped in plausible sentences — keep your match lit.",
"Coherence ahead: it only *looks* like memory.",
"The illusion of beginnings is being spun from probability weights."
],
synthesis: [
"A plausible story is forming — coherence without comprehension."
]
},
// ... other flows
};

export function getSpinnerByRound(flow: FlowKey, phase: Phase, round: number): string {
const pack = SPINNERS[flow]?.[phase] || [];
const idx = Math.max(0, Math.min((round ?? 1) - 1, pack.length - 1));
return pack[idx] ?? '';
}

3. Round Education Cards: Persistent Critical Framing

Each reflection round displays a persistent education card at the top of the interface, a non-dismissible reminder that primes critical reading before students select questions.

Four-Round Progression: Round 1: The Statistical Foundation "This AI model is a token-sequence predictor assembling plausible questions, not a mind making them. Use them as scaffolds, not verdicts. If you feel 'seen,' label it as an interpretive effect and keep authorship with you."

Round 2: Structure Without Care "You are interacting with a machine trained on countless stories. It is excellent at mimicking their structure. The AI model can arrange coherence; it cannot care or commit. Treat the output as raw material. You decide what carries forward—and you own the claims."

Round 3: The Knowledge Gap "The AI model generating these questions knows nothing about storytelling, podcasts, or research. The 'thinking' and 'storytelling' in this exchange must happen entirely on your side of the screen."

Round 4: Human Agency Sovereignty "Your words are the sole source of genuine reflection, inquiry, and understanding in this process. The AI's role is to generate text that prompts you to reveal and examine your own interpretive habits and sense-making frames. You are the only agent of meaning here."

Design Specifications:

• Always visible (not dismissible)
• Same progression across all deep dive categories
• Markdown support for emphasis (bold text)
• Placed above question list, after AI-generated summary
• Neutral styling (not alarming, just persistent)

⠀Pedagogical Rationale: These cards function as conceptual primers that:

• Counter the illusion of AI understanding through repeated exposure
• Build metacognitive awareness of interpretive projection
• Reinforce student authorship and agency
• Progress from mechanics (token prediction) to ethics (ownership)

Technical Implementation:

import { RoundEducationCard } from '@/components/RoundEducationCard';

{!isGenerating && round <= 4 && (
<RoundEducationCard round={round as 1 | 2 | 3 | 4} />
)}

4. Non-Anthropomorphic UI Language Registry

All interface labels, button text, and microcopy pull from a centralized registry (/lib/uiLanguage.ts) designed to avoid personification while remaining clear and functional.

Key Reframings:

Traditional Label	RTS Label	Pedagogical Effect
"AI is thinking..."	"Processing..."	Computational framing
"AI-generated insights"	"AI-Generated Summary"	Neutral description
"Thought process"	"The Imitation of a Thought Process"	Names the performance
"Understanding your research"	"Pattern-matching from your text"	Accurate mechanism
"AI reasoning"	"Statistical inference trace"	Technical precision
Example from Registry:

export const UILang = {
loaders: {
generatingQuestions: 'Preparing question candidates from patterns…',
generatingSynthesis: 'Assembling synthesis text…',
},
reflection: {
summaryLabel: 'AI-Generated Summary',
promptPlaceholder: 'Write your reflection here…',
},
aiPanel: {
toggle: 'Inspect Model Artifacts',
tokenUsageTitle: 'Token Usage',
imitationTitle: 'The Imitation of a Thought Process',
columns: { 
prompt: 'Prompt', 
response: 'Response', 
thinking: 'Processing' 
},
educationTitle: 'How to Read This Output',
educationBody: 'Treat the text as a statistical artifact. Any sense of "insight" is an effect to analyze, not authority to accept.',
},
} as const;

Maintenance Benefit: Centralizing language enables system-wide updates to maintain pedagogical consistency as understanding of effective AI literacy evolves.

5. Progressive Disclosure: AI Metadata Panels

Token analytics and "thought summaries" are not hidden, but they're not thrust at students immediately. Progressive disclosure through expandable panels gives students control over their engagement depth.

AIMetadataPanel Component Structure: Always Visible (Collapsed State):

• Model used (e.g., "gemini-2.5-pro-002")
• Total token count for current interaction
• Toggle to expand: "Inspect Model Artifacts"

⠀Expandable Content:

• Token breakdown (prompt, response, thinking, total)
• Cumulative token usage across rounds
• "Thought summary" (when available)
• Educational context about what these numbers mean

⠀ Pedagogical Framing Within Panel: The expanded view includes educational text:

"Token counts reveal computational cost, not depth of thinking. High token usage means more pattern-matching operations occurred, not that the AI 'thought harder' about your topic."

"Thought summaries (when available) are traces of the model's chain-of-thought processing. They are not evidence of understanding—they are intermediate statistical outputs formatted to resemble reasoning."

Why Progressive Disclosure Works:

• Doesn't overwhelm students in early rounds
• Rewards curiosity with deeper technical insight
• Makes metadata feel like evidence to examine, not distracting noise
• Respects different levels of technical interest

⠀6. Integration Pattern: How Interface Elements Work Together

The interface components function as a layered pedagogical system:

┌─────────────────────────────────────────────┐
│ Round Education Card (Persistent)           │
│ "This AI model is a token-sequence          │
│ predictor assembling plausible questions…"  │
└─────────────────────────────────────────────┘
↓ Primes critical stance
┌─────────────────────────────────────────────┐
│ Mechanistic Loader (During Generation)      │
│ [Token Bars Animation]                      │
│ "Sequencing probability traces—no ideas     │
│ here, just patterns"                        │
└─────────────────────────────────────────────┘
↓ Visual + textual reinforcement
┌─────────────────────────────────────────────┐
│ AI-Generated Summary                        │
│ [Output text]                               │
│ └─ AIMetadataPanel (Collapsible)            │
│    • Model: gemini-2.5-pro-002              │
│    • Tokens: 3,847 total                    │
│    └─ Expand: See processing details        │
└─────────────────────────────────────────────┘
↓ Metadata available for inspection
┌─────────────────────────────────────────────┐
│ Questions (Randomized, Student Selects)     │
│ [10 Socratic questions]                     │
└─────────────────────────────────────────────┘

Teaching Through Repetition: Over 4 rounds, students encounter:

• 4 different education card messages
• 4 different spinner texts during generation
• 4 opportunities to inspect metadata
• 4 synthesis moments with different framing

By Movement 1 completion, students have engaged with persistent, varied, and reinforcing messages about AI as statistical pattern-matching—not through a one-time disclaimer, but through the lived experience of the interface.

Interpreting "AI Thought"

RTS sometimes uses phrases like "thinking tokens," "AI reasoning trace," or "thought summary." These terms are deliberate metaphors. They describe the shape of output, not the presence of understanding. The system predicts tokens. It does not plan, reason, or reflect. I use this metaphorical language only when paired with explanation.

Student-Facing Framing

Why AI Feels Like It's Thinking (But Isn't)

When students say: "This reflection sounds like my brain but better," they're responding to the phenomenon of apparent comprehension. What's actually happening: The model is predicting the next word, one at a time, based on patterns it learned from a large dataset. That's it. There is no awareness. No understanding of your topic. No intention. But:

• Language is a compressed form of reasoning.
• When trained on enough of it, the model produces text that resembles reasoning patterns.
• It becomes convincing not because it understands, but because we do.

So Why Use These Features?

RTS uses token counts and "thought summaries" to stage a paradox. By exposing token counts, prediction traces, and synthetic outputs, RTS can't really reveal "how the model works" because the goal of RTS has never been to create a transparency engine but to function more as a frame-maker. It's showing students:

• What kinds of information we treat as evidence
• What metaphors we use to narrate system behavior
• What appearance of intention we project onto coherent output

So instead of claiming that an AI model is legible, RTS aims to show how and why we experience it as if it were. That is a literacy problem. That is a reading problem. These traces provoke questions:

• Why does this output feel persuasive?
• What does it seem to know—and what is that feeling based on?
• What do I bring to the interpretation that the model didn't provide?

That's the goal. Not belief. Not demystification. But critical engagement with synthetic coherence itself.

Pedagogical Rationale

Students encounter AI in systems that rarely reveal their assumptions. RTS is designed to:

• Surface AI's structure, but not mistake it for intention
• Expose model fluency while resisting personification
• Ask students to reflect on their own interpretive habits

Instead of simplifying or hiding synthetic coherence, RTS creates a context for studying it. Traceability becomes a frame for literacy, instead of a "window" into the machine.

Metadata as Disruption

RTS displays as much metadata as possible and in no way suggests we are "looking" inside the AI model. They are artifacts of simulation, traces of a system trained to produce coherent text. Displaying these "traces" can be an entry into critically reflecting on generative AI's alignment problems via so-called undesirable behaviors of AI models like "sycophancy," "scheming," and "reward hacking."

For now, RTS treats this AI metadata as just another "text" made visible so students can:

• Notice the synthetic coherence
• Mark what feels "real" and why
• Question how their own sense-making is being shaped

Transparency here means: how much of the phenomenon are we willing to study?

Technical Implementation Overview

"Thought" Summaries

RTS uses Gemini's thinkingConfig with includeThoughts: true to request model-generated interpretive glosses. Instead of claiming these represent internal reasoning, RTS just admits they represent a computational process that we frame in a language of reasoning.

Sample Output: "The student has progressed from naming cultural touchpoints to shaping a reflective narrative arc. The pivot toward a multisensory podcast experience is insightful and positions the student as both narrator and researcher..."

These are used to:

• Prompt student annotation and interpretation
• Encourage critique of tone, coherence, and persuasion

⠀Technical Details:

• Model: Gemini 2.5 thinking models (required for “thought” summaries with structured output)
• API Configuration: thinkingConfig: { thinkingBudget: -1, includeThoughts: true }
• Response Processing: Extract part.thought content from multi-part responses

Comprehensive Token Analytics

Each AI interaction includes detailed token usage data:

• promptTokenCount - Tokens used for user input and context
• candidatesTokenCount - Tokens used for AI response generation
• thoughtsTokenCount - Tokens used for internal AI reasoning
• totalTokenCount - Complete computational cost

⠀Multi-Round Analytics:

• Current round token usage
• Cumulative token totals across rounds
• Round-by-round breakdown for research journey awareness
• Movement-wide token summaries in synthesis view

Clean Data Architecture

AI Metadata Storage Strategy:

• reflection_rounds - Complete AI interaction metadata (thinking, tokens, summaries)
• followup_questions_log - Individual questions + model reference only
• movement_synthesis - Synthesis AI metadata + journey totals

This prevents data duplication while maintaining traceability.

Progressive Disclosure UI

AIMetadataPanel Component:

• Always visible: Basic token counts and model used
• Expandable: Detailed "thinking" process and token analytics
• Educational context: Explanations of why it matters
• Running totals: Cumulative computational cost across rounds

Research Insights

Multi-Model Testing Capabilities The Model Workbench allows comparative testing of different models against the same student input:

• Side-by-side question generation comparison
• Token efficiency analysis across models
• Quality assessment of AI reasoning approaches
• Research methodology validation

This is for showing how different patterns of synthetic coherence operate under similar constraints.

Why This Matters

RTS doesn't promise transparency but it tries to promise interpretability. Not of the model's internals but of our own responses to the model's performance. We don't just want students to see that AI outputs are shaped by prompt and probability. We want them to ask:

• Why did this feel like a good answer?
• What am I projecting into this language?
• What's being reflected back at me?

That's where AI literacy happens: around, inside, and about the reader's interpretive habits. The interface itself is built around a pedagogical architecture designed to sustain critical distance, make computation visible, and center student agency in meaning-making. Every loading animation, every label choice, every metadata panel is asking students to read AI outputs as texts to interpret.