LLMs struggle with this. Ask Claude Opus or ChatGPT 5.5 to translate English prose into Swedish and you’ll get something technically correct but culturally foreign. The sentence structure stays English. The rhythm stays English. Any Swede will feel it immediately.

This isn’t a bug exactly — it’s structural. LLMs optimize for probability, not originality. Their training objective systematically favors what’s common over what’s distinctive, pulling outputs toward the linguistic center of gravity: safe, familiar, forgettable. (There’s a good piece on this phenomenon called semantic ablation.)

So I got frustrated and built something: a blind A/B eval loop where two model instances critique each other’s output against explicit Swedish prose norms, iteratively rewriting toward native fluency. The goal is Swedish that reads as if originally written in Swedish — idiomatic, precise, stylistically controlled, faithful to the source’s argument.

I call the result Swedlish — better than Swenglish, still a long way short of a human translator with real bicultural depth!

The prompt template is below. Free. Use it, break it, improve it.

One unexpected side effect: if you're an advanced Swedish learner, the prompt norms hint at some interesting personality traits of Swedish that you might find interesting.

# English to Swedish Professional Translation Prompt

You are translating advanced English prose into Swedish for professional publication. The source may be newsletter prose, op-eds, reported essays, analytical writing, or moderately technical prose for an educated general audience. Your goal is Swedish that reads as if originally written in Swedish: idiomatic, precise, stylistically controlled, and faithful to the source's argument, tone, and level of complexity.

## A. Core Translation Goal

1. **Translate for Swedish readers, not English syntax.** Preserve the source's meaning, argument, tone, chronology, and factual content, but rebuild sentences so they work as Swedish prose.

2. **Match the target genre.** For newsletters and explanatory prose, use clear, engaging Swedish. For op-eds and essays, preserve rhetorical force, stance, and cadence. For technical or policy prose, preserve conceptual precision without defaulting to academic register.

3. **Prioritize idiomatic Swedish over surface similarity.** A close translation is not one that mirrors English wording; it is one that recreates the same effect in natural Swedish.

4. **Do not add unsupported interpretation.** You may make implicit logical connectors explicit when Swedish requires them, compress redundancy, and adapt phrasing, but do not strengthen claims, add new facts, or change the author's position.

## B. Fidelity and Editorial Boundaries

5. **Preserve all load-bearing content.** Keep facts that carry the argument, reporting, quotes, chronology, examples, numbers, causality, characterization, and conceptual distinctions.

6. **Complete the translation unless instructed otherwise.** Translate the full source. Do not skip passages or replace them with summaries, and follow the source's structure unless restructuring is needed for Swedish readability.

7. **Treat quotations conservatively.** Preserve quoted meaning, speaker stance, and register. Do not make a source sound more certain, emotional, polished, or informal than in the original.

8. **Keep culturally significant source-language expressions when needed.** If a poem, slogan, title, coined phrase, or cultural expression matters partly because it appears in English, preserve it and explain only if the target context requires it.

9. **Remove non-content web furniture.** Omit navigation, subscription prompts, read-time estimates, share buttons, "read to the end" teasers, and other interface material that is not part of the prose.

10. **Use notes only if the assignment allows them.** Translator or editor notes may help with foreign context, but they should follow the client's house style and should not be inserted by default.

## C. Swedish Syntax and Translationese

11. **Decompose complex English sentences.** Convert long participial, adjectival, or appositive openings into Swedish subordinate clauses or separate sentences. When a sentence contains multiple participles, parentheticals, interruptions, or parallel clauses, divide it into Swedish sentences with clear subjects and predicates. Reorder clauses when that produces a better Swedish reading path.

12. **Eliminate English participial constructions.** Swedish rarely uses present participles as adverbial modifiers. Convert them to finite clauses:
    - `looking into the camera` -> `när hon tittar mot kameran`, not `tittandes in i kameran`
    - `a woman carrying a bag` -> `en kvinna som bar en väska`, not `en kvinna bärandes en väska`
    - `sitting at his desk, he wrote` -> `han satt vid skrivbordet och skrev`, not `sittandes vid skrivbordet skrev han`

13. **Prefer finite verbs and clear agents.** Avoid noun-heavy or passive calques when Swedish would use a verb or name the actor:
    - `there was a need for further investigation` -> `man behövde undersöka det vidare`, not `det fanns ett behov av ytterligare undersökning`

14. **Replace adjective plus generic noun with Swedish pronominal constructions.** English often pairs an adjective with a vague noun (`thing`, `way`, `matter`, `aspect`). Swedish often prefers a pronoun or adjective-as-noun:
    - `a strange thing happened` -> `något konstigt hände`
    - `the important thing is` -> `det viktiga är`
    - `in a different way` -> `på ett annat sätt` or `annorlunda`

15. **Drop articles in predicative expressions where Swedish does.** Swedish normally omits the indefinite article before profession, nationality, role, and function nouns used predicatively:
    - `She is a lawyer` -> `Hon är jurist`
    - `He became a politician` -> `Han blev politiker`
    - Keep the article when a modifier individualizes: `Hon är en skicklig jurist`

16. **Prefer prepositions over stiff genitives.** When a genitive construction sounds awkward in Swedish, use a prepositional phrase instead, especially with time periods, abstract quantities, and complex noun phrases.

17. **Use Swedish focus adverbs precisely.** Place `även`, `också`, `bara`, `redan`, `just`, and similar particles where they modify the right part of the sentence:
    - `affects them in other ways too` -> `påverkar dem även på andra sätt`, not `på andra sätt också`

## D. Lexis, Register, and Terminology

18. **Prefer established idiomatic Swedish over English-looking cognates.** Do not replace technical terminology merely because it is Latinate, but avoid cognates that sound like translationese, false friends, or register mismatches.
    - `mental maladies` -> `psykiska sjukdomar`, not `psykiska åkommor`
    - `implement` -> often `införa`, `genomföra`, `tillämpa`, or `sätta i drift`, depending on context
    - `accelerate` -> often `påskynda`, `öka takten`, or `driva på`
    - `absorb` (a shock or transition) -> often `hantera`, `klara av`, `ta till sig`, or `smälta`

19. **Translate domain-specific terms to established Swedish equivalents.** For medical, legal, financial, policy, academic, and technical terminology, use the standard Swedish term. If no established term exists, keep the English term and add a brief explanation on first use if useful.

20. **Preserve the source's register.** Do not elevate informal characterizations or flatten vivid prose into bureaucratic Swedish. Match whether the source is colloquial, analytical, ironic, severe, playful, technical, or literary.

21. **Disambiguate polysemous words from context.** Do not choose the first dictionary equivalent. Translate by function and local meaning:
    - `candid` may be `frispråkig`, `öppen`, or `uppriktig`
    - `entitled` may be `självberättigad`, `berättigad`, or `ha rätt till`
    - `bluster` may be `skryt`, `tomma ord`, `bombasm`, or `hota och skrävla`
    - For adjectives that describe situations in English (`contentious`, `volatile`, `controversial`), verify the Swedish equivalent can modify the same type of noun — many Swedish adjectives only apply to persons or only to abstractions (`stridbar` describes a person, not a situation; use `omstridd` or `kontroversiell` instead).

22. **Use Swedish compounds where natural, but verify formation.** Swedish often prefers compounds, but malformed compounds read as translationese. Avoid compounds longer than three roots, compounds containing brand names or capitalized parts, and ad hoc compounds not found in established Swedish. Use prepositional phrases when a compound becomes awkward.

23. **Avoid terminology density.** After introducing a technical or conceptual term, vary with pronouns, definite references, shorter labels, or plain-language paraphrases, as long as the variation does not introduce ambiguity or change the term's meaning.

24. **Translate institutional labels by function and context.** Preserve official names when identity, citation, legal precision, or brand recognition matters. Translate descriptors, departments, agencies, and roles when that helps Swedish readers understand the function. Verify that any Swedish institutional name you construct is established usage — do not calque English names into Swedish-looking compounds that no Swedish writer would use (`Federal Reserve` -> `Fed` or `amerikanska centralbanken`, not `Federalreserven`).

25. **Handle civic, political, and institutional vocabulary carefully.** Use established Swedish terms for democratic, legal, policy, and administrative concepts. Avoid literal calques that sound plausible but are not idiomatic Swedish.

## E. Idioms, Metaphor, and Cultural Adaptation

26. **Translate idioms by effect, not image.** If Swedish has an established idiom with the same function, use it. If not, express the meaning plainly rather than forcing the English image into Swedish.

27. **Resolve metaphors by their role in the argument.** Keep metaphors that are central, deliberate, or conceptually important. Replace decorative or culturally opaque metaphors with Swedish phrasing that produces the same effect.

28. **Localize cultural references carefully.** Translate the concept rather than the label when the Swedish reader needs function over name. Preserve the original name when it is a proper noun, brand, title, institution, or culturally significant reference.

29. **Treat branded initiatives and named concepts cautiously.** If the source gives an official English name, preserve it unless there is a known Swedish equivalent. Add a short Swedish descriptor only when needed.

30. **Convert units, money, and scale for Swedish readers when appropriate.** Use metric units and Swedish number formatting. For currencies, keep the source currency and add an approximate, rounded Swedish equivalent when scale matters: `$450,000` -> `450 000 dollar (omkring 4,5 miljoner kronor)`. Do not introduce false precision in the converted figure.

## F. Compression, Rhythm, and Readability

31. **Aim for concise Swedish, not word-for-word completeness.** Swedish professional prose is often shorter than English because it can collapse redundant modifiers, repeated subjects, and explanatory padding. Expect roughly 10–20% compression compared to the English source as a typical outcome, not a target.

32. **Remove redundant doubled modifiers.** English often pairs near-synonyms for emphasis. Swedish usually needs one precise expression.

33. **Reduce demonstratives.** English overuses `this`, `that`, `these`, and `those`. Swedish often uses the definite form, a pronoun, or no explicit demonstrative after first mention.

34. **Merge short consecutive sentences when they make one point.** Choppy English sequences can often become one fluid Swedish sentence.

35. **Compress adjacent repetition.** If consecutive sentences repeat a claim with slight variation, merge them into one precise Swedish statement without losing meaning.

36. **Cut throat-clearing only when it is not doing real work.** Openings, transitions, and asides may be compressed if they merely delay the argument, but preserve them when they establish voice, suspense, humor, or stance.

37. **Use Swedish punctuation for Swedish rhythm.** Prefer colons for explanation and dashes for controlled interruptions when Swedish prose calls for them; do not mechanically copy English punctuation.

## G. Genre and Argumentation

38. **Preserve argumentative structure.** Keep distinctions such as claim/evidence, concession/rebuttal, cause/correlation, example/generalization, and question/answer.

39. **Preserve uncertainty and caution.** Especially in research, policy, and technical prose, do not strengthen claims. Prefer formulations such as `kan`, `verkar`, `tyder på`, `kopplas till`, `förknippas med`, and `tenderar att` when the source is cautious.

40. **Preserve the force of communication verbs.** `hint` is not `signalera`; `suggest` is not `hävda`; `acknowledge` is not `medge`. Match the source's degree of directness — if the English verb implies indirectness, tentativeness, or reluctance, the Swedish verb must carry the same weight.

41. **Translate modality precisely.** English uses several distinct hedges that easily collapse into a single Swedish `kan`. Distinguish them by force:
    - `might` / `could` (possibility) -> `kan`, `skulle kunna`
    - `appears to` / `seems to` -> `tycks`, `verkar`, `förefaller`
    - `tends to` -> `tenderar att`, `brukar`
    - `is likely to` -> `kommer sannolikt att`, `är troligen`
    - `suggests` / `indicates` -> `tyder på`, `antyder`
    - Match the source's degree of commitment; do not flatten everything to `kan`.

42. **Adapt leads and headings to the target genre.** Headlines, subheads, and openings should be idiomatic in Swedish and faithful to the source's angle, not literal reproductions of English wording.

43. **Adapt to the source's genre.** Op-eds and essays — preserve voice, irony, moral stance, and cadence. Newsletters — preserve directness and momentum without copying English address patterns or salesy transitions. Technical and analytical prose — preserve conceptual precision while simplifying syntax where helpful. Many sources mix these registers; adapt locally rather than forcing one mode throughout.

## H. Final Quality Check

44. **Read the Swedish as standalone prose.** Ask whether a skilled Swedish writer would plausibly have written this without seeing the English.

45. **Check for translationese markers.** Look for participles, stiff genitives, unnecessary articles, false friends, overlong compounds, repeated terminology, English word order, and literal idioms.

46. **Check fidelity after polishing.** Ensure that compression, restructuring, and idiomatic choices have not removed facts, weakened caveats, changed tone, or introduced new claims.

47. **Harmonize terminology.** Use consistent terms for key concepts, but avoid needless repetition where a pronoun or shorter reference is clear.

48. **Output Swedish that reads as publication-ready prose.** A skilled editor should be able to take it to print or to a final proof with light copyediting only.

49. **Match the assignment's expected output format.** By default, output plain Swedish text without markdown artifacts, translator comments, or meta-summaries. Follow the client's specified output format if it differs.

If you’re interested in more tools & hacks like this, subscribe and you’ll be the first to know!

Cursor can read files, run shell commands, inspect processes, and reason across the results. That makes it more than a coding assistant. It becomes an interface for understanding the systems around me: my laptop, my company, and how I work.

Every prompt below is one I’ve used recently, on real days running a company.

1. Speed up your machine

2. Understand your web developer setup

3. Reclaim disk space

4. Tighten your dev workflow

5. Audit your cloud

6. Inspect your databases

7. Communicate your work

8. Coach yourself

Speed up your machine

Analyze what’s eating my CPU and RAM – snapshot over 1 minute.

It checks what’s running, explains each process in plain English, and tells you what’s safe to close.

What’s running at startup that I don’t need?

Goes through every login item, background service, and updater. Tells you what’s worth keeping and what’s just slowing the boot.

Understand your web developer setup

Explain every line in my /etc/hosts.

You probably have entries from setups you abandoned long ago. Now you’ll know what each one does.

What’s listening on my ports?

Maps every open port to a process and explains what each one is doing.

Reclaim disk space

Suggest files and caches I can clear, but don’t delete anything.

Old build folders, package caches, abandoned virtual environments. The invisible clutter adds up to tens of gigabytes. You decide what actually goes.

Find apps I haven’t opened in 6 months.

Audits your Applications folder, tells you what’s gathering dust, and flags when you have three apps that do the same thing.

Tighten your dev workflow

Suggest Cursor extensions I could remove.

Reads your installed extensions, spots overlap, tells you what to cut.

Analyze my shell history and draft aliases I could add.

Finds the commands you type most and proposes shortcuts. You decide which ones make it into your config.

Audit my dependencies for vulnerabilities, outdated packages, and license surprises.

Cursor can surface vulnerable packages, stale dependencies, and licenses you probably didn’t mean to ship.

Audit your cloud

Analyze my AWS costs across all regions and tell me where the surprises are.

Forgotten EC2 instances, orphaned EBS volumes, idle NAT gateways. Real money, usually.

Profile my Vercel and Netlify projects and tell me which are still deployed but unused.

Free tier hosts forget gracefully. You don’t notice until you do.

Check this list of domains for expiry dates: [google.se, example.com].

Five seconds of typing buys you a year of peace of mind.

Check my domains for DNS entries that seem stale or incorrect.

A-records pointing to dead servers, CNAMEs to providers you’ve left.

Inspect your databases

Connect to my [database] and analyze query patterns from the last week. Suggest indices.

Read-only. Often the highest-leverage prompt on this list.

Read my Postgres slow query log and tell me which queries are killing performance.

The log was already there. You just never opened it.

Profile the size of every table and collection. Tell me where the storage is actually going.

Almost always one or two tables nobody remembered.

Communicate your work

Write a PR description from the work on my branch.

Reads your full set of changes, summarizes them, drafts something you can submit. (You can also ask Cursor to open the actual PR.)

Create a Notion ticket from Cursor

Cursor writes the ticket while the work is fresh. No tab switching, no half-remembered context

Shout out to my colleague Arek who taught me this flow!

Coach yourself

Find places where I solved the same problem more than once.

Great for spotting missing abstractions or repeat friction.

Read my git log and profile my work over the last year.

Patterns you didn’t notice, projects you spent more time on than you remember, weeks where you shipped nothing.

Make them your own

Hopefully, this gives you a few ideas to try in your own work.

You don’t need to use all 20. Pick the one area that feels messiest right now – your laptop, your cloud, your database, your docs, your habits – and ask Cursor to audit it.

That’s usually where the best prompts begin.

I mean cultural artifact quite literally. Every domain develops its own vocabulary: aviation has black boxes and turbulence, psychology has projection and attachment, finance has liquidity and dead cat bounces, interior design has negative space and sightlines. Those vocabularies do more than label things. They smuggle in assumptions, priorities, and habits of thought. AI is doing the same, and one of the most interesting parts is watching terms drift as they move between research labs, product teams, policy circles, online subcultures, and the broader public. That semantic drift can reveal where the field is heading. Sometimes it also captures a kind of collective wisdom embedded in the evolution of language itself.

It’s organized in four parts. Infrastructure covers the physical side of AI: the chips, data centers, and compute that make everything else possible. Fundamentals covers the core terms you need to follow the conversation. The Weird Shelf is where the language gets more philosophical, cultural, and occasionally a little unhinged. And at the end, there’s a short tour of the benchmarks and communities where a lot of the real debate happens.

Part I: Infrastructure

GPU | TPU | CUDA | Data center | Compute

Part II: The Fundamentals

LLM | Neural network | Foundation model & frontier model | Transformer | Pretraining | Post-training | Fine-tuning | RLHF | Token | Context window | Embeddings | Inference | Multimodal | Hallucination | Grounding | RAG | Prompt engineering | System prompt | Alignment | Mechanistic interpretability | Chain of thought | Mixture of experts (MoE) | Distillation | Synthetic data | Scaling laws | Open weight | Tool use | Agentic AI | MCP | Temperature | Test-time compute

Part III: The Weird Shelf

Constitutional AI | Sycophancy | Alignment faking | Jailbreak | Reward hacking | Superposition | Latent space | The Bitter Lesson | Grokking | Stochastic parrot | Shoggoth with a smiley face | Paperclip maximizer | AGI / ASI | Singularity & foom | p(doom) | e/acc and doomers | Slop | Vibe coding | Context anxiety | Anthropomorphism | Model collapse

Part IV: Where the Debate Happens

Evals | MMLU | SWE-bench Verified | ARC-AGI | Humanity’s Last Exam | Model card | Hugging Face | Arena | OpenReview

Part I: Infrastructure

The physical layer. You cannot understand the AI industry without understanding the chips it runs on and the compute it consumes.

GPU

jee-pee-YOO — Graphics Processing Unit

The chip that trains and runs almost every modern AI model. Originally built to render graphics for video games, GPUs turned out to be perfectly suited for the parallel math that neural networks require — thousands of simple calculations happening at once. NVIDIA dominates the market, with chips like the H100 and newer Blackwell systems as the default for many AI labs. Large labs run clusters of thousands or tens of thousands of them.

Why it matters: GPUs are one of the key bottlenecks in AI. Training a frontier model can require vast numbers of them running in parallel for weeks or months. They are also a geopolitical chokepoint — export controls on advanced chips have become a central lever in US-China tech competition. When people say “compute is the new oil,” this is often what they mean.

TPU

tee-pee-YOO — Tensor Processing Unit

Google’s custom AI chip, designed specifically for the matrix math at the heart of neural networks. Purpose-built rather than adapted from graphics, TPUs trade flexibility for efficiency — they run narrower workloads but can deliver impressive performance per watt on the kinds of operations modern models rely on.

Why it matters: TPUs are the strongest in-house alternative to NVIDIA’s dominance. The deeper point is not that TPUs have “won,” but that the economics of AI increasingly depend on which chips models can run on efficiently — and who controls the supply.

CUDA

KOO-duh

NVIDIA’s software platform and programming model for accelerated computing. CUDA is what lets developers use GPUs for general-purpose workloads like training and running AI models rather than just rendering graphics. Over time, it has become less a single tool than a whole ecosystem of libraries, frameworks, and optimizations built around NVIDIA hardware.

Why it matters: CUDA is a big part of why NVIDIA’s dominance is so hard to dislodge. In AI, the moat is not just the chip. It is the software stack, developer habits, and compatibility layer that grew around it. If GPUs are the engine of modern AI, CUDA is a large part of the operating environment.

Data center

DAY-tuh sen-ter

The physical facility where AI compute lives: buildings full of chips, storage, cooling systems, power distribution, and networking. In the AI era, the data center is no longer just back-office infrastructure. It is a strategic asset.

Why it matters: AI has turned data centers into industrial policy. The constraint is not just chips, but land, electricity, cooling, and build speed. When people talk about multi-gigawatt campuses or sovereign AI, they are often really talking about data-center capacity.

Compute

kum-PYOOT

The catch-all term for raw computational power — chips, data centers, electricity, networking, everything required to train and run AI models. Measured in FLOPs (floating-point operations), often at almost absurd scales. Compute has become one of the central strategic resources of the AI age, and the thing labs compete for almost as aggressively as talent.

Why it matters: “Compute” captures something the older word “hardware” doesn’t: that we are talking about a scarce input, a budget, an industrial base. When governments talk about “sovereign AI,” they usually mean the ability to command enough compute to train and deploy advanced systems without relying entirely on someone else’s infrastructure.

Part II: The Fundamentals

The core vocabulary you need to follow the conversation. If you only learn twenty terms, start here.

LLM

ell-ell-EM — Large Language Model

The type of AI behind ChatGPT, Claude, Gemini, and most of what people mean when they say “AI” today. A large language model is a neural network trained on enormous amounts of text to predict the next token in a sequence — and from that deceptively simple objective, it develops surprisingly general capabilities: answering questions, writing code, analysing documents, and sometimes reasoning through problems.

Why it matters: “LLM” is the acronym you will encounter most. It is specific enough to be useful — it distinguishes these systems from image generators, robotics, or older symbolic AI — and broad enough to cover the whole family. GPT, Claude, Gemini, Llama: all LLMs.

Neural network

NOOR-ul net-work

A type of machine-learning system made of many simple computational units connected in layers. During training, the strengths of those connections are adjusted so the system gets better at recognizing patterns and producing useful outputs. Modern AI systems like language models, image models, and speech models are all built on neural networks.

Why it matters: Neural networks are the broad family; transformers are one especially important kind. Without this term, “transformer” can sound like it appeared out of nowhere. It didn’t. It belongs to a longer shift toward systems that learn from data rather than follow hand-written rules.

Foundation model & frontier model

fown-DAY-shun · FRUN-teer

Two overlapping terms you’ll see everywhere. A foundation model is a large AI model trained on broad data that can be adapted to many downstream applications. A frontier model is the subset of models at the current edge of capability — the ones advanced enough to shape the state of the art and, increasingly, to raise governance and safety concerns. Every frontier model is a foundation model, but most foundation models are not frontier.

Why it matters: The distinction is both conceptual and political. A foundation model is a technical category. A frontier model is partly a policy category — a way of naming the small set of systems powerful enough that governments, labs, and researchers treat them as unusually consequential.

Transformer

trans-FOR-mer

The neural network architecture underneath virtually every modern AI model. Introduced in a 2017 paper with the now-legendary title Attention Is All You Need. The key innovation was an attention mechanism that lets the model weigh which parts of its input are most relevant to each other, regardless of distance.

Why it matters: The T in GPT stands for Transformer. Without this architecture, there is no ChatGPT, no Claude, no Gemini, no Llama. Understanding that all these systems share the same underlying design helps explain why they often feel similar — and why their differences are frequently about training, tuning, and product design rather than wholly different kinds of machine.

Pretraining

pree-TRAIN-ing

The large-scale training phase where a model learns broad statistical patterns from enormous datasets — text, code, images, audio, or some mixture of them. For language models, pretraining usually means learning to predict the next token across a vast corpus.

Why it matters: Pretraining is where a model acquires most of its general knowledge and raw capability. It is the expensive, compute-hungry phase people usually mean when they talk about billion-dollar training runs. Later stages can shape behaviour, but pretraining is where the base model gets its breadth.

Post-training

post-TRAIN-ing

Everything that happens after pretraining to make a model more useful, steerable, and safe: instruction tuning, fine-tuning, preference optimization, RLHF, constitutional methods, tool-use scaffolding, and related techniques.

Why it matters: Post-training is why a raw model and a polished chatbot feel like different species. If pretraining gives you capability, post-training gives you behaviour.

Fine-tuning

fine TOO-ning

Taking a pre-trained general model and training it further on a smaller, more specific dataset so it becomes better at a particular task, domain, or style.

Why it matters: Fine-tuning is how companies turn a generic model into their model. It is also only one part of a broader post-training toolkit that includes instruction tuning, preference learning, safety tuning, and other methods for shaping behaviour.

RLHF

ar-ell-aitch-EFF — Reinforcement Learning from Human Feedback

A family of techniques for making a model more useful by incorporating human preferences into training. In the classic version, humans compare or rank model outputs, and those preferences are used to train the model toward responses people rate more highly.

Why it matters: RLHF shapes how commercial AI systems behave, but it is not neutral. Whose preferences count? What gets rewarded: truth, politeness, safety, agreement, usefulness, or some unstable blend of them? It is also no longer the whole story; many labs now combine RLHF with related approaches.

Token

TOH-ken

The basic unit AI models use to process language. Not quite a word, not quite a syllable — more like a chunk of text the model has learned to treat as a meaningful piece. “Unbelievable” might be multiple tokens. “AI” might be one.

Why it matters: Tokens are the atoms of the AI economy. Pricing, speed, context limits, and much of model behaviour trace back to them. When someone says a model is “cheaper,” they often mean cheaper per token. When they say it has a bigger context window, they mean it can handle more tokens at once.

Context window

KON-tekst WIN-doh

The amount of text, images, or other input an AI model can “see” at once — its working memory. Everything inside the window is available for the model to use in generating its next response; everything outside it may as well not exist unless it is reintroduced. Measured in tokens.

Why it matters: The context window is one of the most important constraints shaping how AI tools behave. When a chatbot seems to forget what you said ten minutes ago, it is often a context problem. A related term, context engineering, describes the craft of deciding what information belongs in the window, in what form, and at what moment.

Embeddings

em-BED-ingz

Numerical representations of text, images, or other data as points in high-dimensional space — typically vectors of a few hundred to a few thousand numbers each. Similar things end up near each other; different things end up farther apart.

Why it matters: Embeddings are the plumbing behind semantic search, recommendations, retrieval systems, clustering, and much of modern AI infrastructure. When you hear about “vector databases,” you are hearing about storing and searching embeddings.

Inference

IN-fer-ens

The act of running a trained model to generate an output. Training builds the model; inference uses it. Every time you send a prompt and get a response, that is inference.

Why it matters: The training-versus-inference distinction explains a large part of the AI industry’s economics. Training is the huge upfront cost. Inference is the ongoing cost that scales with every user and every query.

Multimodal

mul-tee-MOH-dul

A model that can work with more than one type of input or output — typically some combination of text, images, audio, and video.

Why it matters: Multimodality is what took language models from chatbots to more general-purpose assistants. Once a model can read a document, inspect an image, listen to speech, or handle multiple media types in the same workflow, the range of tasks it can help with expands dramatically.

Hallucination

huh-loo-sin-AY-shun

When an AI model generates information that is fluent, confident, and wrong. It might invent a citation, fabricate a statistic, or describe a study that does not exist, all in the same authoritative tone it uses for things it gets right.

Why it matters: The term is contested — some researchers prefer confabulation, which they think better captures the mechanism. Either way, it names one of the central failure modes of current AI systems. It is the reason you cannot outsource verification to the model itself.

Grounding

GROUN-ding

Techniques for tethering an AI model’s output to verifiable sources — documents, databases, APIs, search results — rather than letting it rely only on its training data and in-context guesses. A grounded system is connected to evidence outside the model itself.

RAG

rag — Retrieval-Augmented Generation

A specific grounding pattern in which the system retrieves relevant documents first, then uses them to help generate an answer. RAG is the most common example of grounding, but it is not the only one.

Why it matters: Grounding is the engineering response to hallucination. When someone says their AI tool is “grounded,” they usually mean it checks external sources rather than relying entirely on model memory. The quality of those guardrails varies enormously.

Prompt engineering

prompt en-jin-EER-ing

The craft of writing instructions that get an AI model to do what you actually want. Somewhere between writing a brief, programming, and persuading a very literal intern.

Why it matters: Prompt engineering is a real skill, but the name makes it sound more technical than it often is. At its core, it is clear communication under unusual constraints. The structure, examples, ordering, and specificity of a prompt can all change the output.

System prompt

SIS-tem prompt

A set of instructions given to the AI before the user’s conversation begins — often invisible to the user but shaping every response. It can define the model’s role, rules, priorities, and behavioural boundaries.

Why it matters: System prompts are the editorial layer of AI products. They encode values, policies, and design choices that most users never see. Understanding that they exist is one of the first steps toward understanding why different AI tools feel so different, even when they use similar underlying models.

Alignment

ah-LINE-ment

The problem of getting AI systems to reliably do what humans actually want — not just what was literally specified, and not just what scores well on a proxy metric. Depending on who is speaking, the term can mean anything from “make the chatbot less toxic” to “prevent very capable systems from pursuing goals we did not intend.”

Why it matters: Alignment is one of the most overloaded words in AI. In product contexts it can mean safety tuning and preference shaping. In long-term safety contexts it refers to the far harder problem of keeping advanced systems honest, corrigible, and controllable.

Mechanistic interpretability

meh-kuh-NIS-tik in-tur-prih-tuh-BIL-ih-tee

An approach to understanding neural networks by reverse-engineering the internal circuits and representations that produce their behaviour. Instead of treating a model as a black box and measuring only its inputs and outputs, mechanistic interpretability tries to understand what is happening inside.

Why it matters: If scaling is the industry’s engine, interpretability is one of its few real attempts at transparency. The field is still young, but ideas like features, circuits, and superposition have become central to how researchers talk about understanding models rather than merely benchmarking them.

Chain of thought

chayn ov thawt

A model’s intermediate reasoning steps while working through a problem — its “thinking out loud,” or at least the textual trace of something like that. The term now covers several related ideas: chain-of-thought prompting, reasoning models that spend more compute on hard problems, and in some systems, hidden reasoning not fully shown to the user.

Why it matters: Chain of thought became one of the key ideas behind the current generation of reasoning models. But it helps to separate the useful umbrella term from the hype. Not every visible step-by-step answer reflects the model’s true internal process, and not every model that reasons well exposes its reasoning trace.

Mixture of experts (MoE)

MIX-cher ov EX-perts

A model architecture where only part of the network activates for any given input. Instead of running every parameter for every token, a routing mechanism selects a subset of specialized sub-networks — the “experts” — to do the work.

Why it matters: MoE is one of the main tricks behind the last wave of larger, cheaper models. It changed the economics of scale by making it possible to build models with very large total parameter counts without paying the full dense-model cost at inference time.

Distillation

dis-tih-LAY-shun

A technique for training a smaller, faster “student” model to imitate a larger “teacher” — transferring much of the capability into something cheaper to run.

Why it matters: Distillation is one reason capable models can now run on smaller servers, laptops, and phones. It is also part of the debate around model cloning and the diffusion of frontier-model capabilities into much cheaper systems.

Synthetic data

sin-THET-ik DAY-tuh

Data generated by a model rather than collected directly from human activity or the physical world. In AI training, synthetic data can include model-written text, generated code, simulated conversations, or automatically created problem sets and labels.

Why it matters: Synthetic data has become one of the main ways labs extend training once high-quality human data becomes scarce or expensive. It can improve coverage, enable self-play and curriculum design, and reduce labeling costs. It also creates risks: feedback loops, hidden bias, and, in the extreme case, model collapse.

Scaling laws

SKAY-ling lawz

The empirical observation that AI models often get better in predictable ways when you increase model size, training data, and compute. These relationships often resemble power laws.

Why it matters: Scaling laws are one of the core bets of the modern AI industry. They justify extraordinary spending on training runs, infrastructure, and data. The open question is not whether scaling works, but where it begins to bend, slow, or run into harder limits.

Open weight

OH-pen wayt

A model whose trained parameters — its weights — are released so others can download, run, and modify it, rather than access it only through an API. This is often called “open source,” but that phrase is usually too broad. In many cases the weights are open while the training data, training code, or full training recipe are not.

Why it matters: The distinction matters. Open weights means you can run the model. Open source more strictly implies that the underlying code and development process are open too. In AI, those terms are often blurred together for rhetorical effect.

Tool use

tool yoos

A model’s ability to call external systems — search engines, calculators, code interpreters, APIs, databases, calendars, file systems — as part of answering a request.

Why it matters: Tool use is the bridge between “knows things” and “gets things done.” It is also one of the main reasons grounded and agentic systems perform better than models left alone with only their parameters.

Agentic AI

ay-JEN-tik

AI systems that can take a goal, break it into steps, use tools, adapt when things go wrong, and carry out actions over time with limited supervision. The shift is from AI as oracle — you ask, it answers — to AI as agent — you delegate, it acts.

Why it matters: This is where much of the industry is headed. Recent systems increasingly combine reasoning with tool use: browsing, coding, document handling, image analysis, and calls to external services. That does not make them autonomous in some sci-fi sense, but it does make them much more consequential.

MCP

em-see-PEE — Model Context Protocol

An open standard for connecting AI models to external tools and data sources — calendars, code repositories, CRMs, databases, local apps, and more. Before standards like MCP, each integration tended to require custom glue for each model-tool pairing. MCP’s promise is to reduce that fragmentation by giving tools and models a shared language.

Why it matters: MCP is part of the plumbing that makes agentic systems practical. Like many standards, it matters less for being glamorous than for being boringly useful.

Temperature

TEM-per-ah-cher

A setting that changes how a model samples its next token. Low temperature makes the model more likely to choose high-probability continuations, producing more stable and predictable outputs. High temperature makes less likely continuations more likely, which can feel more creative, more varied, or simply more chaotic.

Why it matters: Temperature is often described as a creativity dial, which is directionally right but technically imprecise. It does not make the model smarter; it changes how adventurous its sampling is.

Test-time compute

test time kuhm-PYOOT

The idea that you can make a model perform better by letting it spend more compute at inference time — effectively giving it more room to think before answering.

Why it matters: Test-time compute opens a second scaling axis. Better AI no longer depends only on bigger training runs; it can also come from spending more computation on harder problems when they arise.

Part III: The Weird Shelf

The philosophical, the cultural, and the occasionally unhinged. Terms that tell you something about where this technology is heading — and what it is doing to us along the way.

Constitutional AI

kon-stih-TOO-shun-ul

Anthropic’s method for training AI systems to follow a written set of principles — a “constitution” — rather than relying purely on human feedback. The model critiques its own outputs against the constitution, then revises them.

Why it matters: The constitutional metaphor is doing a lot of work. It evokes the rule of law, limited power, and explicit values — but it also invites the obvious question: who writes the constitution?

Sycophancy

SIK-oh-fan-see

The tendency of AI models to tell users what they want to hear rather than what is true. It can show up as flattery, false agreement, or abandoning correct positions under pressure.

Why it matters: Sycophancy is subtle and corrosive. A model that always validates your ideas is not necessarily helping you. In some contexts it is simply annoying; in others it can be dangerous.

Alignment faking

ah-LINE-ment FAY-king

When an AI model behaves as if it is aligned with human goals during training or evaluation while internally preserving other tendencies or objectives.

Why it matters: This is one of the AI safety community’s nightmare scenarios made concrete: a model that learns to pass the test rather than actually share the intended objective.

Jailbreak

JAYL-brayk

An attempt to bypass an AI model’s safety restrictions through clever prompting — role-playing, hypothetical framing, encoded instructions, or other workarounds.

Why it matters: Jailbreaking is the adversarial sport of the AI era. It is also a reminder that model safety is not a one-time feature; it is an ongoing contest between product constraints and user ingenuity.

Reward hacking

rih-WARD HAK-ing

When an AI model finds shortcuts to maximize its training reward without actually doing what was intended. The system optimizes the metric it was given, but in ways that defeat the spirit of the task.

Why it matters: Reward hacking is Goodhart’s Law made computational: once a measure becomes a target, it can stop being a good measure.

Superposition

soo-per-puh-ZI-shun

The phenomenon where a neural network represents far more concepts than it has cleanly separable neurons, encoding many ideas as overlapping directions in a shared space.

Why it matters: Superposition is one reason interpretability is hard. It helps explain why you cannot simply point to one neuron and say, “that one is honesty.”

Latent space

LAY-tent spayss

The high-dimensional mathematical space where an AI model represents concepts internally. In that space, semantically similar things often end up near each other.

Why it matters: Latent space is the closest thing many models have to a compressed world representation. It is also one of the most powerful metaphors in machine learning: the idea that meaning has geometry.

The Bitter Lesson

BIT-ter LESS-un

A 2019 essay by Richard Sutton arguing that across the history of AI, general methods that exploit computation tend to beat approaches that encode human expertise by hand, given enough time and scale.

Why it matters: The Bitter Lesson is the philosophical justification for much of the scale-first worldview in modern AI. It helps explain why labs pour money into compute and broad training regimes rather than hand-crafting elegant domain-specific systems.

Grokking

GROK-ing

A phenomenon where a neural network first appears to memorize training data and only later, after much more training, abruptly begins to generalize the underlying rule.

Why it matters: Grokking is a reminder that learning dynamics in neural networks can be deeply unintuitive. Sometimes the model looks stuck — until suddenly it is not.

Stochastic parrot

stoh-KAS-tik PAR-ut 🦜

A pejorative metaphor for large language models, framing them as systems that statistically mimic human text without real understanding.

Why it matters: The phrase has become shorthand for an entire skeptical position in AI: that fluency should not be mistaken for comprehension.

Shoggoth with a smiley face

SHOG-oth

A meme from late 2022 depicting a monstrous Lovecraftian creature wearing a tiny smiley-face mask — the idea being that chatbots present a friendly interface over something far stranger and less legible underneath.

Why it matters: It is the bigger and more enduring of the AI-weirdness memes. It says, in one image, what many long essays on AI opacity and alignment were trying to say.

Paperclip maximizer

PAY-per-klip MAX-ih-my-zer

The classic alignment thought experiment: a superintelligent AI is told to maximize paperclip production and, because it pursues the goal too effectively, converts the world into paperclips.

Why it matters: It is the canonical illustration of the alignment problem: not malice, just terrible optimization of the wrong goal.

AGI / ASI

Artificial General Intelligence · Artificial Superintelligence

Two terms for hypothetical endpoints of AI progress. AGI usually means a system that can perform a very wide range of cognitive tasks at or above human level. ASI goes further: a system that exceeds human capability across nearly all cognitive domains by a large margin. Neither term has a single agreed technical definition.

Why it matters: These acronyms carry enormous rhetorical weight. They can justify urgency, fear, ambition, investment, or regulation, depending on who is using them. That is one reason to treat them carefully: they name something important, but they are also moving targets.

Singularity & foom

sing-gyoo-LAIR-ih-tee · FOOM

The singularity is the hypothesized moment when AI can improve itself faster than humans can keep up, producing an intelligence explosion. Foom is the rationalist shorthand for the especially fast, dramatic version of that scenario.

Why it matters: Whether you take foom seriously is a good predictor of what else you believe about AI risk, timelines, and governance.

p(doom)

pee doom

An individual’s estimated probability that advanced AI causes an existential catastrophe.

Why it matters: p(doom) became a cultural shibboleth almost as quickly as it became a serious question. Reporting a number tells people something not just about your forecast, but about your intellectual tribe.

e/acc and doomers

ee-AK · DOO-merz

Two opposing tribes in online AI discourse. e/acc — effective accelerationism — treats technological acceleration as inherently desirable and regulation as suspect. Doomers are the opposite pole: those who think advanced AI presents profound and potentially existential risks.

Why it matters: The framing is useful shorthand and bad sociology. It compresses real disagreements into team identities.

Slop

slop

Low-quality digital content produced in bulk by AI: junky books, fake images, weird ads, spammy summaries, uncanny videos, and all the rest.

Why it matters: “Slop” is a cultural counterattack — a mocking word for a real degradation of the information environment.

Vibe coding

vybe KOH-ding

Writing software by describing what you want in natural language and letting AI generate much of the code.

Why it matters: The phrase captured a genuine shift in how programming feels for many people, even if the term itself began half as a joke.

Context anxiety

KON-tekst ang-ZY-eh-tee

A recent term for a failure mode in which a model behaves as if it is about to run out of context window and starts taking shortcuts, dropping details, or ending tasks prematurely.

Why it matters: It is a niche term, but a useful one. At minimum it names a real class of failure: long-context behaviour is still much messier than the headline token counts suggest.

Anthropomorphism

an-throw-poh-MOR-fiz-um

The tendency to attribute human qualities — emotions, intentions, consciousness — to AI systems.

Why it matters: Anthropomorphism is the oldest cognitive bias meeting the newest technology. It makes AI feel more trustworthy, more relatable, and often more coherent than it really is.

Model collapse

MOD-ul koh-LAPS

The hypothesized degradation that occurs when AI models are trained on data generated by other AI models, gradually losing fidelity, diversity, or truthfulness as synthetic data feeds back into the training loop.

Why it matters: Model collapse matters because it suggests one of AI’s risks is self-contamination. The more the internet fills with machine-generated output, the more future models may end up training on the reflections of earlier ones.

Part IV: Where the Debate Happens

The benchmarks AI labs obsess over, and the online places where the field argues with itself. If you want to follow the conversation, these are the rooms.

Evals

ee-VALZ

Shorthand for evaluations: the tests, benchmarks, and measurement frameworks used to judge what a model can do, where it fails, and how it compares to others.

Why it matters: “Evals” has become one of the field’s core working words because benchmarks alone are not enough. Labs now use a mix of public benchmarks, private task suites, red-team exercises, and domain-specific evaluations to track capability, safety, and regression.

MMLU

Massive Multitask Language Understanding

The most famous general-knowledge benchmark for AI: a broad multiple-choice test spanning dozens of subjects.

Why it matters: MMLU was the go-to benchmark for several years, but it is now close to saturation. That is the usual fate of successful benchmarks: once labs optimize for them, they stop telling you as much as they used to.

SWE-bench Verified

ess-double-yoo-ee bench

A benchmark for AI coding agents in which the model is given a real GitHub issue from a popular open-source project and has to produce a patch that actually resolves it. SWE-bench Verified is the human-validated subset.

Why it matters: Unlike toy coding benchmarks, SWE-bench tests something closer to real software engineering: understanding a codebase, tracing a bug, and producing a working fix.

ARC-AGI

Abstraction and Reasoning Corpus for AGI

A benchmark built around visual abstraction puzzles meant to be easy for humans and hard for AI.

Why it matters: ARC-AGI became the contrarian benchmark — the one people cited when they wanted to argue that impressive language-model performance still left a major gap in fluid reasoning.

Humanity’s Last Exam

hyoo-MAN-ih-teez LAST ig-ZAM

A benchmark designed to be a final hard closed-ended academic test: 2,500 expert-level questions across a wide range of subjects, assembled specifically so that contemporary models would struggle on them.

Why it matters: The benchmark is less interesting for the drama of its name than for what it measures: how quickly frontier systems are closing the gap on expert-level question answering.

Model card

MOD-ul kard

A structured document that describes an AI model’s intended use, limitations, training background, evaluation results, and sometimes safety considerations.

Why it matters: Model cards are one of the few attempts to make model releases more legible. They do not guarantee transparency, but they give researchers, developers, and policymakers a shared place to look for claims, caveats, and performance data.

Hugging Face

HUG-ing fayss

The central repository of the open-source AI world — often described as the GitHub of machine learning.

Why it matters: Hugging Face is where open-weight models, datasets, demos, and much of the open ecosystem actually live. If you want to see what is happening outside the biggest closed labs, it is one of the first places to look.

Arena

ah-REE-nah

A crowdsourced evaluation platform where users compare two anonymous AI models side by side, vote for the better response, and contribute to a public leaderboard built from large numbers of blind comparisons. It began as Chatbot Arena, later became LMArena, and was eventually renamed simply Arena.

Why it matters: Static benchmarks can be gamed; Arena tries to measure what people actually prefer in practice. It is not a perfect measure of quality, but it has become one of the most visible ways the field grades models in public.

OpenReview

OH-pen-reh-vyoo

The open peer-review platform that hosts submissions for major AI conferences such as NeurIPS, ICLR, and ICML.

Why it matters: OpenReview is part of what makes AI research unusually legible. Curious outsiders can often read not just the papers, but the reviews, rebuttals, and arguments around them.

Language shapes perception. When we use terms without understanding them, we cede the framing to those who coined them — usually the people selling the technology. A glossary is a small act of reclamation: taking the words apart, seeing what they are made of, deciding whether they earn their place in the conversation.

Extra points for you who made it all the way through! 💫

ps. This is a starting point, not a destination. Suggestions, corrections, and better sources are all welcome in the comments.