LLM (Large Language Model)
The actual AI bit — the engine that generates text, answers questions, and follows instructions. Examples you've probably heard of: ChatGPT, Claude, Gemini, GitHub Copilot. They all run on LLMs underneath.
Analogy: Think of an LLM as an extremely well-read assistant who has read most of the public internet. They can write, summarise, explain, brainstorm — but on their own, they can't do anything in your world. They just talk.
OpenCode
An app that uses an LLM to actually do things — read your files, edit documents, run commands, talk to other tools, publish web pages. It's not just chat: it's chat plus the ability to take action.
Similar tools you might have heard of: Cursor, Claude Code, GitHub Copilot Chat, Windsurf. They all do roughly the same thing — give an LLM hands.
Analogy: If the LLM is the brain, OpenCode is the hands. The brain knows things; the hands get things done in the real world.
Agentic / Agent
An AI that can take a series of actions on its own to complete a task, instead of just answering one question and stopping. It plans, does, checks the result, and adjusts — without you having to spell every step out.
If you ask OpenCode "publish a page summarising this Confluence doc", it will read the doc, draft the page, save the file, push it to GitHub, and confirm when it's live. That whole sequence is agentic behaviour.
Context
Everything OpenCode "knows" during a single session — your prompts, the files you've shared, what's been said so far in the conversation, and any standing instructions it's read.
Analogy: Context is the working memory of one conversation. When you start a new session, that memory resets — which is why putting the right files and standing instructions in the right place matters so much.
Prompt
Anything you type into OpenCode. Your message. Your question. Your instruction. That's a prompt.
The quality of your prompts has a huge effect on the quality of what you get back — but you don't need to learn fancy "prompt engineering" tricks. Clear, specific, and complete usually does the job.
Skill
A reusable instruction set. A recipe for OpenCode to follow whenever you invoke it — so you don't have to re-explain how you want something done every time.
Example: a "weekly status update" Skill that knows your format, who the audience is, and what to include. You write it once, then every week you just say "use the status update skill" and it follows the recipe. See Using Skills.
AGENTS.md
A special file you can put in any folder that tells OpenCode standing instructions whenever it works in that folder. Things like "this is a marketing project", "always use Australian English", "the stakeholders are X and Y", "use this tone".Analogy: Like a job brief OpenCode reads at the start of every session in that folder, so you don't have to repeat yourself.
MCP (Model Context Protocol) / MCP Server
A connector that lets OpenCode talk to another tool — Webex, Confluence, Jira, Airtable, GitHub, almost anything. Once an MCP is set up, OpenCode can read from or write to that tool as part of a session.
Analogy: An MCP is like a USB cable between OpenCode and another system. The "server" part sounds technical, but it's just the bit doing the connecting — you don't need to think about it as anything fancy. Most MCPs are set up once and then forgotten about.
API (Application Programming Interface)
The way one piece of software talks to another. When OpenCode pulls a Confluence page or posts a message to Webex, it's using that tool's API behind the scenes.
Analogy: An API is like a service counter at a shop. You walk up, ask for something specific in a format the shop understands, and get something back. APIs are how every connected app on your phone talks to its servers.
API Key / Token
A password that lets OpenCode (or any other tool) use an API on your behalf. When you connect OpenCode to Webex, you give it a Webex API key so Webex knows the requests are coming from you and are allowed.
Treat them exactly like passwords. Don't paste them into chats, don't share them in screenshots, don't put them in files that get shared. See Handling API Keys & Tokens Safely.
Repository / Repo
A folder of files stored on GitHub, with a full history of every change ever made to it. You work on a local copy on your laptop, and the master version lives in the cloud.
Analogy: Think of it as a folder with built-in version control and a permanent backup. Everything is saved, nothing is lost, and you can roll back if you make a mess.
GitHub / GitHub Enterprise
A place on the internet where files (especially code, but really anything text-based) live, with version history and access controls. The world's most popular place to store and share software.
Many large organisations also run their own private "GitHub Enterprise" instance — same product, but only accessible to their employees and behind their corporate network. If your workplace has one, it's safe for internal documents, playbooks, and team-shared files in the same way Confluence is.
The cloud
Just means "stored on a server somewhere on the internet, not on your laptop." That's it. Confluence, OneDrive, GitHub, Webex, Gmail — all cloud tools. The phrase makes it sound fluffy and abstract, but it really just means "not local."
Clone / Push / Pull / Commit
The four words you'll hear about GitHub. They sound technical but the ideas are simple — and the good news is OpenCode can do all of these for you, you just need to know roughly what they mean:
- Clone = download a repository to your machine for the first time.
- Commit = save a snapshot of your changes locally, with a short note describing what changed.
- Push = send your committed changes up to GitHub so they're saved in the cloud.
- Pull = grab the latest version from GitHub down to your machine (useful if you or someone else made changes elsewhere).
You don't have to type any of these as commands. Just ask OpenCode to "save my changes to GitHub" and it handles all of them.
Token (the other meaning — model context)
Confusingly, "token" means something different here than an API token. In the LLM world, a token is a small chunk of text the model processes — roughly three-quarters of a word. So "approximately" is one or two tokens; "OpenCode" is two or three.
Why it matters: every model has a limit on how many tokens it can hold in one conversation. Bigger limit = more context it can handle. You'll hear people talk about "context windows" measured in tokens (e.g. 200K tokens). For most non-technical use, you don't need to worry about it.
Hallucination
When an LLM confidently makes something up. The model doesn't always know what it doesn't know — so sometimes it invents a name, a date, a quote, or a fact that sounds plausible but isn't real.
This is a genuine risk to be aware of. The way to mitigate it: give the model good source material as context (so it has the real answer to draw from), and verify anything important before you publish or send it on. Don't take confident-sounding outputs at face value just because they sound right.