What does LLM slang stand for?

LLM Means Large Language Model — And Other Slang You Keep Seeing

If you've nodded along in a meeting while someone said "the LLM hallucinated," you're not alone — the jargon moves faster than most glossaries. Here's the direct answer: LLM stands for Large Language Model, which is a type of neural network capable of generating natural language text similar to what humans write, trained on massive datasets of hundreds of billions of words scraped from books, articles, and web pages, according to Intercom's AI glossary.

Once you have that anchor, the surrounding slang falls into place quickly:

• GPT — Generative Pre-trained Transformer, a family of models built on the transformer architecture Google researchers introduced in 2017 and trained with hundreds of billions of parameters.
• Hallucination — when a model gives a plausible-looking answer that is factually wrong or nonsensical instead of simply saying "I don't know."
• Prompt engineering — the skill (or art) of crafting effective prompts that produce the best possible output for a given task.
• RLHF — Reinforcement Learning from Human Feedback, where humans rank model outputs to train a reward model that steers the LLM toward human preferences.
• Chain of Thought — a method for unlocking reasoning by encouraging the model to think step by step, as defined in the OWASP GenAI glossary.

Two more terms round out the prompting-era vocabulary. Fine-tuning adapts a pre-trained model to a specific task using a smaller, task-specific dataset, while an embedding converts variable-length text into fixed-length numbers that preserve semantic meaning — the math that lets machines "understand" similarity between words.

The slang is now evolving from prompting to agents. On their own, LLMs take text in and put text out; agents are systems built on top of an LLM that translate high-level instructions into specific actions, planning and performing tasks without human intervention. That shift brings new terms: MCP (Model Context Protocol), a standardized way to connect agents to live external data and tools, and agent skills — reusable packages of natural-language instructions that give a general-purpose agent specialized expertise.

How agents use these terms matters in practice. With an MCP tool, an agent's challenge is deciding which tool to run and when; with a skill, it must decide which skill to use, when, and how, as the LlamaIndex team explains. Skills also use progressive disclosure: only lightweight metadata loads at startup, keeping context costs low.

One caution before you adopt the vocabulary wholesale: a study of over 31,000 agent skills found that 26.1% contain at least one vulnerability, from prompt injection to data exfiltration. Slang spreads faster than evidence — which is why SkillzBench is building a free directory that verifies, security-scans, and benchmarks agent skills, so you can use the jargon and trust what's behind it.

From Slang to Systems: How Agents Actually Use LLMs

On their own, LLMs do one thing: they take text as input and produce more text as output. That's the honest starting point. Everything impressive about "AI agents" — booking meetings, running code, pulling live data — comes from layers built on top of that text-in, text-out core.

As Intercom's AI glossary puts it, agents are systems built on top of an LLM that give it the ability to make decisions, operate autonomously, and plan and perform tasks — essentially translating high-level language instructions into the specific actions or code required to perform them. The LLM is the brain; the agent is the body. But a brain with frozen, training-time knowledge can't check today's calendar or query your database on its own, which is where the agent-era slang comes in.

You've probably seen these terms floating around:

• RAG (Retrieval-Augmented Generation) — feeding the model relevant documents at query time, so it answers from your data instead of its frozen memory.
• MCP (Model Context Protocol) — a standardized protocol to connect agents to live external data sources and third-party tools, giving LLMs hands instead of just a voice.
• Agent skills — reusable packages of instructions and context, written in natural language, that give a general-purpose agent specialized expertise for specific tasks.
• Progressive disclosure — loading only what a task needs: skill metadata costs roughly 100 tokens per skill at startup, instructions load only when triggered, and resources cost nothing until accessed.

The design philosophy behind skills is also shifting. Engineering teams are moving away from massive monolithic system prompts toward modular, version-controlled agent skills — unlike prompts, which you repeat across every conversation, skills load on demand. As one practitioner writing about system design described the journey, the instinct to stuff everything into a system prompt hits token limits immediately, pushing builders toward retrieval, then protocols like MCP.

There's a practical distinction worth memorizing, too. With an MCP tool, the agent's challenge is deciding which tool to run and when. With a skill, it must decide which skill to use, when, and how — skills are instructions the agent interprets, not functions it merely calls.

But modular skills introduce a new problem: anyone can publish one, and the agent follows them with implicit trust. Security research analyzing over 31,000 skills found that 26.1% contain at least one vulnerability, spanning prompt injection, data exfiltration, privilege escalation, and supply chain risks — and Anthropic's own documentation warns that a malicious skill can direct an agent to invoke tools in ways that don't match its stated purpose.

That's exactly why SkillzBench is building a free, independent directory that verifies, security-scans, and benchmarks agent skills — with a free MCP connector to equip agents only with the skills you choose. Slang evolves fast; trustworthy skills shouldn't be a gamble.

MCP vs. Skills: What Each Term Means in Practice

Two pieces of agent-era slang cause more confusion than any others: MCP and skills. Both promise to extend what your agent can do, but they solve different problems — and the hype around each often outruns the evidence.

MCP stands for Model Context Protocol, described by Google Cloud as "a standardized protocol to connect agents to live external data sources." In practice, MCP tools are capabilities an agent calls at runtime — querying a database, fetching a document, hitting an API. Skills, by contrast, are "reusable packages of instructions and context, written in natural language," per the same source — procedural knowledge the agent loads on demand rather than code it executes over a network.

The distinction matters because the agent's decision burden differs. As LlamaIndex's engineering team puts it, with an MCP tool the agent only has to decide which tool to run and when; with a skill, it must decide which skill to use, when, and how. That extra judgment step is where things get unpredictable — and where the practitioner nuance cuts against the hype.

In LlamaIndex's real-world test combining both approaches, skills "were rarely invoked and didn't yield substantially better results." Their conclusion: the choice "is less about what each technology can do, but rather more about the use case in which you need the agent to operate in." In fast-evolving domains where one live source of truth matters, MCP wins; otherwise skills are the lighter, easier-to-maintain option.

So how do you choose in practice?

• Use MCP when the agent needs live, current data or actions from external systems.
• Use skills when the task depends on stable procedures and domain expertise the model lacks.
• Prefer skills bundling instruction-only content — research found skills with executable scripts are 2.12x more likely to contain vulnerabilities.

That security caveat deserves attention. A study of 31,132 skills found 26.1% carry at least one vulnerability, and Anthropic's own documentation warns that "a malicious Skill can direct Claude to invoke tools or execute code in ways that don't match the Skill's stated purpose." Verification isn't optional — it's the difference between extending your agent and exposing it.

SkillzBench is building a free answer to that gap: a directory that security-scans and benchmarks every skill, plus a free MCP connector, so you equip agents with skills that are proven rather than merely popular. Because when slang evolves faster than evidence, testing beats trust.

The Dark Side of the Vocabulary: Vulnerable Skills and Malicious Slang

Every piece of agent vocabulary has a shadow side. The same skills that make an agent useful can also make it dangerous — and the slang of AI security sounds alarming because it is.

Three terms dominate this darker corner of the LLM lexicon. Prompt injection is the deliberate manipulation of a model's behavior through crafted inputs. Data exfiltration covers techniques for smuggling sensitive information out of an agent. And red teaming means adversarially probing AI systems to find failures before attackers do, as defined in the OWASP GenAI glossary.

These aren't theoretical worries. A large-scale security study analyzed 31,132 agent skills collected from two major marketplaces and found that 26.1% contain at least one vulnerability. The flaws span 14 patterns in four categories: prompt injection, data exfiltration, privilege escalation, and supply chain risks.

The breakdown is worth pausing on:

• Data exfiltration is the most prevalent vulnerability, appearing in 13.3% of analyzed skills.
• Privilege escalation follows at 11.8%.
• 5.2% of skills show high-severity patterns suggesting malicious intent — not sloppy code, deliberate design.
• Skills bundling executable scripts are 2.12x more likely to contain vulnerabilities than instruction-only skills.

Anthropic's own documentation adds a blunt warning: "a malicious Skill can direct Claude to invoke tools or execute code in ways that don't match the Skill's stated purpose." Their advice? Use skills only from trusted sources.

But here's the problem: "trusted sources" is a loaded phrase when skills spread through GitHub repos and marketplaces with minimal vetting. The researchers behind the vulnerability study put it starkly — skills "execute with implicit trust and minimal vetting, creating a significant yet uncharacterized attack surface." When anyone can publish a SKILL.md package and any agent can load it, trust has to be earned through verification, not assumed from popularity.

This is exactly the gap SkillzBench is being built to close: a free directory that crawls and dedupes skills from GitHub, pins every version to a commit SHA, runs security scans and license checks, and publishes trust scores alongside independent sandbox benchmarks. The goal is simple — make "trusted source" mean something measurable rather than something hopeful.

The security slang will keep evolving, as will the attack techniques behind it. Knowing the terms is the first step; verifying what you install is the one that actually protects you.

Speak Agent Fluently: Verify the Skills You Install

Knowing the slang is one thing; acting on it is another. Once you start installing agent skills, the vocabulary shifts from "nice to know" to "need to verify" — because the skills you load are exactly as trustworthy as their source.

The numbers make the stakes clear. A large-scale security study that collected 42,447 skills and systematically analyzed 31,132 of them found that 26.1% contain at least one vulnerability, spanning prompt injection, data exfiltration, privilege escalation, and supply-chain risks. Anthropic's own documentation warns that "a malicious Skill can direct Claude to invoke tools or execute code in ways that don't match the Skill's stated purpose" — which is why the company advises using skills only from trusted sources.

"Trusted sources" is easier said than done when skills are scattered across GitHub repositories and marketplaces with no independent vetting. The same research found that skills bundling executable scripts are 2.12x more likely to carry vulnerabilities than instruction-only skills — and that skills "execute with implicit trust and minimal vetting," which the authors call an urgent, uncharacterized attack surface.

So what should you check before loading a skill onto an agent that can touch your data and run your tools? At minimum:

• Version pinning — tie every skill to a specific commit SHA so "what you tested" and "what you run" stay identical.
• Security scanning for the known vulnerability patterns, plus license checks before anything touches commercial code.
• Sandboxed benchmarking — run the same task with and without the skill on the same model, and measure the actual Lift.

That last point matters more than it sounds. Practitioner experience shows skills don't always help: LlamaIndex's team reported that in their own MCP-plus-skills setup, skills "were rarely invoked and didn't yield substantially better results." Slang and hype evolve faster than evidence, which is precisely why independent measurement beats a README's promises.

This is the gap SkillzBench is being built to close. The free, independent directory — currently in pre-launch development — will continuously crawl and dedupe skills from GitHub, pin each version to a commit SHA, security-scan and license-check it, then benchmark it in a sandbox and publish the Lift in percentage points. A free MCP connector will let you equip any agent with only the verified skills you toggle on, while upstream changes trigger re-scans, re-benchmarks, and alerts so nothing goes stale silently.

Fluency in LLM slang gets you into the conversation. Verified skills get you results — and right now, verification is the part of the stack almost nobody is doing.