The AI glossary for sensory and consumer scientists

You can't direct a collaborator you don't understand. Before you trust a model with a transcript or a dataset, it helps to know how it reads, what it can hold in view at once, and why it sometimes makes things up.

TokenEssentialWeek 1

The chunks a model actually reads. AI doesn't read words the way you do: "astringency" might be split into three or four pieces, and a 50-page report becomes tens of thousands of them. Model limits and prices are counted in tokens, not pages.

EmbeddingEssentialWeek 1

Where a word lives in the model's meaning space, like a product on a perceptual map. "Creamy" and "smooth" sit close together; "creamy" and "invoice" sit far apart. This is how the model relates concepts without a thesaurus.

AttentionWeek 1

The mechanism that decides which words in your input matter to each other. In "the yogurt was thick, but panelists liked it," attention is what connects "it" back to the yogurt.

PredictionWeek 1

How the model writes: one plausible next piece at a time, from pattern, the way you might finish a familiar phrase. It is composing, not looking up. That is why it is fluent, and why it needs checking.

Context windowEssentialWeek 1

The model's desk: everything it can consider at once. Your question, the pasted transcript, and the uploaded scorecards all share this space. One focus group transcript fits easily; your whole study archive does not. When answers degrade and slow down, the desk is full.

LLM (large language model)EssentialWeek 2

The engine inside the big AI chat tools: a creative, probabilistic pattern recognizer trained on text. Not a search engine and not a database. Search retrieves; language models generate.

HallucinationEssentialWeek 2

A confident, plausible, made-up answer, like a citation to a study that does not exist. It happens when the model generates past its evidence. The fix is grounding: give it your sources, and check the trail.

Context hygieneEssentialWeek 2

Keeping the model's desk clean: clear instructions, only the relevant files, an example of what good looks like. The opposite, context pollution (contradictory asks, leftover chatter, irrelevant data), degrades every answer that follows.

MultimodalEssentialWeek 5

Working across text, images, audio, and video in one conversation. You can hand the model a photo of the product, the liking chart, and a consumer quote together, the way a real briefing works.

Thinking vs. non-thinking modelsOffice hours

Some models deliberate step by step before answering; others answer immediately from pattern. Deliberation helps on math and logic, but it can overthink gut-level calls, like a trained assessor second-guessing a simple liking question. Match the mode to the task.

“Search retrieves; language models generate.”

From the course

The difference between "the model says" and "our data shows" is where the answer came from. Grounded work draws on your own reports and cites them, so every claim can be followed back to a source you trust.

GroundingEssentialWeeks 1, 7

Anchoring the model's answers in documents you supply (your studies, your reports) instead of its general memory. Ground it, then push back.

RAG (Retrieval-Augmented Generation)EssentialWeek 1

The pipeline behind grounded tools. When you ask a question, the system first retrieves the relevant passages from your uploaded documents, then writes its answer from those passages, with citations. Like a careful analyst who quotes the source report, page and all.

Small RAGEssentialWeek 3

Notebook-style tools where you upload documents and the tool answers only from them, no engineering required. Load twelve reports about a category, ask questions, get cited answers. The right rung for most research synthesis.

Deep researchEssentialWeek 1

A mode where the AI plans its own search, reads dozens of sources over ten minutes or so, and returns a cited report. Much closer to a literature review than to a chat answer, and far more reliable than asking the model from memory.

TraceabilityWeek 1

Being able to follow any claim back to its source document and page. Load sources, ask, inspect the trail. If you can't trace it, don't present it.

Model EmpathyEssentialWeeks 1, 6

The course's signature habit: before blaming the model, ask what it knows, what it wants, and what it should be. It has never seen your category, your panel, or your last ten years of studies. Brief it the way you would brief a smart new hire on day one.

The 99% RuleEssentialWeek 6

99% accuracy needs 100% context. Most bad answers are context failures, not reasoning failures. Give the model the codebook, the scale definitions, and the constraints, and the last 1% stops being a guess.

The Parsing GapEssentialWeeks 2-3

Machines read your files worse than you think. A PDF or a PowerPoint is nearly opaque to a model; plain text, Markdown, and CSV are transparent. Converting your documents before analysis is often the single highest-value step in the whole workflow.

MarkdownEssentialWeek 2

A plain-text way of writing documents (headings, bullets, bold) that both people and models read cleanly. Where a Word file confuses a model, Markdown lands intact. The default format for briefs and notes in AI work.

JSONWeek 2

A plain-text format for structured information, built from labeled fields, like a well-organized codebook. Useful when you need answers your other tools can read, or want to write a very precise image prompt.

Handoff documentOffice hours

When a long chat starts to degrade, ask the model to summarize everything decided so far, then paste that summary into a fresh chat and continue. A shift handover, for conversations.

“99% accuracy needs 100% context.”

From the course

Every AI tool sits somewhere on a six-rung ladder, from bare model to autonomous agent. Knowing the rung tells you how much the tool does on its own, and how much checking you owe in return.

The AI TaxonomyEssentialWeek 2

The six-rung ladder for placing any AI tool: Model, Wrapper, RAG System, Workflow, Agentic Search, Agent. Each rung up does more on its own and shows you less of how. More autonomy means more need for judgment.

WrapperWeek 2

The product around the model: the chat window, the buttons, the settings. Your company's approved AI tool is usually an enterprise wrapper: the same engine, plus the data protections and approval trail IT needs before your studies can flow through it.

WorkflowWeek 2

A fixed sequence of steps with AI inside some of them: transcribe the groups, pull quotes by topic, cluster into themes, draft the summary. Repeatable and inspectable. You own the steps; the model does the drafting.

Agentic searchWeek 2

Search that plans and iterates on its own, deciding what to look for next based on what it just found. Deep research tools live on this rung.

AgentEssentialWeeks 2-3

A saved assistant that pursues a goal using tools, defined once and reused, the way a formula in a spreadsheet beats retyping the math. If a prompt is worth saving, make it an agent: a screener checker, a verbatim clusterer, a report formatter.

Gems and custom GPTsEssentialWeeks 4-5

The easiest way to make an agent: saved assistants inside the big chat tools that keep your instructions and reference files. Set one up with your reporting style and every session starts already briefed.

Coding agentEssentialWeek 9

An AI that writes and runs real code in your project files, showing its work as it goes. This is how a sensory scientist builds a dashboard without being a programmer: you direct and review, it types.

Extract the agentWeek 3

Prove the workflow first, save it second. Run the analysis by hand, chat by chat, until the recipe works. Then save the recipe as an agent, so the next study takes an hour instead of a day.

“More autonomy means more need for judgment.”

From the course

Prompting is not typing harder. It is briefing: deciding who the model should be, what evidence it sees, and what a good answer looks like, the same care you would give a new analyst on their first project.

Prompt engineeringWeek 2

The craft of asking well. Precision beats length: name the audience, the format, and what good looks like. Vague or contradictory instructions produce vague work, from models and interns alike.

The 10-Component FrameworkEssentialWeeks 2-3

The completeness check for an important prompt, like a study protocol: Role, Goal, Context, Rules, Examples, Format, Style, Audience, Output, Checks. Start complete, then refine.

Side chatEssentialWeek 3

Two chats, two jobs. The main chat stays anchored to your data, strict and evidence-driven. The side chat is the strategy room: define the audience, design the prompt, pressure-test the plan. Mixing them pollutes both.

Meta-promptEssentialWeek 3

Don't write the prompt; have AI write it. Describe what you need in the side chat and ask it to design the full prompt for the main chat. You are the creative director; the side chat is the prompt engineer.

Voice rambleEssentialWeek 3

Talk first, type later. Hold the voice button and ramble for sixty seconds about the analysis you can't quite articulate. The model extracts the themes you actually meant and turns them into a structured prompt.

Role promptingWeek 10

Tell the model who to be: "Act as a sensory scientist explaining a preference map to a brand manager." One line sets the vocabulary, the depth, and the tone.

System instructionsOffice hours

Standing rules a saved assistant keeps forever: your terminology, your report format, what never to do. Set them once instead of repeating them in every chat.

Prompt libraryEssentialOffice hours

Your collection of prompts that worked: the design checker, the verbatim clusterer, the executive summary format. Collect, refine, and promote the keepers into agents.

Canvas and artifactsEssentialOffice hours

A workspace beside the chat where the model builds the actual deliverable (a document, a chart, a small interactive page) and you edit it together, instead of scrolling back through drafts in the conversation.

Synthetic personaEssentialWeek 3

A consumer you can interview, built from your real research: segmentation data, focus group archetypes, verbatims. Ask her why she'd switch brands. Let R&D and marketing question the same person and hear the same voice.

Empathy auditWeeks 1-2

The reflection habit after an AI session: name the Symptom (what wasn't useful), the Repair (what context or constraint fixed it), and the Lesson (what you'll do differently). One a week compounds fast.

“Don't write prompts. Architect them.”

From the course

Data reality is a spreadsheet. Executive reality is a feeling. These are the tools that close the gap: a consumer with a face, charts people actually read, motion and sound that carry the finding into the room.

The Prompt-to-Image workflowEssentialWeek 4

Don't make the image; make the brief. Profile: turn the finding into descriptors (creamy, vibrant, refreshing). Scene: place it (a weekday breakfast table, a gym bag). Synthesize: hand the brief to the image model. Refine: change one thing at a time instead of starting over.

Mood boardWeek 4

Eight to twelve images that lock a project's palette, lighting, and texture. Attach it with every prompt and everything comes back looking like one campaign instead of ten.

Character sheet (the 3x3)EssentialWeek 4

Nine renders of the same consumer: three angles, three expressions, same wardrobe and lighting. Build it once, attach it whenever you need her again. The single biggest fix for character drift.

Character driftEssentialWeek 4

Generate the same persona through a long session and her face slowly changes, the way a story changes over retellings. The character sheet is the lock; the setting is the variable.

Re-seedWeek 4

Re-attach your reference assets (character sheet, mood board, style guide) at the start of each new session, so the model starts in your world instead of a generic one.

Look-and-feel agentEssentialWeek 4

Hand the model your brand kit once, have it write a one-page style guide, and save that as an agent. Every future chart, mockup, and slide inherits the brand look for free.

North Star imageEssentialWeek 9

One image that captures the look you want, handed to the AI as a target. A color palette tells it little; a picture tells it everything. Works the same for slides, dashboards, and apps.

Asset classesWeek 4

The six visuals worth mastering: product mockup, chart makeover, recipe card, infographic, three-panel comic, persona card. Each answers a different question in the room.

Chart makeoverEssentialWeek 4

Same data, same message, dramatically better slide. The default chart from your statistics software is a draft. Ask the model to rebuild it with brand colors, readable type, and one annotation that names what to notice.

The Director's WorkflowEssentialWeek 5

Don't shoot the video; direct it. Generate an opening still and a closing still, let the video model fill the motion between them, then cut short clips together into the piece you need.

Frames-to-videoWeek 5

The technique underneath: give the model a start frame and an end frame and it generates the movement between. Watch the seams: if the lamp disappears between frames, the cut breaks.

Sonic brandingWeek 5

Sound as meaning: a nostalgic chord says "comfort" faster than a paragraph. Score the finding to the consumer emotion you measured, not to the brand guidelines.

Voice profile cardWeek 5

A written description of a persona's voice (age, pace, warmth, accent), saved beside her character sheet so every generated clip sounds like the same person.

Consumer avatar testimonialWeek 5

Fifteen seconds of your persona on camera, saying what she wants in her own words, built from the character sheet and voice profile. It does what a verbatim quote on a slide cannot.

Cold openWeek 5

Thirty seconds of story before any agenda slide: the problem on screen, the number rising over music, the product landing. Half an hour to make. It changes how the room listens to everything after.

Hook, Reveal, ResolveEssentialWeeks 3-5

The three-beat arc under every good research story: what the audience already believes, what in the data quietly disagrees, and what they should do Monday.

“Don't make the image. Make the prompt.”

From the course

AI writes the code and runs the model. What is left for you is everything that matters: what to study, whether the answer holds, and what it means for the product. This vocabulary keeps you in charge of both ends.

The data science workflowWeek 6

The map of the whole job: Design, Collect, Clean, Transform, Analyze, Communicate. AI adds speed at every stage; your judgment gates every stage.

The Four StationsEssentialWeek 7

One trip through the kitchen with AI as your sous-chef. Collect: design the study and gather clean data. Prepare: shape raw exports into one trustworthy table. Analyze: find the signal and judge it. Deliver: turn the result into something stakeholders act on.

The 5-Stage Segmented WorkflowEssentialWeek 6

How to build any analysis with AI. Plan it in conversation first, no code. Segment it into small checkable steps. Generate one step at a time. Verify by running and reading it. Integrate the proven pieces. Never ask for the whole thing at once.

Mock dataEssentialWeeks 6-7

A fake but realistic dataset, like a synthetic panel with believable noise and score distributions, used to build and practice safely. The code doesn't care whether the data is real; your confidentiality rules do. Never draw a real conclusion from it.

The Golden DatasetEssentialWeek 7

The one clean, checked table that every analysis draws from: imports scripted, outliers flagged, panelist checks done. A single source of truth, so "which file did you use?" always has one answer.

Panelist driftWeek 7

A panelist whose scores wander away from the panel over time. Have AI script the alignment checks so drift gets flagged during collection, not discovered at reporting.

Design of Experiments (DoE)Week 7

The balancing work you used to do by hand: serving orders, product rotations, panelist assignments. Hand the model your design constraints and let it do the bookkeeping. You decide what is worth measuring.

Pressure-testing a studyEssentialWeek 6

The cheapest place to fix a study is before it fields. Hand the model your design and let it poke holes: the product you forgot, the cell that is too small, the question that leads the witness.

PCA and the biplotEssentialWeeks 7, 9-10

The course's workhorse example: principal component analysis of a sensory panel, drawn as the familiar map of products and attributes. AI writes and runs the code; you ask it to walk you through the plot until you could defend it in review.

ReproducibilityEssentialWeeks 6, 8

Never edit the spreadsheet. Every change to the data happens in a script, so anyone can re-run the analysis and get the same numbers. A study you can defend a year later, to an auditor or to yourself.

BoilerplateWeek 6

The routine set-up code every analysis needs: loading files, naming columns, formatting output. AI writes it in seconds. That speed is the gift you are borrowing.

Technical debtWeek 6

Shortcuts in code that work today and cost you later, like an undocumented cleaning step nobody can explain at handover. AI generates code cheerfully; noticing the debt is your job.

CodebookWeek 6

The key to your dataset: what each column, scale, and abbreviation means. The model cannot guess that OA_INT means overall aroma intensity on a 15-point scale. Feed the codebook with the data, every time.

The hierarchy of code solutionsOffice hours

One-off code for one-off questions, scripts for tasks you repeat, apps when a script earns an audience. Build the disposable version first, and make it permanent only after repeated use.

“Practice on mock data, but never draw a real conclusion from it.”

From the course

The week the analysis learns to last. Version control sounds like an engineering habit, but it is really a scientific one: the lab notebook, applied to code. Every result traceable, every change deliberate, every dead end reversible.

The Manual TaxEssentialWeek 8

Folders full of final_v2_REVISED, and steps you did by hand and cannot quite remember. Every hour spent hunting the right file or redoing a manual fix is a tax on your science.

Scripts vs. systemsEssentialWeek 8

A script runs once, for you, today. A system runs the same way every time, for anyone: same folders, same steps, same result on every study.

Version controlEssentialWeek 8

A dated, annotated record of every change to your analysis, kept automatically. The lab notebook, applied to code. Non-negotiable once results matter.

GitEssentialWeek 8

The tool that does version control: the undo button for science. Every save is a snapshot you can return to, so nothing is ever lost and trying things is safe.

CommitEssentialWeek 8

One saved snapshot with a note saying what changed and why. "Added panelist alignment check before PCA" beats final_v3.

BranchEssentialWeek 8

A parallel copy for trying something risky (a new cleaning rule, a different model) while your good version stays untouched. Keep it if it works; discard it if it does not.

Pull request (PR)EssentialWeek 8

The formal ask to fold your change into the shared version, reviewed by a colleague first. A built-in audit trail of who changed what and why. Quality teams love it for a reason.

Repository (repo)EssentialWeeks 8-9

Your project's durable home online: the data rules, the scripts, and the full history in one place, usually on GitHub. Not just for teams. It is where future-you finds the latest good version.

ForkWeek 8

Copy someone else's repository (like the course's standard project template) to make it your own starting point. Same shape, every study: fork it and go.

PushWeek 8

Send your saved snapshots from your laptop to the online copy, where they are safe, backed up, and shareable.

.gitignoreWeek 8

The keep-out list: files that must never enter the shared history. Raw panel data and passwords stay out by rule, not by vigilance.

The One Standard ProjectWeek 8

The same folder shape for every study: raw data that is never edited by hand, processed data built only by scripts, scripts, outputs. New study, same map, no archaeology.

Relative pathsWeek 8

Write file locations from the project folder (data/raw/panel.csv), never from your own machine (C:/Users/you/...), so the project runs on any computer, including your successor's.

Git client (GitKraken)Week 8

A visual window onto version history: every change, who made it, and why, laid out as a map instead of a command line. History a non-developer can actually read.

“A script runs once. A system runs the same way every time.”

From the course

A dense plot is not a finding. A finding is something a stakeholder can act on. This is the vocabulary for turning a validated analysis into a tool the brand team can explore without you in the room.

ShinyEssentialWeek 9

The R tool for turning a finished analysis into an interactive web page: your preference map with filters and cluster controls instead of forty static slides. AI writes the code; you stay in charge of the statistics.

app.RWeek 9

The single file a first app lives in, holding its three parts: what users see, the calculations behind it, and the data. Small enough to review, easy to save and share.

UI vs. serverEssentialWeek 9

Every app splits in two. The UI is the front door: the tabs, dropdowns, and charts your stakeholders click. The server is the engine room: the statistics you validated. They explore the first; you control the second.

ReactivityEssentialWeek 9

What makes an app feel alive: change the cluster count and the map redraws itself. No rerun request, no waiting for you to email a new version.

DashboardWeek 9

The chart people used to inspect becomes a tool people explore: pick the segment, see its profile, check the numbers underneath. The scientist can still audit everything behind it.

DeploymentEssentialWeek 9

Getting the app off your laptop so others can open it in a browser. Mostly an IT conversation, not a technical feat: public hosting for demo data, company servers behind the firewall for real data.

Validate before wrappingWeek 9

Run the analysis as a plain script and check it before building the app around it. An app can make work feel polished before the analysis deserves polish. Boring verification first.

“The browser is the front door. The server is the engine room.”

From the course

The final week: your analysis talking directly to outside services, including AI models themselves. Once this feels ordinary, a dashboard can describe each product in plain language, and your workflows stop ending at the edge of your machine.

APIEssentialWeek 10

How programs ask each other for things: a request with a return. Your R script can send a product's sensory profile to an AI model and get back two plain-language sentences describing it. Whole workflows connect this way.

Endpoint, header, body, responseEssentialWeek 10

The four parts of every call: where the request goes, who is allowed to make it, what you are sending, and what comes back. Services differ in syntax; the mental model never changes.

Status 200Week 10

The "call succeeded" code, and a caution: succeeded does not mean right. The service answered; whether the answer is faithful to your data is still your judgment.

API chainingWeek 10

One service feeding the next: a city name becomes coordinates, coordinates become a weather report. Your user sees the forecast, never the chain that made it.

API keyEssentialWeek 10

The password-like code that identifies and bills your account when your script calls a service. Treat it like a signature: anyone holding it can spend as you. For work data, use a company-approved key, not a personal one.

Environment variablesWeek 10

Where keys and other secrets live: stored on the computer and read by the script at run time. Never pasted into the code itself, never saved into version control.

Hello WorldWeek 10

The smallest possible success: one call, one printed response. The fastest way to make any of this feel ordinary is to do the tiny version today.

The full-stack mindsetWeek 10

Seeing your whole pipeline as one connected thing: data in, analysis, app, outside services. The graduation posture of the course: you are the connected scientist.

“AI is not a replacement. It is a multiplier.”

From the course