A quick reference for terms you'll run into.
The type of AI model that powers tools like Claude, ChatGPT, and Gemini. An LLM is trained on large amounts of text and learns to predict what comes next in a sequence. When people say "AI" in a software context right now, they usually mean an LLM or something built on top of one.
Example: Claude is an LLM. When you type a question, the model generates a response token by token based on everything it's learned and everything in your current conversation.
The input you give to an AI model — your question, instruction, or starting text. The wording matters more than most people expect. "Write tests for this function" and "Write unit tests for this function using the existing test style in this file, covering edge cases" will get you very different results.
See How to Prompt and the 8th Light Awesome AI Prompts for practical examples.
The amount of text a model can "see" at once — your conversation history, any files you've shared, system instructions, everything. Think of it like working memory. Once you exceed it, the model starts losing track of earlier parts of the conversation.
Example: If you share a large file and have a long conversation about it, you may notice the model forgetting details from earlier as you get further in.
The unit a model uses to process text — roughly four characters, or about three-quarters of a word. Models don't read words the way humans do; they break everything into tokens first. This matters practically because model pricing is usually measured in tokens, and context windows are measured in tokens too.
Example: "AI is moving fast" is roughly 5 tokens.
When a model generates something that sounds confident and plausible but is factually wrong. This happens because models are pattern-matchers — they generate what seems likely to come next, not what is provably true. Hallucinations are more common with specific facts (dates, names, numbers, API signatures) than with general reasoning.
Verify facts, test generated code, and audit output before use.
Giving a model accurate, specific information to work from — rather than relying on what it learned during training. Grounding reduces hallucination and makes responses more relevant to your actual situation. Sharing relevant context — a file, a spec, a chunk of documentation — before asking a question is a form of grounding.
Example: Instead of "How does our auth system work?", share the relevant auth code and ask "Given this code, how does our auth system work?" The second version is grounded.
Training a model further on a specific dataset to specialize its behavior. The base model learns general language patterns; fine-tuning teaches it to behave differently for a specific use case — like always responding in a certain format, or understanding domain-specific terminology. Most developers won't need to fine-tune a model.
Fine-tuning addresses hallucination or inconsistency in some cases, but good prompting and grounding usually gets you further. Consider it when consistent output format or domain-specific vocabulary matters.
Anthropic's AI assistant and the primary AI tool at 8th Light. Available as a chat interface at claude.ai, via API for building applications, and via Claude Code for development workflows. Known for its large context window, strong reasoning, and safety focus.
Get access: Email software@8thlight.com.
A command-line tool that puts Claude directly into your development workflow. Rather than switching between your editor and a chat window, Claude Code lets you work with an AI agent that can read your files, run commands, write and edit code, and iterate — all from the terminal. It understands your project structure and can take on multi-step tasks.
See Claude Code Basics to get started. The Claude Code in Action course on Anthropic Academy is a solid introduction.
The desktop application for Claude. It supports MCP (see below), which means you can connect it to local tools and services — your filesystem, GitHub, databases — without writing code. This makes it accessible for working with real data without needing to build anything.
Example: Connect Claude Desktop to your GitHub repo via MCP and ask it to summarize recent pull requests or explain a file — no terminal required.
An open protocol that lets AI models connect to external tools and data sources. Instead of copying and pasting information into a chat window, MCP lets the model reach out and get it directly — from your filesystem, a database, an API, or a service like GitHub or Slack. Think of it as a standardized way to give AI models hands.
A model that can read a database, query an API, and write back results is a very different tool than one that just answers questions. See MCP and Tools for more.
An agent is an AI model that doesn't just respond to a single prompt — it takes a sequence of actions to accomplish a goal. It might read files, run code, check results, and try again, all on its own. An agentic workflow is one built around this loop: observe → decide → act → repeat.
Example: Claude Code is an agent. You tell it "add tests for the payment module" and it reads the existing code, writes tests, runs them, sees which ones fail, fixes them, and reports back — without you directing each step.
Agents can go wrong in non-obvious ways. Giving an agent the ability to take actions (write files, run commands, call APIs) means mistakes can have real consequences. Good agentic workflows include human checkpoints and clear scope boundaries.
A pattern for giving a model access to a large body of knowledge without fine-tuning. Instead of trying to train the model on all your data, you store that data separately, retrieve the relevant pieces at query time, and include them in the prompt. The model uses what it's given to answer — grounded in your actual content.
Example: A support chatbot that can answer questions about your product docs. The docs are stored in a database; when a user asks a question, the relevant sections are retrieved and included in the prompt before the model responds.
See RAG and Vectors for how it works in practice.
A way of representing text (or other data) as a list of numbers — a vector — that captures its meaning. Two pieces of text that mean similar things will have similar vectors, even if they use different words. Embeddings are what make it possible to search by meaning rather than keyword.
Example: The query "how do I reset my password?" and the doc section "account recovery steps" might not share any words, but their embeddings will be close — so a vector search will still find the right result.
A database designed to store and search embeddings. Regular databases search by exact match or filter; vector databases search by similarity. This is the storage layer that makes RAG work — you embed your documents, store them here, and query them by meaning at runtime.
Common tools: Pinecone, Weaviate, pgvector (Postgres extension), Chroma.
The ability for a model to call external functions or APIs as part of generating a response. The model decides when a tool is needed, calls it with the right inputs, and incorporates the result. Tool use is what turns a chat model into something that can actually do things — check a calendar, run a query, send a message.
Example: An AI assistant with tool use set up might respond to "what's on my calendar tomorrow?" by calling a calendar API, getting the results, and summarizing them — rather than guessing or saying it doesn't have access.
A structured workflow for tackling complex tasks with Claude Code. Instead of jumping straight to implementation, you break the work into three stages: Research (understand the codebase and requirements), Plan (produce a written plan for review), and Implement (execute the plan). The human reviews and approves between stages, which catches mistakes before they compound.
This pattern has evolved into installable skill sets. See dev-skills for a full Claude Code implementation of this workflow.
An approach to AI-assisted development where you build testing and validation infrastructure — a "harness" — before letting agents work on your codebase. The idea is that agents are only as reliable as the feedback loops you give them. Good tests, linters, and CI checks let an agent verify its own work, which gives it a way to catch its own mistakes.
See Harness Engineering and the resources section for further reading.
The practice of writing and structuring prompts to get better results from AI models. This includes things like providing context, specifying format, giving examples, breaking complex tasks into steps, and knowing when to use a system prompt vs. a user message. It's less about magic tricks and more about clear communication.
See How to Prompt and the Anthropic Prompt Engineering Guide.
The practice of writing a specification before writing code with AI — making the spec, not the code, the primary artifact the agent implements against. At minimum this means writing a clear description of what you're building before implementation starts. Some approaches go further, keeping the spec as a living document that evolves alongside the code.
See approaches/spec-driven-development.md for a deeper look and tool options.
The practice of deliberately shaping what an agent sees — the standing instructions, tools, memory files, and retrieved content that make up its context — to get better results. Different from prompt engineering, which focuses on individual requests. Context engineering is about the environment the agent operates in across an entire session or project.
See approaches/context-engineering.md for how this applies in Claude Code.
AI models whose weights are publicly released — meaning anyone can download and run them. Examples include Meta's Llama series and Mistral. The main appeal is control: you can run them on your own infrastructure, so data never has to leave your environment. They typically require more setup and currently trail frontier models like Claude on capability.
Before submitting proprietary or sensitive data, understand the model's data handling policies.
"Open source" in the AI world varies — some models are free to use but have restrictions on commercial use. Check the license. Safety properties also vary widely.
A markdown file that Claude Code reads at the start of every session to understand your project. You put things in it like coding conventions, architecture decisions, commands to know, and things to avoid. It's how you give Claude persistent context about your codebase without repeating yourself every session.
Example: "Always write tests before implementation. Use the existing mock pattern in /tests/helpers. Never modify the database schema directly."
Reusable, composable capabilities you can add to Claude Code — like plugins. A skill might handle a specific workflow (running a QA pass, creating a pull request, formatting code to a style guide). Skills can be shared across projects and teams.
See Skills.sh for the broader ecosystem, Superpowers for a full agentic development workflow built on composable skills (installable directly into Claude Code), and the 8th Light Awesome AI Prompts for our internal collection.
Scripts that run automatically at specific points in a Claude Code session — before a tool call, after a response, on session start. Hooks let you enforce rules, log activity, run validations, or trigger external systems. They're how you add guardrails and automation to agentic workflows.
Example: A hook that runs your linter after every file edit, so Claude Code always gets immediate feedback on whether its changes pass. For a practical safety application, see claude-code-safety-net — a hook that catches destructive git and filesystem commands before they execute.
A framework for building applications with LLMs. It provides abstractions for common patterns — chaining prompts together, connecting to tools and data sources, building agents.
LangChain adds abstraction on top of direct API calls. For many use cases, calling the API directly is simpler — LangChain is most useful when your workflow is complex enough to benefit from the structure.
Learning resources: LangChain Academy has free courses.
A library built on LangChain specifically for building multi-agent workflows as graphs. Each node in the graph is a step or agent; edges define how control flows between them. LangGraph is useful when you need fine-grained control over complex agentic systems — multiple agents handing off to each other, conditional logic, loops.
When it matters: If you're building something where one agent hands off to another, or where the workflow branches based on results, LangGraph gives you a structured way to model that. See Agentic Systems.
Term missing? Open a PR or drop a note in #ai-explorers.