Glossary

Every AI, tech and business term — plus every command, flag and file across the courses — in plain words. The same definitions you see when you hover a term inside a lesson.

⌘K

AI-generated

AI & tech terms 171

adapter: A small trained add-on (as in LoRA) that adjusts a base model for a new task without retraining the whole thing.
agent: An AI that can take actions on its own — use tools, call APIs, run multi-step tasks — not just chat.
API: Application Programming Interface — a defined way for one program to request data or actions from another, usually over the internet.
API key: A secret password-like string that authorises your requests to a paid AI service and tracks your usage.
attention mechanism: The part of a transformer that decides which tokens in the input to focus on when predicting each output token.

B2B: Business-to-business — selling products or services to other companies rather than to individual consumers.
backend: The server-side part of an app — the logic, databases, and APIs that users never see directly.
batch API: An API mode that queues many requests to be processed asynchronously at lower cost, ideal for large offline jobs.
benchmark: A standardised test used to compare AI models on a common task (e.g. coding, reasoning, reading comprehension).
BM25: A classic keyword-ranking formula that scores how well a document matches the query words — the standard baseline for keyword search.
BYOK: Bring Your Own Key — you supply your own paid API key to a tool instead of the tool billing you directly.

cache: A temporary store of results so repeated requests are served faster without redoing the work.
chain-of-thought: Prompting a model to reason step by step before giving its final answer.
chunking: Splitting documents into smaller passages so they can be embedded and retrieved one piece at a time.
CI: Continuous Integration (with CD, Continuous Deployment) — automatically building, testing, and shipping your code whenever you change it, to catch breakage early.
CLI: Command-line interface — you type text commands in a terminal instead of clicking buttons.
codebase: All the source-code files that make up a project, taken together — the thing you own and edit once you leave a no-code builder.
commit: A saved snapshot of your changes in version control, with a short message describing what changed.
container: A lightweight, isolated package that bundles an app and its dependencies so it runs consistently anywhere (e.g. via Docker).
content filter: A safety layer that screens model inputs or outputs and blocks harmful or disallowed content.
context overflow: What happens when an input exceeds the model's context window: older content is silently dropped or the request is rejected.
context window: How much text a model can consider at once, measured in tokens — a bigger window fits more of your documents in one go.
contextual retrieval: A RAG improvement that prepends a short summary of each chunk’s surrounding context before embedding it, so retrieval finds the right passage more often.
CPU: Central processing unit — a computer’s general-purpose processor; models can run on it without a GPU, but more slowly.
CRM: Customer Relationship Management — software that tracks your contacts, deals, and conversations with customers (e.g. Salesforce, HubSpot).
cross-encoder: A reranking model that reads the query and a document together to score relevance precisely — slower but sharper than embedding similarity.
CSAT: Customer Satisfaction score — a metric (often a 1–5 rating) of how happy customers are with a product or support.
CSP: Content Security Policy — a set of browser rules that limits what scripts and resources a page may load, blocking many injection attacks.
CSV: Comma-separated values — a plain-text spreadsheet format where each line is a row and commas separate the columns.

database: An organised store of data that programs can quickly search, add to, and update.
dataset: A collection of data assembled for a purpose — to train or test a model, or to analyse.
defense-in-depth: Layering several independent safeguards so that if one fails, others still catch the problem.
dependency: An external library or package your project needs in order to run.
deploy: To publish your app to a server so other people can actually use it.
dev server: A temporary web address that runs your app while you build it, updating as you edit — it is for development, not for real visitors.
distillation: Training a smaller, faster model to imitate a bigger one.
Docker: A tool that packages an app with everything it needs into a container, so it runs the same on any machine.
DPO: Direct Preference Optimization — an alignment method that tunes a model directly from "this answer is better than that one" comparisons.

embedding: A list of numbers that captures the meaning of a piece of text, so a computer can find passages with similar meaning.
endpoint: A specific URL on a server that accepts one kind of request (e.g. /api/chat) — the address your code calls.
environment variable: A named value (like an API key) stored outside your code that a program reads when it starts.

fair-code: A licensing model (used by n8n) where the source is open to read and self-host, but reselling it as a hosted service is restricted.
few-shot: Giving a model a handful of worked examples in the prompt to show it the pattern you want.
fine-tuning: Further training a ready-made model on your own examples so it specialises in your task or writing style.
FPGA: Field-Programmable Gate Array — a chip you configure into custom hardware circuits for very fast, specialised processing.
framework: A reusable foundation of code and conventions you build an app on top of, so you don’t start from scratch.
frontend: The part of an app that users see and interact with, in the browser or on screen.
full-stack: Covering both the frontend (what users see) and the backend (server, database, logic) — a full-stack builder generates a complete working app, not just the screens.
function calling: A model feature that lets the AI call external functions or tools mid-conversation and act on the results.

GB: Gigabyte — a unit of data/memory size; model files and the RAM or VRAM needed to run them are measured in GB.
GGUF: The standard single-file format for quantized local models (used by Ollama and LM Studio) — the file you download to run a model on your own machine.
Git: The standard version-control tool that tracks every change to a project’s files so you can review history and collaborate.
GPU: Graphics processing unit — a chip that runs many calculations in parallel; the standard hardware for running AI models.
grounding: Making an AI base its answers on the sources you provide rather than its own memory.
guardrail: A rule or filter applied to model inputs or outputs to prevent harmful, off-topic, or policy-violating content.

hallucination: When an AI states something false but plausible-sounding as if it were fact.
HDL: Hardware Description Language — code (like Verilog) that specifies the actual digital circuits on an FPGA or chip.
HLS: High-Level Synthesis — tools that turn C/C++ into hardware circuits, a faster route to an FPGA design than writing raw HDL by hand.
HTML: HyperText Markup Language — the code that defines the structure and content of a web page.
HTTP: The protocol browsers and APIs use to request and send data over the web; HTTPS is the encrypted, secure version.
hybrid search: Combining keyword search and semantic (vector) search and merging the results — catches both exact terms and meaning.

ICP: Ideal Customer Profile — a description of the type of customer a product is best suited for.
IDE: Integrated development environment — an app for writing code (like VS Code) with editing, running, and debugging in one place.
inference: Running a trained model to get an answer — as opposed to training the model in the first place.
inference provider: A service that runs open models for you behind an API (e.g. Groq, Cerebras, OpenRouter), so you don’t need your own GPU.

jailbreak: A crafted prompt that tricks an AI into ignoring its safety rules and doing something it normally refuses.
JD: Job Description — a written summary of a role’s responsibilities and requirements.
Jetson: NVIDIA’s family of small AI computers with a built-in GPU, made to run models on robots and edge devices.
JSON: A lightweight text format for structured data — key–value pairs and lists — that programs and APIs use to exchange information.

keyword search: Finding text by matching the literal words of the query (e.g. BM25), as opposed to matching by meaning.
knowledge base: The collection of documents you give an AI to answer questions from.
KPI: Key Performance Indicator — a headline metric used to track whether something is on target (e.g. signups per week).
KV cache: A model’s short-term memory of the current conversation; it grows with the context length and uses extra memory on top of the model itself.

latency: The delay before a model starts responding.
LLM: Large language model — the kind of AI (like GPT or Claude) trained on huge amounts of text to understand and generate language.
localhost: Your own computer used as a server address (127.0.0.1) — where locally-running software is reached, e.g. localhost:11434.
LoRA: Low-Rank Adaptation — a cheap fine-tuning method that trains a small add-on instead of the whole model, so it needs far less memory.
LPU: Language Processing Unit — Groq’s custom chip built specifically to run language models very fast.

machine learning: Teaching computers to find patterns in data and improve at a task, instead of following hand-written rules.
markdown: A simple plain-text formatting syntax (e.g. # for headings, ** for bold) that converts to formatted text.
MCP: Model Context Protocol — a standard that lets an AI assistant plug into outside tools and data sources like files, databases, and apps.
MCU: Microcontroller — a tiny low-power computer-on-a-chip that runs a single embedded program, e.g. inside a sensor or robot.
MIT: The MIT License — a very permissive open-source licence that lets almost anyone use, change, and even sell the code.
MLX: Apple’s framework for running models on a Mac (Apple Silicon), often faster than other formats on the same Mac.
MoE: Mixture of Experts — a model split into many specialist parts where only a few run per word, so a huge model can run fast and cheap (active parameters are far fewer than total).
MRR: Monthly Recurring Revenue — the predictable subscription income a business earns each month.
multimodal: A model that handles more than text — images, audio, or video — in the same prompt.
MVP: Minimum Viable Product — the smallest version of a product that delivers real value, built to test the idea quickly.
MXFP4: A 4-bit format that OpenAI’s gpt-oss models ship in natively — it shrinks the model with almost no quality loss.

npm: Node’s package manager — installs and manages JavaScript libraries, usually via `npm install`.

OAuth: A standard that lets you grant an app limited access to your account (e.g. “Sign in with Google”) without sharing your password.
OCR: Optical character recognition — pulling the text out of an image or scanned document.
offline-first: Designed to work fully without an internet connection, keeping your data on your own machine.
ONNX: Open Neural Network Exchange — a portable model file format so a trained model can run across different tools and hardware.
open-source: Software whose source code is published so anyone can read, run, and modify it.
open-weights: A model whose trained parameters are published, so anyone can download and run it themselves.
OWASP: Open Worldwide Application Security Project — publishes the widely-used “Top 10” lists of common security risks, including one for LLM apps.

parameters: The internal numbers a model learned during training; more of them (e.g. 70 billion, written "70B") usually means more capable but heavier to run.
PDF: Portable Document Format — a fixed-layout document file; many AI tools can read from or generate PDFs.
PEFT: Parameter-Efficient Fine-Tuning — a family of methods (like LoRA) that adapt a model by training only a tiny fraction of its parameters.
pipeline: A sequence of automated steps where each step’s output feeds the next (e.g. fetch → clean → analyse → report).
POST: An HTTP request that sends data to a server to create or process something — as opposed to GET, which just fetches data.
prompt: The instruction or question you give an AI.
prompt caching: Reusing a stored copy of a long prompt prefix so the model skips reprocessing it, cutting cost and latency.
prompt engineering: The craft of writing prompts that reliably get good results.
prompt injection: An attack where hidden instructions buried in content trick an AI into ignoring its real task.
pull request: A proposed set of code changes submitted for review before being merged into the main project (often shortened to “PR”).

Q4_K_M: A common quantization setting (4-bit, “medium”) — the usual sweet spot that keeps a model small and fast while preserving most of its quality.
QA: Quality Assurance — systematically testing a product to catch defects before users hit them.
quantization: Shrinking a model so it runs on less memory, trading a little accuracy for speed.

RAG: Retrieval-Augmented Generation — the AI looks up relevant documents first, then answers using them, so replies are grounded in your sources instead of its memory.
RAM: A computer’s main working memory; a model and its data must fit in RAM (or in VRAM on a GPU) to run.
rate limit: A cap on how many requests you can make in a given period.
RCE: Remote Code Execution — the most severe flaw, where an attacker gets your system to run commands of their choosing.
README: A project’s intro-and-setup document (usually README.md) — the first file you read in a code repository.
reasoning tokens: Hidden tokens a reasoning model generates to think through a problem before its visible answer — you pay for them and they count toward limits.
red-team: Deliberately attacking your own AI system to find weaknesses (jailbreaks, leaks) before real attackers do.
regex: Regular expression — a compact pattern for finding or validating text, like matching emails or phone numbers.
repo: Repository — a project’s folder of files (usually code) tracked by version control like Git.
reranking: A second-pass model that re-orders retrieved documents by relevance before they are passed to the main model.
REST: A common style of web API where a program fetches or sends data by calling URLs over HTTP — often called a “REST API”.
RLHF: Reinforcement Learning from Human Feedback — a training step where people rate the AI’s answers to make it more helpful and safe.
ROI: Return on Investment — how much value or profit you get back compared with what you spent.
ROS 2: Robot Operating System 2 — the standard open-source framework for writing the software that controls robots.
RSS: A standard feed format that lets apps automatically pull a site’s latest items (articles, videos) as they’re published.

SaaS: Software as a Service — software you use over the internet by subscription, rather than installing and owning it.
sandbox: An isolated environment where code or an AI can run safely without affecting the rest of your system.
schema: A defined structure that data must follow — the field names, types, and rules an input or output is checked against.
scraping: Automatically extracting data from web pages with a program instead of copying it by hand.
SDK: Software Development Kit — a bundle of ready-made code that makes building on top of a service easier.
self-hosting: Running software on your own server instead of using the vendor’s cloud.
semantic search: Finding text by meaning using embeddings, so a query matches relevant passages even when they share no exact words.
server: A computer or program that provides data or services to other machines over a network.
SFT: Supervised Fine-Tuning — training a model on labelled input→output example pairs to teach it a task or style.
similarity threshold: A cutoff score below which retrieved chunks are discarded, so only sufficiently relevant matches reach the model.
SLA: Service Level Agreement — a promised standard of service, such as “99.9% uptime” or “reply within one hour”.
SOP: Standard Operating Procedure — a written, step-by-step routine for doing a recurring task the same way every time.
SQL: Structured Query Language — the standard language for reading and writing data in a relational database.
SQL injection: An attack that hides malicious database commands inside user input to read or destroy data — prevented by never pasting untrusted text straight into a query.
SSRF: Server-Side Request Forgery — tricking your server into making requests to internal systems it was never meant to reach.
streaming: Token-by-token delivery of a model's response so the text appears word by word instead of all at once.
structured output: A model mode that forces replies to follow an exact JSON schema, making them easy to parse by code.
STT: Speech-to-text — turning spoken audio into written text.
system prompt: Hidden instructions that set an AI’s role and rules for the whole conversation.

temperature: A setting that controls how random or creative an AI’s output is — lower is more focused, higher is more varied.
TensorRT: NVIDIA’s toolkit that optimises a model to run as fast as possible on NVIDIA GPUs, including Jetson boards.
terminal: The text window where you type commands to control your computer, instead of clicking buttons.
TFLite-Micro: TensorFlow Lite for Microcontrollers — a runtime for running tiny models directly on a microcontroller.
throughput: How much work a model serves per unit time (e.g. total tokens per second across all users) — distinct from latency, the wait before the first token.
token: A chunk of text (roughly ¾ of a word) that a model reads or writes; usage limits and context windows are measured in tokens.
tokenization: The process of splitting text into tokens (small chunks) before a model reads or writes it.
tokens per second: How fast a model writes — its output speed; about 10–15 per second feels usable in chat, higher feels instant.
top-k: The number of best items to use — in retrieval, the k most relevant chunks fetched; in sampling, the k most likely next tokens the model may pick from.
top-p: Nucleus sampling — the model chooses from the smallest set of next-word options whose probabilities add up to p, balancing focus and variety.
transformer: The neural-network architecture behind most modern language models, built around self-attention layers.
TTS: Text-to-speech — turning written text into spoken audio.
TUI: Text user interface — a richer, full-screen terminal app with menus and panels, still keyboard-driven.

UI: User interface — the buttons, screens, and controls you interact with in an app.
URL: Uniform Resource Locator — a web address (like https://example.com) that points to a page, file, or API endpoint.

vector store: A database that stores embeddings and quickly finds the most similar ones — the search engine behind RAG.
vectorization: Turning text into embeddings (lists of numbers) so it can be stored and searched by meaning.
Verilog: A hardware description language used to design the digital circuits that run on FPGAs and custom chips.
version control: Tracking changes to files over time (usually with Git) so you can see history, undo mistakes, and work as a team without overwriting each other.
vision input: Sending images or PDFs to a multimodal model so it can read, describe, or reason about visual content.
VLA: Vision-Language-Action model — a model that maps camera images plus an instruction directly to robot actions.
VLM: Vision-Language Model — an AI that understands images and text together, e.g. so a robot can describe or reason about what its camera sees.
VPS: Virtual Private Server — a rented slice of a remote computer you fully control, commonly used to host apps online.
VRAM: The memory on a graphics card (GPU); a model has to fit in it to run fast — the main limit on which local models your hardware can handle.

webhook: A URL that one app calls to notify or trigger another app the moment something happens.

XSS: Cross-site scripting — an attack that injects malicious code into a web page so it runs in other users’ browsers.

zero-shot: Asking a model to do a task with no worked examples — just the instruction.

Base44 11 lessons ↗

Features

invokeLLM: A built-in Base44 function that runs an AI language model from inside your app, letting you add features like summarization, classification, or a chat assistant without managing any external API keys.
GenerateImage: A built-in Base44 function that creates an image from a text description, so your app can produce cover photos, thumbnails, or marketing visuals on demand.
GenerateSpeech: A built-in Base44 function that converts text into spoken audio and returns a URL to an MP3 file, supporting 30 languages and five voice styles (river, honey, sunny, storm, spark).
SendEmail: A built-in Base44 function that sends an email (such as a confirmation, alert, or notification) to registered users of your app without needing a separate email service account.
ExtractDataFromUploadedFile: A built-in Base44 function that reads an uploaded document (CSV, PDF, or image) and extracts its contents into structured records your app can store and query.
App Visibility: A dashboard setting that controls who can reach your published app: public to anyone, your workspace, or private/invited users only.
Connectors: Base44 integrations with services like Stripe, Gmail, and Slack that authorise via OAuth, so no API key sits in your code.
integration credits: The unit consumed by Base44's built-in AI and connector actions (roughly a few per LLM call, about one per email), drawn from your plan's monthly allowance.
Automations: Base44's scheduler for backend jobs that run on a time schedule or on a data change, with no user needing to open the app.
Security Scan: Base44's automated check that grades your app's data-permission rules and endpoints and flags issues to fix before publishing.

Commands

npm install: A standard command that downloads and adds a JavaScript library from the public npm registry into your project so your code can use it.

Claude Code 34 lessons ↗

Commands

claude: The command you type in your terminal to start a Claude Code session; running it opens an interactive AI coding assistant in your project folder.
claude -p "query": Runs Claude Code in print mode — Claude answers the query and exits immediately, making it useful in scripts and automated pipelines.
claude --permission-mode plan: Starts Claude Code in plan mode so it describes what it intends to do before making any file or code changes, letting you review and approve first.
pytest tests/ -q: Runs the automated test suite in the tests/ folder using pytest, with -q (quiet) flag to show only failures rather than every test name.
git diff: A git command that shows exactly which lines have been added or removed in your files since the last saved version.
gh: The official GitHub command-line tool; Claude Code uses it to create pull requests, read comments, and interact with GitHub repositories.
aws: The Amazon Web Services command-line tool; lets you control cloud services such as S3 storage and Lambda functions from the terminal.

Flags

-p: Short form of --print; tells Claude Code to respond to a single query and exit without opening an interactive session.

Concepts

default: The standard permission mode where only read operations run without prompting; file edits and shell commands always ask for your approval.
acceptEdits: A permission mode that auto-approves file edits and common filesystem commands (mkdir, touch, rm, mv, cp, sed) without prompting, while still asking before other shell commands.
plan: A permission mode where Claude reads files and runs shell commands to explore your codebase, but cannot edit source files until you approve its proposed plan.
PreToolUse: A hook event that fires just before Claude runs any tool, letting you inspect or block the action with a shell script before it takes effect.
Bash: Claude Code's built-in shell tool that executes terminal commands on your machine; it is the tool name used in permission rules and hooks.
pandas: A popular Python library for working with tabular data such as spreadsheets and CSV files; used in many data-analysis scripts.
seaborn.histplot: A Python function from the Seaborn visualisation library that draws a histogram (a bar chart showing how values are distributed).
None: Python's built-in value meaning 'nothing' or 'no result'; a function returns None when it has no explicit return value.
ValueError: A standard Python error raised when a function receives an argument of the right type but an unacceptable value, such as a negative number where a positive one is required.

Slash commands

/: Typing a forward slash at the start of your message opens the command menu so you can see and filter all available Claude Code commands.
/help: Shows a list of available commands and a brief description of each.
/clear: Starts a fresh conversation with empty context; the previous conversation stays available via /resume.
/resume: Opens a picker to return to a previous conversation by name or ID, restoring the full message history.
/rewind: Rolls the conversation and code changes back to an earlier point, or summarizes from a selected message, letting you undo a direction that went wrong.
/usage: Shows session cost, plan usage limits, and activity statistics, including a breakdown by skill, subagent, and MCP server on paid plans.
/compact: Summarises the conversation so far to free up context space; you can optionally tell it what to focus on (e.g. /compact Focus on test output).
/context: Displays a visual breakdown of what is filling your context window and shows optimization suggestions and capacity warnings.
/model: Opens a picker to switch the AI model Claude Code uses; the choice is saved as your default for new sessions.
/config: Opens the Settings panel where you can change your theme, model, output style, and other preferences.
/mcp: Manages MCP server connections and OAuth authentication; run with no argument to open the interactive list.
/schedule: Creates or manages routines that run on Anthropic-managed cloud infrastructure on a schedule, even when your computer is off.
/loop: Runs a prompt repeatedly while the session stays open; omit the interval and Claude self-paces between iterations.
/skill-name: The pattern for invoking any custom skill you have created; replace skill-name with the actual name of your SKILL.md file (e.g. /review-pr).

Files & config

.claude/skills/review-pr/SKILL.md: An example skill file path; a SKILL.md placed in .claude/skills/<name>/ defines a reusable workflow Claude loads when you run /<name>.
.claude/commands/*.md: The legacy location for custom command files; any .md file placed here also creates a slash command and continues to work alongside the newer .claude/skills/ layout.
model: haiku: A settings key that pins the AI model to Haiku (a faster, lower-cost Claude model) for a project or session.

Building complex codebases 16 lessons ↗

Commands

/prime: Loads context for a fresh session — the ticket, the file tree, and recent git history — so the agent gets oriented in one step.
/plan: Asks the agent to write an implementation plan (steps, files, and the checks that must pass) without editing any code yet.
/implement: Executes an approved plan — ideally in a fresh session so it follows the plan instead of drifting on old conversation.
/validate: Runs the checks that must pass — lint, type-check and tests — and reports what failed.
/review: A structured code-review pass over the changes, looking for bugs, missing tests and security issues.

Files & config

CLAUDE.md: Project rules the agent loads at the start of every session; keep it lean — only rules it would be wrong without.
~/.claude/CLAUDE.md: Your personal, global rules that apply across all of your projects. The ~ means your home folder.
.claude/commands/: The folder where reusable slash commands live — checked into git alongside your code so the whole team shares them.
SKILL.md: A saved skill — a short file describing a procedure the agent loads only when it is relevant.
INITIAL.md: A plain feature request file; in Cole’s context-engineering workflow the agent turns it into a full plan (a PRP).

Concepts

AI layer: The version-controlled context that teaches the agent your codebase — rules, commands and skills — kept next to the code.
PIV loop: Plan → Implement → Validate: plan in a fresh context, implement, then prove the work with checks that must pass.
PRP: Product Requirements Prompt — a comprehensive, validation-gated blueprint the agent generates from a request and then executes.
context window: The amount of text (code, chat, rules) a model can consider at once; it is finite, so what you load matters.
subagent: A helper agent with its own isolated context, used to parallelise or isolate work without contaminating the main session.
MCP: Model Context Protocol — a standard way to connect an agent to external systems like GitHub, a database, or Jira.

Gitea 20 lessons ↗

Concepts

Repository: A shared folder that stores every version of every file together with who changed what and when.
Self‑hosted Git service: Software that provides Git repository hosting on your own servers instead of a third‑party site.
Git forge: A platform like Gitea or GitHub that lets teams create, manage and collaborate on repositories.
Pull request (PR): A request to merge changes from one branch into another, showing a side‑by‑side diff for review.
Branch: An isolated line of development that keeps your edits separate from the main code until merged.
Issue: A record in Gitea used to track a problem, request or task, with rich formatting and comments.
Gitea Actions: The built‑in continuous integration/continuous deployment (CI/CD) system that runs workflow files stored in `.gitea/workflows/`.
Forgejo: A community‑governed fork of Gitea that offers the same core features under independent stewardship.

Interface

+ New Repository button: The web UI control in Gitea used to start a new repository without using the command line.
Inline comment: A remark attached to a specific line in a pull‑request diff, used for precise feedback.
Merge button: The highlighted control that becomes clickable once required checks pass, allowing the branch to be merged.
Label: A tag applied to an issue that categorises it (e.g., bug, enhancement) for easy filtering.
Assignee: The person selected to work on an issue, shown by their avatar on the issue card.
Green check: The green check mark shown on a commit that indicates all CI workflow steps completed successfully.

Commands

"Fixes #<issue-number>": A phrase placed in a commit or PR description that automatically closes the referenced issue when merged.
Docker run command: A single command that starts a Docker container hosting the Gitea service, exposing web and SSH ports.

Components

Runner: A small Go program you register with Gitea so it can execute the jobs defined in your CI workflows.
SQLite: An embedded relational database bundled with Gitea so you can run it without setting up a separate database server.

Files

Workflow file: A YAML‑formatted file placed in `.gitea/workflows/` that defines triggers and steps for automated builds.

Formats

YAML: A plain‑text format using indentation to represent data structures, commonly used for configuration files like workflows.

GitHub 12 lessons ↗

Concepts

personal access token: A secret string you create on GitHub that lets a script act like you when accessing repositories.
scopes: Specific permissions you assign to a personal access token, such as allowing it to edit code or manage pull requests.
branch: A separate line of development in a repository where you can make changes without affecting the main code until you merge them.
MIT license: An open‑source legal notice that lets anyone use, modify, and share the code freely with minimal restrictions.

Files

deployment link: A web address (e.g., from Render, Vercel, Heroku) that runs your project online so others can view it without installing anything locally.
.github/workflows/: A folder inside a repository where you place YAML files that define automated actions like testing or building code.
YAML: A simple text format used to write configuration files, such as the workflow definitions for GitHub Actions.

Commands

commit: Saving a set of changes to your local copy of the code with a short description.
push: Sending your committed changes from your computer up to the GitHub repository.
pull request (PR): A request on GitHub to review and possibly merge changes from one branch into another.
echo command: A line you add to a workflow that prints a custom message into the log so you can confirm the step ran.

Interface

Actions tab: The page in a GitHub repository that shows the history and details of automated workflows that have run.

Test-Driven Prompt Engineering 12

Process

red‑green‑refactor cycle: A three‑step process where you first find a failing example (red), make the smallest change to fix it (green), then tidy up the prompt without breaking any tests (refactor).
Red: The label for an example that the current prompt gets wrong.
Green: The label for an example that the current prompt gets right after a change.
Refactor: A step where you simplify or reorganise the prompt while keeping all examples passing.
defendability check: A quick test to see if you can explain why a prompt works after it fails once; if not, the prompt relies on guesswork.
regression run: Re‑executing all examples after a change to ensure previously passing cases are still correct.
model swap regression check: Running the same test suite on a different language‑model version to spot any new failures caused by the change.

Concepts

input → expected output: A pair showing what you will give the model and the exact answer you want it to produce.
edge case: An unusual or difficult example that previously caused the prompt to fail.

Tools

pass/fail grid: A table that marks each example as pass (green) or fail (red) after running the prompt.

Files

example file: A document that lists all input‑output pairs and serves as the specification for testing the prompt.

Prompt Elements

delimiter: A character or string added to the prompt to clearly separate parts of the input, helping the model understand the structure.

From demo to production agent 12

Concepts

Retrieval Augmented Generation: A method that lets a language model answer questions by first searching a database of document vectors and adding the found text to its prompt.
Quadrant client wrapper: A small Python class that simplifies creating collections, adding (upserting) vectors with IDs and payloads, and performing similarity searches using the Quadrant service.
PointStruct: The data structure that holds an ID, a vector, and optional extra information (payload) for each item stored in Quadrant.
Agent Span: A service that moves the state of an AI agent to its own server so the agent can continue after crashes and be inspected via a web interface.
Ollama: Software that lets you run open‑source large language models, such as Llama 3.1, locally on your computer.
Model‑Context Protocol (MCP): A standard that converts natural‑language requests from a language model into API calls for external tools like Gmail or Calendar.

Commands

ingest_client.create_function: A command used to register an asynchronous Python function with an ID and trigger name so it can be called through the Ingest development server and automatically logged.
PDFReader: A tool from LlamaIndex that loads the raw text of a PDF file so it can be further processed into chunks.
OpenAI embeddings.create: An API call that takes a list of text strings and returns a matching list of numeric vectors (3072 dimensions) representing their meanings.
agent_span server start: The command line instruction that launches the Agent Span server on the default port 6767.

Files

agents.md: A markdown file placed in a project folder that contains a permanent system prompt defining the agent’s role, business context, and tool instructions.
memory.md: A mutable markdown file where an agent writes facts it learns so those preferences can be recalled in later sessions.

Docker 12 lessons ↗

Concepts

Container: An isolated process that has its own filesystem and network view but shares the host’s Linux kernel.
Image: A read‑only snapshot of a filesystem that contains everything needed to run an application.
Namespace: A Linux feature that gives a container its own separate view of system resources like processes and networking.
Cgroups: Linux controls that limit and account for the CPU, memory, and other resources used by a container.
Immutable image ID hash: A fixed identifier shown by docker inspect that proves you are using exactly the same image binary each time.

Commands

docker run: Command that creates a container from an image and starts it, optionally running a specific command inside.
docker images: Command that lists all image snapshots stored locally on your machine.
docker ps: Command that shows the containers currently existing (running or stopped) on the host.
docker rm: Command that deletes a container, freeing its resources and removing it from the list shown by docker ps.
docker inspect: Command that displays detailed metadata about an image or container, such as its ID hash.

Files

Dockerfile: A plain‑text file that contains step‑by‑step instructions for building a Docker image.
docker-compose.yml: A YAML configuration file that defines multiple services, their images, and how they should be started together.

Docker on Windows 12 lessons ↗

Interface

PowerShell: A command‑line interface built into Windows for running scripts and commands.
Ubuntu app: The shortcut in the Start menu that launches the Ubuntu Linux distribution inside WSL2.

Commands

wsl --list --verbose: A command that shows all installed Linux distributions on Windows and whether each is using WSL version 1 or 2.
wsl --install: A command that automatically enables the required Windows features, installs the Linux kernel, and adds a default Ubuntu distribution.
docker --version: A command that prints the installed Docker client version number.
docker compose version: A command that shows the version of the Docker Compose plugin bundled with Docker Desktop.
-d flag: An option added to `docker run` that starts the container in the background instead of tying up the terminal.

Software

Docker Desktop: A Windows program that provides a graphical interface and manages the Docker engine running inside WSL2.

Concepts

BIOS/UEFI: The low‑level firmware that starts your computer and contains settings such as CPU virtualization support.
Intel VT-x / AMD-V: Hardware features that allow a computer to run virtual machines, required for Docker Desktop’s WSL2 backend.
WSL2: Windows Subsystem for Linux version 2, which runs a real Linux kernel inside a lightweight virtual machine.

Files

.wslconfig: A text file placed in your user profile folder that lets you set limits such as maximum RAM for WSL2.

Docker on macOS 12 lessons ↗

Concepts

Apple Silicon: The ARM‑based processor family used in newer Macs.
Intel (AMD64): The x86‑64 CPU architecture that older Macs use, also called AMD64.
ARM64: Another name for the 64‑bit ARM architecture used by Apple Silicon.
Docker Desktop VM: A lightweight Linux virtual machine that runs behind Docker Desktop on macOS.
daemon: The background service (Docker Engine) that manages containers and responds to Docker commands.

Files

DMG: A macOS disk image file that you double‑click to install an application.
/Applications: The standard folder on a Mac where most apps are stored for easy launching.

Commands

`docker --version`: A Terminal command that prints the installed Docker version, confirming the CLI is available.
`--platform linux/amd64`: A flag you add to a Docker pull or run command to tell Docker to emulate an Intel‑based image on Apple Silicon.
`docker system prune -a`: A command that deletes all unused images, containers, networks, and build cache to free disk space.
`COPY <source> <dest>`: A line you add to a Dockerfile to copy files from your Mac into the image during build, improving performance on Apple Silicon.

Tools

Colima: A command‑line tool that runs Docker Engine in a lightweight VM as an alternative to Docker Desktop.

Docker on Linux 12 lessons ↗

Concepts

cgroups: A Linux kernel feature that limits and monitors resource usage for groups of processes.
namespaces: Kernel mechanisms that isolate system resources like network, process IDs, and file systems for each container.

Commands

apt-get: A command‑line tool used on Debian‑based Linux to install, remove, or manage software packages.
usermod: A command that modifies a user account, such as adding the user to a new group.
hello-world container: A small test image that prints a success message when run, confirming Docker is installed correctly.
systemctl enable: A command that registers a service to start automatically each time the system boots.
newgrp: A command that refreshes the current shell’s group memberships without logging out and back in.

Files

/var/run/docker.sock: A Unix socket file through which the Docker CLI talks to the Docker daemon; access gives full control over Docker.
docker.gpg: The public GPG key stored on the system that lets apt verify packages from Docker’s repository.
docker.list: A file placed in /etc/apt/sources.list.d that tells apt where to find Docker’s Ubuntu package repository.

Groups

docker group: A system user group whose members can run Docker commands without using sudo because they can access the Docker socket.

Configuration

restart: unless-stopped: A Docker Compose setting that tells containers to restart after a reboot unless they were manually stopped.

AI for robotics & edge devices 10 lessons ↗

Concepts

RTOS: A real‑time operating system that schedules tasks with strict timing guarantees.
ISR: Interrupt Service Routine, a short piece of code that runs when hardware signals an event.
malloc: A function that requests dynamic memory at runtime, which is discouraged in real‑time code because it can cause unpredictable delays.
latency budget: The maximum time allowed for a computation or response to meet real‑time requirements.
LLM/VLM: Large language or vision‑language model used as a service to generate high‑level robot plans.

Hardware

flash: Non‑volatile storage on a microcontroller where the program code is kept permanently.
RAM: Volatile memory that holds data while the microcontroller runs, cleared when power is lost.

Tools

benchmark script: A small program that repeatedly runs the model and measures how long inference takes.

Software

ROS 2: A middleware framework for building modular robot software, supporting communication between components.
firmware: The low‑level code that runs directly on the microcontroller to control hardware functions.

Skills, tools & extensions 12 lessons ↗

Concepts

skill: A reusable capability you give an agent: a folder with a SKILL.md the agent loads only when a task matches, so specialised know-how does not clutter every session.
Agent Skills: The open standard for the skill format (a folder + SKILL.md). It began at Anthropic and is read by many tools, so one skill works across them.
slash command: A saved prompt you invoke by name (e.g. /review) instead of retyping it — a shortcut, not loaded-on-demand like a skill.
subagent: A helper agent that runs in its own isolated context, so noisy or parallel work does not crowd your main conversation; it returns just a summary.
MCP: Model Context Protocol — the open standard for connecting an agent to external systems (GitHub, a database, your calendar) so it can read real data and act.
MCP server: A small program that exposes one external system over MCP; you connect it to your agent to give it that tool.
hook: A script that fires automatically on an event (e.g. after every file edit) — for things that should happen without you asking.
progressive disclosure: How agents keep many skills cheap: at startup they read only each skill name and description, and load the full instructions only when a task needs them.

Files & config

SKILL.md: The one required file in a skill: YAML frontmatter (a name and a description) followed by Markdown instructions the agent follows.
frontmatter: The small block of metadata at the top of a SKILL.md (between --- lines) giving the skill its name and description.
description: The one-line summary in a skill's frontmatter that tells the agent WHEN to use the skill — the single most important line to get right.
.claude/commands/: The folder where Claude Code reads project slash commands — one Markdown file per command, checked into git so the team shares them.

Private AI for your org: buy, build & govern 15 lessons ↗

Concepts

SaaS: Software‑as‑a‑Service means you use an application that runs on the provider’s servers instead of installing it yourself.
EU‑based AI SaaS: An AI service hosted in Europe, which helps meet European data‑protection rules.

Documents

Data Processing Agreement (DPA): A legal contract that spells out how a vendor will handle personal data on behalf of the organization that owns it.
AVV: Another name for a Data Processing Agreement used in German‑language contracts.

Regulations

GDPR: The European Union law that sets rules for protecting personal data of people in the EU.
AI Act: A proposed EU regulation that will set safety and transparency standards for AI systems.

Roles

data controller: The person or organization that decides why and how personal data is processed.
processor: A party that processes personal data on behalf of the data controller, following their instructions.

Certifications

ISO 27001: An international certification showing a company follows recognized information‑security management practices.
SOC 2 Type II: A report that verifies a service provider’s controls for security, availability, and privacy over time.

Tools

Open WebUI: An open‑source web interface you can install to talk with an AI model on your own server.
Ollama: Software that lets you run local AI models on a machine, often used together with Open WebUI.
vLLM: A fast engine for serving large language models locally or in the cloud.

Infrastructure

GPU server: A computer equipped with graphics‑processing units that accelerate AI model calculations.

Features

audit logs: Records that show who accessed data, what they did, and when it happened, useful for compliance checks.

Claude Cowork 9 lessons ↗

Concepts

Claude Cowork: Claude's "Tasks" mode in the desktop app — a third way to use Claude (alongside Chat and Claude Code) where it works on its own across your files and apps to hand back a finished deliverable, no terminal needed.
Tasks mode: The part of the Claude Desktop app where you hand Claude a whole job to complete autonomously, instead of chatting one turn at a time.
agentic: Describes AI that plans and carries out a multi-step job itself — opening files, using apps, checking its work — rather than just answering a single prompt.
deliverable: The finished output Cowork returns — a report, spreadsheet, or deck — not just a chat reply.
Claude Code: Claude's terminal-based coding agent; Cowork is its no-terminal sibling, aimed at non-technical knowledge work.

How it works

plan-then-work: Cowork first shows a step-by-step plan for you to review and approve, then executes it — so you stay in control before it touches anything.
job-function plugin: A prepackaged skill set for a role (Finance, Sales, Support, Bio-Research…) that gives Cowork the context and steps for that kind of work.
scheduled task: A Cowork job set to run automatically on a schedule (e.g. a Monday-morning report) instead of you starting it each time.
Claude Desktop: Anthropic's desktop app for Mac and Windows that hosts Chat, Claude Code, and Cowork in one place.

Dify 18 lessons ↗

Concepts

Chatbot: The simplest Dify application type — you give it a model and a prompt, and users interact with it through a back-and-forth chat interface without needing tool calls or a multi-step workflow.
Agent: A Dify application type where the AI can reason, decompose tasks, and call tools on its own without you having to pre-define every step.
Workflow: A Dify application type that chains multiple steps (nodes) together in a visual diagram; it runs once from start to finish, taking input and returning a result through a fixed, repeatable process.
Chatflow: A Dify application type that combines a workflow's structured steps with a conversational chat interface, so each user message triggers the full node chain before a response is returned.
Node: A single building block inside a Dify workflow — each node does one job (call an LLM, run code, retrieve from a knowledge base, etc.) and passes its result to the next node.
RAG: Retrieval-Augmented Generation — a technique where the AI looks up relevant passages from your knowledge base and uses them to write a more accurate, grounded answer.
Chunking: The process of splitting an uploaded document into smaller pieces so each piece can be independently searched and retrieved by the AI.
Embedding: A way of converting text into numbers (vectors) so the system can measure how similar two pieces of text are — used internally when searching a knowledge base.
ReAct: An agent strategy available in Dify that guides the model through explicit Thought → Action → Observation cycles, useful for models that lack native function-calling support.
System Prompt: Hidden instructions you write once that shape how the AI behaves in every conversation — setting its persona, tone, and rules before any user message arrives.
Variable: A named placeholder in a Dify prompt or workflow that gets filled in at run-time — either from user input or from the output of an earlier node.
Tool: A specific action an Agent or workflow node can call — such as searching the web, running a calculation, or querying an API — to get information or take action beyond text generation.
API Key: A secret credential you enter in Dify when connecting a model provider or external service — it authenticates your workspace so the service accepts requests from your application.

Features

LLM Node: A workflow node that sends a prompt to a language model — supporting text, images, and documents — and returns the model's output as a variable the rest of the workflow can use.
Knowledge Base: A repository of documents you upload to Dify so the AI can search and retrieve relevant passages when answering questions, rather than relying only on its training data.
Reranking: A second sorting pass that takes the initial search results from a knowledge base and re-orders them by relevance using a scoring model so the best chunks reach the AI first.
Annotation: A hand-curated question-and-answer pair you save in Dify so the app returns your exact pre-written response whenever a sufficiently similar question appears, bypassing the LLM entirely.
Plugin: A modular component you install in your Dify workspace to extend it with new model providers, tools, or external integrations — usable across all apps in that workspace.

Gemini 18 lessons ↗

Concepts

Gemini: Google's personal AI assistant that can answer questions, write text, analyze files, generate images and videos, and connect with Google apps like Gmail and Drive.
prompt: The message or question you type to Gemini to tell it what you want it to do.
context window: The maximum amount of text, files, and conversation history Gemini can read and hold at one time — like its working memory for a single session.
multimodal: Gemini's ability to work with multiple types of content at once — text, images, audio, video, and documents — all in the same conversation.
token: A small chunk of text (roughly a word or part of a word) that Gemini uses to measure how much it has read or generated; larger context windows allow more tokens.
Google AI Pro: A paid subscription tier for Gemini that gives 4× higher usage limits and a 1-million-token context window (supporting up to 1,500 pages of text).
Google AI Ultra: The highest Gemini subscription tier, offering the largest usage allowances and exclusive access to features such as Deep Think and enhanced Deep Research visuals.
NotebookLM: A separate Google AI tool focused on document research; Gemini's Notebook feature is integrated with it, so sources and changes sync automatically between both products.

Features

Deep Research: A Gemini feature that automatically searches many sources, spends roughly 5–10 minutes analyzing them, and produces a detailed written report on any topic you ask about.
Deep Think: An advanced reasoning mode exclusive to Google AI Ultra subscribers where Gemini takes extra time to reason through complex or difficult problems before responding.
Gems: Custom AI assistants you build inside Gemini by giving it a name, specific instructions, and optional reference files, so it always behaves like a specialist for a particular task.
Canvas: A side-by-side workspace in Gemini where you can collaboratively create and edit documents, code, slides, apps, and more while chatting with the AI in real time.
Gemini Live: A feature that lets you have a natural, back-and-forth spoken conversation with Gemini using your voice, and optionally share your camera feed so it can see what you see.
Audio Overview: A podcast-style audio conversation that Gemini generates from a document, research report, or notebook so you can listen to the content instead of reading it.
Notebook: A dedicated project space in Gemini where you upload sources (PDFs, Drive files, websites, etc.) and have ongoing conversations that always remember your documents and past discussions.
Connected Apps: Google services (such as Gmail, Drive, Calendar, and Tasks) that you can link to Gemini so it can search your real emails, documents, and events when you ask questions.
Memory: An optional setting where Gemini learns details from your past conversations and uses that context to give more personalized answers in future sessions.
Imagen: Google's AI image-generation model, available inside Gemini, that creates photorealistic or illustrated images from a text description you provide.

Groq 13 lessons ↗

Files & config

.mp3: A common compressed audio file format; Groq's speech-to-text API accepts .mp3 files for transcription.
.wav: An uncompressed audio file format that stores raw sound data; Groq's speech-to-text API accepts .wav files for transcription.
base_url: A setting in the OpenAI Python client that tells it which server to send requests to; changing it to a Groq or other compatible endpoint lets you swap providers without rewriting your code.
api_key: A secret password-like string you get from an AI provider's dashboard; you pass it when connecting so the service knows who you are and can bill you correctly.
base_url: The openai SDK parameter pointed at Groq's endpoint so an OpenAI-compatible script runs on Groq by changing only this one value.
api_key: The credential, created in the Groq console, that authorises your requests; passed to the client so your script can call the API.

Models

whisper-large-v3: OpenAI's Whisper speech-recognition model (large version 3), hosted on Groq to convert spoken audio into text at high speed; supports formats including mp3, wav, flac, m4a, ogg, and webm.
llama-3.3-70b-versatile: Meta's Llama 3.3 model with 70 billion parameters, available on Groq for general-purpose tasks; runs at ~280 tokens per second and supports a 131,072-token context window.
llama-3.1-8b-instant: Meta's smaller Llama 3.1 model with 8 billion parameters, available on Groq for fast, low-cost responses; runs at ~560 tokens per second with a 131,072-token context window.
whisper-large-v3: The Groq-hosted OpenAI Whisper model used for speech-to-text; named in the model field of a transcription request and returns results almost instantly.
llama-3.3-70b-versatile: A larger, more capable Llama model on Groq, chosen in the model field when you need stronger reasoning rather than maximum speed.
llama-3.1-8b-instant: A small, fast Llama model on Groq suited to high-volume tasks where speed and a higher request cap matter more than reasoning depth.

Commands

pip install openai: A shell command that downloads and installs the official OpenAI Python library, which you can also use to talk to Groq because Groq's API follows the same format.

Cerebras 24 lessons ↗

Concepts

Cerebras Inference API: Cerebras's cloud service that lets you send text to an AI model and receive a response, accessed by sending HTTP requests to api.cerebras.ai/v1.
CEREBRAS_API_KEY: A secret password-like string you get from Cerebras that proves your identity every time your code calls the API.
tokens per second: A measure of how fast the AI generates text — one token is roughly one word or word-piece, so 3,000 tokens/second means about 2,000 words generated every second.
Time to First Token: How long you wait from sending your request until the very first word of the answer appears; shorter is better for real-time, interactive applications.
reasoning tokens: Internal thinking text the model generates before its final answer; depending on the reasoning_format setting they may appear in the response or be hidden, but they always count toward your token usage.
JSONL: A plain-text file format where each line is a separate, valid JSON object — used to package many requests into one file for batch processing.
shared endpoint: The standard public API where many customers share the same hardware; easier to get started with but performance may vary under high demand.
OpenAI compatibility: Cerebras's API speaks the same language as OpenAI's API, so code written for OpenAI can be redirected to Cerebras by changing just the base URL and API key.
base_url: The web address your code sends requests to; for Cerebras it is https://api.cerebras.ai/v1, and changing this is how you switch from the OpenAI SDK to Cerebras.
RAG: Retrieval-Augmented Generation — a pattern where your application fetches relevant documents from a database and adds them to the prompt so the model can answer questions about your own data.
agentic workflow: A design where the AI autonomously takes multiple steps — calling tools, browsing data, making decisions — to complete a goal rather than answering a single question.

Models

gpt-oss-120b: OpenAI's 120-billion-parameter open-source model hosted on Cerebras hardware, capable of generating roughly 3,000 tokens per second.
zai-glm-4.7: A Mixture-of-Experts model from Z.ai with approximately 355 billion total parameters (32 billion active per token), available on Cerebras at around 1,000 tokens per second.

Features

streaming: A mode where the model sends its answer word-by-word as it is generated, so you can display text to the user progressively instead of waiting for the full response.
structured outputs: A feature that forces the model's response to match a JSON schema you define, so your code always receives data in a predictable, machine-readable shape.
JSON mode: A looser version of structured outputs that guarantees the response will be valid JSON but does not enforce a specific field structure.
reasoning_effort: An API parameter that tells the model how much thinking to perform before answering — options are low, medium, or high, trading speed for thoroughness.
prompt caching: A feature that reuses the processed results of repeated prompt prefixes — like a shared system prompt — so subsequent calls with the same opening are faster.
prompt_cache_key: An optional routing hint you attach to a request so that related requests (such as turns in the same conversation) are directed to the same cache, reducing latency.
predicted outputs: A feature where you supply the text you expect the model to produce; the model skips regenerating tokens that already match your prediction, speeding up the response.
Batch API: A service for submitting up to 50,000 AI requests at once as a JSONL file, letting them process in the background (guaranteed within 24 hours) and collecting all results when done.
dedicated endpoint: A private, reserved slice of Cerebras infrastructure for your organisation alone, offering guaranteed throughput and advanced features like fine-tuning, custom model weights, and the Priority service tier.
service tier: A setting on each API request that controls processing priority — Priority (dedicated endpoints only) is highest, Default is standard, Auto uses the highest available tier, and Flex is lowest-priority for non-urgent tasks.
tool calling: A feature where you describe external functions (like a search engine or calculator) to the model, and it can request that your code run one of them mid-conversation to gather information.

Hermes 36 lessons ↗

Commands

hermes setup: First-run wizard — it asks which model provider to use and writes your config file.
hermes setup --portal: Set up Hermes using a managed Nous Portal model, so you skip picking your own provider and key.
hermes --tui: Start Hermes in its modern text UI (a full-screen terminal interface).
hermes --continue: Reopen Hermes where you left off — it reloads your last session.
hermes doctor: Health check — verifies your config, model connection and tools, and reports what is wrong.
hermes model: Choose or switch the model (the "brain") Hermes runs on.
hermes gateway setup: Connect chat apps (Telegram, Signal, Slack…) so you can message your agent.
hermes gateway status: Check whether your connected chat apps are reachable.
hermes sessions list: List your saved conversations.

Slash commands

/skills pending: List skills the agent has staged and is waiting for you to review.
/skills diff: Show exactly what a proposed skill would add or change before you accept it.
/skills approve: Accept a staged skill so the agent can reuse it.
/skills reject: Discard a staged skill you do not want.

Files & config

~/.hermes/config.yaml: Hermes’s main settings file — which provider, model and server it uses. The ~ means your home folder.
~/.hermes/.env: A hidden file holding secrets like API keys, kept out of the main config.
provider: custom: A config setting that points Hermes at any OpenAI-compatible server — used for local models.
base_url: The web address of the model server Hermes talks to (e.g. a local LM Studio server).
OPENAI_API_KEY: The environment variable holding your model key. Local servers ignore it; cloud providers require a real one.
SKILL.md: A saved skill — a short file describing a procedure the agent learned once and can repeat.
config.yaml: Hermes’s settings file (full path ~/.hermes/config.yaml).

Install

curl: A command-line tool that downloads from a web address — here it fetches the install script.
bash: The standard Linux/macOS shell — it runs the downloaded install script.
iex: PowerShell’s Invoke-Expression — runs the text it is given as a command (Windows install).
irm: PowerShell’s Invoke-RestMethod — downloads from a web address (Windows install).
source ~/.bashrc: Reload your shell’s settings so a newly installed command is found without reopening the terminal.
.dmg: A macOS installer file — double-click it to install an app.
.exe: A Windows installer/program file — double-click it to install or run.

Concepts

CLI: Command-line interface — you type commands in a terminal instead of clicking.
TUI: Text user interface — a richer, full-screen terminal app (menus and panels, still keyboard-driven).
LM Studio: A free desktop app that runs AI models on your own computer and exposes an OpenAI-compatible server.
cron: A scheduler for recurring tasks — e.g. "every weekday at 8am".
token: A chunk of text (~¾ of a word) the model reads or writes; context limits are measured in tokens.
context: How much text the model can consider at once. Hermes needs a model with at least ~64k tokens of context.
localhost: Your own computer, as an address — localhost:1234 is a server running on this machine, port 1234.
gateway: The part of Hermes that connects your chat apps (Telegram, Slack…) to the agent.
artifacts: Everything the agent produced or touched in a session — files, links, images — your record of what it did.

Antigravity 18 lessons ↗

Concepts

Antigravity: Google's standalone desktop application for AI-assisted software development, where one or more AI agents autonomously plan, write, and test code on your behalf.
Antigravity CLI: A command-line version of Antigravity that lets you run agents directly from your terminal without opening the desktop app.
Antigravity SDK: A set of developer tools that lets you embed Antigravity's agent capabilities inside your own programs or infrastructure.
Agent: An AI process that Antigravity launches to carry out a task — it can read files, run code, browse the web, and make changes autonomously.
Artifacts: Structured outputs an agent produces — such as task lists, implementation plans, code diffs, screenshots, and walkthroughs — so you can review what it did before accepting the changes.
Skills: Packaged instruction files that teach an agent how to handle a specific kind of task; you can add them globally or per project.
Review-Driven Development: An Antigravity mode where the agent works independently but pauses at important steps so you can approve or reject significant changes before they are applied.
Project: A folder (or set of folders) you open in Antigravity that defines the workspace boundary — the files, tools, and permissions the agent is allowed to use.
Conversation: A message thread inside a project where you type instructions to the agent and see its replies; one project can contain many conversations.
MCP: Model Context Protocol — a standard way to connect external tools (databases, APIs, services) to an agent so it can use them during a task.

Features

Manager Surface: The part of the Antigravity interface where you can launch, watch, and control several agents running different tasks at the same time.
Editor View: The traditional code-editor side of Antigravity, which supports AI tab-completions and inline commands for developers who prefer a hands-on coding style.
Plan mode: An agent mode where the agent first produces a written implementation plan for you to inspect and approve before it starts making any changes to your code.
Fast mode: An agent mode for small, single-step tasks where the agent acts immediately without stopping to show a plan first.

Slash commands

/browser: A slash command that tells the agent to open a real web browser and carry out a web-based action you describe.
/schedule: A slash command that sets up a task to run automatically at a fixed time or on a repeating schedule, without you having to start it manually.

Models

Gemini 3.5 Flash: The default AI model powering Antigravity agents — Google describes it as four times faster than frontier models while outperforming them on most coding and agentic benchmarks.

Files & config

SKILL.md: The required file inside a Skills package that contains both YAML metadata (so the agent knows when to load the skill) and Markdown instructions (telling it what to do).

Lovable 22 lessons ↗

Concepts

Build mode: Lovable's implementation mode where agents write code, apply changes across files, and verify results.
Plan mode: Lovable's reasoning mode for exploring ideas, comparing approaches, and reviewing plans without modifying any code.
Prompt: A plain-English instruction you type to tell Lovable what to create, change, fix, or explain in your app.
Prompt queue: A queue of pending prompts you can reorder, edit, copy, or remove before Lovable processes them.
Diff: A side-by-side file change comparison showing exactly which lines were added or removed by Lovable.
Knowledge: Persistent instructions you write once that Lovable follows across all future conversations, available at both workspace and project level.
Lovable Cloud: Lovable's built-in full-stack platform that provides a database, user authentication, file storage, and edge functions without any manual setup.
Secrets: Securely stored credentials (API keys and passwords) that are automatically injected into your edge functions so they never appear in your code.
Credits: The units Lovable uses to measure usage — both Plan mode messages and Build mode runs consume credits from your workspace's shared balance.
Workspace: The top-level container that holds all your projects, team members, billing, and settings for one account or organisation.
Project: A single app you are building inside Lovable, with its own code, chat history, integrations, and settings.
Subagents: Temporary, read-only helper agents Lovable spins up to research, inspect code, and browse the web in parallel before the main agent makes changes.
Edge functions: Serverless TypeScript functions that run on Lovable Cloud and handle backend tasks such as APIs, webhooks, and third-party integrations.

Features

Preview: The live, interactive view of your app shown inside Lovable while you are building, so you can see changes as they happen.
Preview toolbar: An overlay above the preview that lets you select any element, edit text directly, add annotations, and leave comments.
Visible tasks: The step-by-step progress shown in the chat during a build, displaying the current step, files being modified, and tools being used.
History: The chronological log of every change made to your project, letting you revert to any earlier version or save a checkpoint.
Remix: A way to create an independent copy of a project as the starting point for a brand-new project, preserving the original.
Publish: The action that deploys a snapshot of your project to a live URL so others can visit and use your app.
Custom domain: A web address you own (such as myapp.com) that you connect to your published Lovable project instead of the default lovable.app URL.
GitHub integration: A two-way sync between your Lovable project and a GitHub repository so your code is version-controlled and other developers can collaborate on it.
Browser testing: A feature where Lovable controls a real browser to click buttons, fill forms, and capture screenshots to verify your app's end-to-end behaviour.

n8n 20 lessons ↗

Concepts

Workflow: A saved sequence of connected steps (nodes) that n8n runs automatically to move or transform data between apps.
Node: A single building block in a workflow — each node performs one action, such as sending an email, filtering data, or calling an API.
Trigger node: A special node that sits at the start of a workflow and decides when it runs — for example, on a schedule, when a form is submitted, or when another app sends a signal.
Action node: A node that does something in an external service — such as creating a row in Google Sheets, sending a Slack message, or reading an email.
Core node: A built-in utility node that handles data processing or flow control without connecting to an external service — examples include IF, Filter, Merge, and Code.
Connection: The arrow drawn between two nodes on the canvas that tells n8n to pass data from one node to the next when the workflow runs.
Execution: One complete run of a workflow — n8n records what happened at each node so you can inspect inputs, outputs, and any errors afterward.
Credentials: Securely stored login details (such as API keys or passwords) that let n8n connect to an external service on your behalf without exposing secrets inside the workflow.
Expression: A small piece of JavaScript written inside double curly braces ({{ }}) that lets you pull in data from a previous node or do a quick calculation instead of typing a fixed value.
Item: A single unit of data travelling through a workflow — for example, one email, one spreadsheet row, or one API result.
Data mapping: The act of telling a node where to find its input by dragging a field from a previous node's output onto the current node's input — no code required.
Manual execution: Running a workflow by clicking the Execute button yourself, used for testing before you switch the workflow on for automatic production runs.

Features

Canvas: The visual drag-and-drop workspace inside n8n where you build a workflow by placing and connecting nodes.
Webhook: A URL that n8n creates for you so that an outside app can instantly start your workflow by sending data to that address.
Schedule trigger: A trigger node that starts a workflow automatically at a set time or repeating interval, similar to a calendar alarm.
IF node: A core node that checks a condition and sends each data item down one of two paths — True or False — so different actions can happen depending on the data.
Sub-workflow: A separate workflow that another workflow calls like a reusable function, helping you keep complex automations organised and avoid repeating the same steps.
Error handling: A set of features in n8n — including dedicated error workflows and the Stop And Error node — that let you define what should happen if a node fails instead of silently stopping.
Sticky note: A text annotation you can place anywhere on the canvas to explain what part of a workflow does, without affecting how it runs.
Template: A pre-built workflow shared by the n8n community that you can import and adapt instead of building from scratch.

openclaw 4 lessons ↗

Commands

npm i -g openclaw: A terminal command that downloads and installs the OpenClaw program on your computer so you can run it from anywhere; `npm i -g` means "install globally via Node Package Manager".
openclaw onboard: The guided first-run setup wizard for OpenClaw that walks you step by step through connecting your AI model, configuring your gateway, linking chat channels (WhatsApp, Telegram, etc.), and optionally installing OpenClaw as a background service.

Concepts

local model: An AI model that runs entirely on your own machine, keeping all conversation data private because nothing is sent to a cloud API.
skills: Add-on capabilities you install (e.g. from clawhub.ai) that extend OpenClaw to work with external services such as Gmail or GitHub.

opencode 27 lessons ↗

Concepts

opencode: An open-source AI coding agent that runs in your terminal (or as a desktop app or IDE extension) and helps you read, write, and change code by chatting with a large language model.
TUI: Terminal User Interface — the interactive chat screen you see when you launch opencode in your terminal, where you type messages and watch the AI respond.
provider: A company that supplies the AI model opencode talks to (for example Anthropic, OpenAI, or Google); you configure your API key for each provider you want to use.
model: The specific AI brain opencode uses to answer your questions and write code (for example claude-sonnet-4-5 or gpt-4o); you can switch models mid-session.
agent: A named AI assistant profile in opencode with its own set of instructions, permitted tools, and optionally a specific model — for example a 'Plan' agent that cannot edit files.
subagent: A specialist agent that a primary agent can invoke automatically to handle a subtask (like researching external docs); you can also invoke one manually by typing @agentname in your message.
skill: A reusable instruction set stored in a SKILL.md file that agents can load on demand, like a reference manual the AI can consult for a specific topic or workflow.
MCP server: An external tool server that connects to opencode via the Model Context Protocol, giving the AI access to additional capabilities such as searching documentation or querying a database.
session: One continuous conversation with opencode, including all your messages, the AI's replies, and any file changes made during that exchange.
permission: A setting that controls whether opencode can use a particular tool automatically (allow), must ask you first (ask), or is blocked from using it entirely (deny).
LSP: Language Server Protocol — a standard opencode uses to connect to language servers and receive diagnostics (errors, warnings) as feedback that helps the AI detect and fix code issues.

Features

Plan mode: A built-in primary agent (switched to with the Tab key) where opencode is restricted from making file changes, so it analyses and describes how it would approach a task without touching your code.
Build mode: The default primary agent where opencode has full permission to read, write, and edit files in your project.
OpenCode Zen: A paid AI model gateway maintained by the opencode team that offers a curated set of tested and verified models on a pay-as-you-go basis, so you can access quality-checked models without setting up separate provider accounts.
snapshot: A save-point opencode automatically tracks as the AI makes file changes, used by the undo system to restore your code if you want to reverse the AI's edits.
compaction: The process of automatically summarising older parts of a conversation to keep the context window from filling up, helping the AI remain accurate on long tasks.

Files & config

AGENTS.md: A plain-text file you place in your project folder (or home config folder) that gives the AI standing instructions about your project's structure, coding conventions, and quirks.
opencode.json: The main configuration file for opencode where you set your preferred model, provider API keys, tool permissions, and other project-level settings.

Slash commands

/init: A slash command that scans your project and automatically generates an AGENTS.md file with a summary of the codebase structure and build instructions.
/undo: A slash command that removes your last message, the AI's response, and any file changes made during that exchange, letting you rephrase and try again.
/redo: A slash command that re-applies a change you previously undid.
/share: A slash command that generates a shareable public web link to your current conversation so teammates can review the chat without needing opencode installed.
/compact: A slash command that summarises the current conversation to reduce context size, useful when a long session is making responses slower or less focused.
/new: A slash command that starts a fresh session, clearing the conversation history so you can begin a new task with a clean slate.
/models: A slash command that lists all AI models available to you through your configured providers.
/sessions: A slash command that shows your previous conversations so you can switch back to an earlier session and continue where you left off.
/thinking: A slash command that toggles the display of the model's reasoning blocks, letting you see the thinking the AI showed before answering — it controls visibility only, not whether the model reasons.

opencode + voice 10 lessons ↗

Tool

opencode-voice: The name of the tool that provides local speech‑to‑text and text‑to‑speech functionality.

Files

index.js: A JavaScript file produced when you compile the plugin, which can be run by Node to activate the voice features.
repository: The online folder (often on a platform like GitHub) that holds the source code you clone to build the plugin.

Dependencies

Node packages: Software libraries installed with the npm command that the plugin needs to work.
dependencies: External code packages required by the plugin, listed so they can be installed automatically.

Backend

Piper: An open‑source text‑to‑speech service that the plugin can call over HTTP to generate speech using only the CPU.
HTTP TTS API: A web interface that accepts text via an HTTP request and returns spoken audio, used by the plugin to produce speech.

Components

plugin: A small add‑on you build and run locally to give opencode-voice its voice capabilities.
open-source repos: Publicly available code collections that anyone can view and modify, which provide parts of the voice layer.

Resources

compute: The processing power of your computer’s CPU or GPU that runs the voice software.

jcode 12

Commands

rustup: The installer and manager for the Rust programming language toolchain.
cargo build --release: A command that compiles the Rust project into an optimized binary placed in the target/release folder.
webhook: An automatic HTTP request sent by jcode to a specified address when an event like a file edit occurs.
diff: A display of line‑by‑line changes between two versions of a file, often shown by the git diff command.
dry-run: An option that runs a command without making permanent changes, used here to test startup time only.
curl: A command‑line tool that downloads data from a URL, used here to fetch and install J Code in one step.

Files

PATH: An environment variable that tells the operating system where to look for executable files.
EXE: A Windows executable file that can be run directly from the terminal or double‑clicked.

Concepts

vector embedding: A high‑dimensional numeric representation of text used to compare similarity between pieces of conversation.
cosine similarity: A mathematical measure that scores how close two vectors are, with higher values meaning more similar content.
API key: A secret token you paste into JCode after /login so it can call an external AI service on your behalf.
ambient mode: A background process that periodically re‑indexes stored vectors and removes low‑relevance entries to keep memory fresh.

OpenRouter 12 lessons ↗

API Endpoints

/api/v1/chat/completions: The OpenRouter API endpoint you send your message to — it receives your request, routes it to the chosen AI model, and returns the reply.
https://openrouter.ai/api/v1/models: A public OpenRouter URL that returns a JSON list of every available model, including its ID, pricing, context length, and supported features.

Flags & Variants

:free: A suffix you append to a model ID (e.g. meta-llama/llama-3.2-3b-instruct:free) to select the no-cost variant of that model; free variants have low daily rate limits and are intended for experimentation.

Models

google/gemma-4-31b-it:free: An example OpenRouter model ID showing the standard format: provider name, a slash, the model name, and the :free variant suffix to use it at no cost.
anthropic/claude-fable-5: An OpenRouter model ID for Anthropic's Claude Fable 5, a high-capability model designed for long-running, autonomous coding and knowledge-work tasks.

API Response

choices[0].message.content: The path inside the API's JSON response where the model's actual text reply is stored — choices is an array, [0] picks the first (usually only) result, and .content holds the message text.

Concepts

POST: An HTTP method that sends data to a server; when calling the OpenRouter API you POST your request (model choice, messages, settings) as a JSON body.

Headers

Authorization: Bearer YOUR_KEY: An HTTP request header that proves your identity to OpenRouter — replace YOUR_KEY with your actual API key so the server knows who is making the request.
Content-Type: application/json: An HTTP request header that tells the server your request body is formatted as JSON, which is required when calling the OpenRouter chat completions endpoint.

Libraries

openai: The name of the official OpenAI Python package; because OpenRouter uses the same API format as OpenAI, you can install this package and point it at OpenRouter instead, saving you from learning a separate library.

Commands

pip install openai: A terminal command that downloads and installs the OpenAI Python package onto your computer so you can use it in your code.

API Request Fields

model: A key in the JSON request body that tells OpenRouter which AI model to use for your request, specified as a provider/model-name string such as google/gemma-4-31b-it:free.

Perplexity 19 lessons ↗

Concepts

Answer Engine: What Perplexity calls itself — instead of returning a list of links like a search engine, it reads the web in real time and writes a direct answer with cited sources.
Thread: A single conversation in Perplexity where each follow-up question keeps the context from previous turns, so you never have to repeat yourself.
Citations: Numbered source links that appear inline in every Perplexity answer so you can click through and verify the original web page or paper.
Sonar: Perplexity's own family of AI models, optimised for fast, accurate web-grounded answers; the base Sonar model is the default search model, while Sonar Pro and Sonar Deep Research handle progressively more complex tasks.
Perplexity Pro: The paid subscription tier (around $20/month) that unlocks unlimited Pro Search, Deep Research, file uploads, model selection, and API credits.
Perplexity Max: A higher-tier subscription above Pro that adds features like Model Council, priority access to new models, and additional advanced capabilities.
Sonar API: A developer interface that lets programmers embed Perplexity's web-grounded search capability into their own applications, using the same request format as the OpenAI API.

Features

Focus: A filter you apply before searching that tells Perplexity which part of the web to look in — for example Academic restricts results to peer-reviewed papers, Social searches Reddit and forums, and Video pulls from YouTube content.
Pro Search: A deeper search mode that breaks your question into multiple sub-queries, consults more sources, and synthesizes a more thorough answer than the default Quick Search.
Quick Search: The default, faster search mode suited for simple factual questions where a brief answer with a few sources is enough.
Deep Research: An autonomous research mode that spends several minutes performing dozens of searches across hundreds of sources and produces a structured, multi-section report — equivalent to asking a research analyst to investigate a topic for you.
Spaces: Collaborative workspaces inside Perplexity where you can group related threads, write custom instructions that apply to every search, and invite teammates to contribute.
Pages: A publishing feature that turns any Perplexity research thread into a formatted, shareable article with a public URL you can distribute or embed.
Connectors: Integrations that link Perplexity to your external apps — such as Gmail, Slack, Notion, or Google Drive — so it can pull live data from those tools into its answers.
Model Council: A premium feature that runs your query through three AI models simultaneously, then uses a fourth 'chair' model to synthesize their responses into one combined answer — available to Max subscribers.
Scheduled Searches: Automated queries you set up once that Perplexity re-runs on a daily, weekly, or monthly schedule and delivers to you as a notification.
File Upload: A feature that lets you attach PDFs, spreadsheets, images, or documents to a conversation so Perplexity can read and answer questions about their contents; free users get a daily limit, while Pro unlocks unlimited uploads.
Comet: An AI-native web browser made by Perplexity, built on Chromium, with a built-in assistant for summarising pages and automating multi-step browsing tasks, available on desktop and mobile.
Voice Mode: A conversational interface that lets you speak your questions aloud and hear Perplexity's answers spoken back, using a real-time speech model.

v0 20 lessons ↗

Concepts

Sandbox: An isolated virtual machine that hosts your project files, runs the live preview, and executes commands on your behalf — completely separate from your deployed app, so each chat gets its own environment with no state leaking between them.
Live preview: A real-time view of your running app inside v0's chat, served from the sandbox so what you see matches what your users will experience.
Deployment: Publishing your v0 project to Vercel so it runs at a public URL with automatic HTTPS and global CDN distribution.
Production URL: The single public web address that represents the live version of your project; the URL stays constant across all deployments so your app is always reachable at the same address.
React Server Components: A Next.js feature where parts of your page are rendered on the server before being sent to the browser, improving load speed and search-engine visibility; v0 uses Next.js, which enables these by default.
Server actions: Functions that run on the server rather than in the browser, used in v0's Next.js projects to handle form submissions, database writes, and other backend tasks.
Environment variables: Secret configuration values (like API keys) stored outside your code and managed through your connected Vercel project, so sensitive credentials are not hard-coded or publicly visible.
NEXT_PUBLIC_: A required prefix for environment variable names in Next.js when the value needs to be accessible in the browser; without it, the variable is available on the server only.
Vercel: The cloud hosting platform that v0 is built on; it handles deploying your app, managing your domain, and distributing it globally — and your v0 account is a Vercel account.
Agentic features: Autonomous capabilities where v0 plans and carries out multi-step tasks on its own — such as running terminal commands, searching the web, fixing errors, and calling external integrations — without you directing every step.

Features

Design Mode: A visual editing tool in v0 that lets you click any element in the live preview and adjust its appearance using a style panel or natural-language instructions, without writing code directly.
Connect panel: The v0 interface where you link external services — databases, AI models, and other integrations — to your project.
Versions: A saved snapshot of your project's code created each time v0 updates a code block in response to a message; you can review, compare, or restore any earlier version.
Duplicate: Creating your own copy of a shared v0 chat so you can make changes without affecting the original, with the option to keep it linked to the same Vercel project.
Unlisted: A sharing setting where anyone with the link can view your project, but it will not be indexed by search engines or appear in public galleries.
Templates: Published v0 chats you can fork as a starting point, giving you a working app structure to customise instead of starting from a blank prompt.
MCP integrations: Connections to external tools and data sources (such as databases, APIs, and services like Stripe or Neon) that v0's AI automatically considers when generating responses, allowing it to incorporate real external context.
Figma integration: A v0 feature that lets you attach a Figma link and have v0 convert the design — including layout, colors, and spacing — into working code.
GitHub integration: A v0 connection that automatically commits every code change to a dedicated branch in your GitHub repository and lets you open a pull request to merge it into main.
Custom domain: A web address you own (like myapp.com) that you can attach to your deployed v0 project instead of using the default Vercel URL.

Codex 22 lessons ↗

Commands

codex: The OpenAI Codex CLI tool — a lightweight AI coding agent you run in your terminal that can read files, write code, and execute commands on your behalf.
codex exec: Runs Codex non-interactively from the command line, streams results to your terminal or a file, and exits when the task is done — useful for scripting or automation.
codex mcp: A Codex subcommand that manages connections to Model Context Protocol servers, which let Codex reach external tools and data sources beyond your local files.

Flags

-i: Short for --image; attaches one or more image files to your prompt so Codex can see screenshots, diagrams, or other visuals when answering.
--image: Attaches one or more image files to your prompt so Codex can see screenshots, diagrams, or other visuals when answering.
-m: Short for --model; lets you choose which AI model Codex uses for a session (e.g., codex -m gpt-5.5).
--json: Makes Codex print its output as newline-delimited JSON events instead of formatted text — useful when another program needs to read the results.
--output-schema: Points Codex to a JSON Schema file; Codex validates its final response against that schema before finishing, ensuring the output has the exact shape your code expects.
-o <path>: Short for --output-last-message; writes the assistant's final reply to a file at the given path, making it easy to pipe results into other scripts.

Slash commands

/model: An interactive slash command that lets you switch the AI model Codex is using mid-session without restarting.
/permissions: An interactive slash command that sets what Codex is allowed to do without asking first — adjusting the approval threshold for the current session.

Files & config

~/.codex/config.toml: The main user-level configuration file for Codex, stored in your home directory, where you set durable defaults like model, MCP servers, and feature flags.
~/.codex/AGENTS.md: A personal instructions file Codex reads before every session — write it in plain English to tell Codex about your preferences, coding style, or recurring context.
.git: A hidden folder Git creates inside every repository to store the project's full version history and configuration — its presence tells tools (including Codex) that the folder is a Git repo.

Concepts

workspace-write: A sandbox mode that lets Codex read and edit files inside your current project folder, but blocks it from writing elsewhere on your computer or accessing the network.
untrusted: An approval policy that lets Codex run commands it recognises as safe automatically but stops and asks you before running anything outside its trusted set.
on-request: An approval policy that lets Codex work freely within its sandbox but pauses to ask for your permission whenever it needs to go beyond those boundaries.
never: An approval policy that lets Codex act fully autonomously without asking for permission — it still respects the sandbox limits, but never pauses for human approval.
npm test: A standard command that runs the automated tests defined for a JavaScript or TypeScript project — if all tests pass, the code behaves as expected.

Models

gpt-5.5: OpenAI's most capable Codex model (as of mid-2026), best for complex coding, research, and multi-step tasks — the recommended default when quality matters most.
gpt-5.4-mini: A faster, lower-cost Codex model suited for simpler or repetitive tasks where speed matters more than maximum reasoning power.
gpt-5.3-codex-spark: A text-only research-preview Codex model built for near-instant response (over 1,000 tokens per second), optimized for real-time coding iteration — available to ChatGPT Pro subscribers.

Claude 8 lessons ↗

Concepts

<context>: An XML-style tag you wrap around background information in a Claude prompt so Claude can clearly distinguish it from your instructions or question.
<task>: An XML tag recommended by Anthropic for wrapping the specific instruction you want Claude to carry out, keeping it distinct from background context in the same prompt.
<data>: An XML tag used to enclose raw data (such as a table or CSV snippet) inside a prompt so Claude can tell it apart from your instructions and context.
Artifact: A document, diagram, chart, or runnable code snippet that Claude generates in a side panel where you can refine, copy, download, or share it.
Project: A named workspace in claude.ai that holds its own documents and instructions so every chat inside it starts with shared context without re-pasting.
Memory: An optional capability where Claude builds a running summary of your role and ongoing work so new chats start already informed about you.
role: A persona or expert identity you give Claude at the start of a prompt (e.g. 'a careful biostatistics reviewer') to steer the depth and tone of its answers.
web search: A live internet lookup Claude can perform when a question needs current information, returning cited sources you can open and verify.

Ollama 34 lessons ↗

Commands

ollama run: Starts an interactive chat session with a model; if the model isn't already downloaded, Ollama downloads it automatically first.
ollama pull: Downloads a model from the Ollama library to your computer without starting a chat session.
ollama list: Shows all models you have downloaded and stored locally on your machine (the canonical short form of this command is ollama ls).
ollama ps: Lists which models are currently loaded in memory and actively running.
ollama stop: Stops a running model, unloading it from memory without removing it from your computer.
ollama rm: Permanently deletes a downloaded model from your computer to free up disk space.
ollama serve: Manually starts the Ollama background server that listens for requests; on most systems this starts automatically at login.
hermes setup: Runs the Hermes Agent interactive setup wizard that walks you through configuring all or part of your Hermes installation.
hermes --tui: Launches Hermes Agent in its terminal user interface mode instead of the classic command-line prompt interface.
systemctl edit ollama.service: Opens the Linux service configuration for Ollama so you can add environment variables (such as OLLAMA_HOST) that apply every time the server starts.

Slash commands

/bye: A slash command you type inside an Ollama chat session to end the conversation and return to your normal terminal prompt (also works as /exit).

Concepts

>>>: The prompt symbol Ollama shows when it is waiting for you to type a message inside an interactive chat session.
openai: A Python library (also the name of the company) that provides a standard way to call AI chat APIs; Ollama supports the same interface so you can use this library with local models.
pip install openai: The terminal command that installs the OpenAI Python library onto your computer so your Python scripts can call AI APIs.
api_key: A secret string that identifies who is making an API request; when using Ollama locally no real key is needed, but the library requires the field to exist.
base_url: A configuration setting that tells an API client where to send its requests; point it to http://localhost:11434/v1 to redirect OpenAI library calls to your local Ollama server.
localhost: A special hostname that always refers to your own computer, so a service at localhost is only reachable from that same machine.
"stream": false: A JSON setting in an API request that tells the model to send its entire response as one message instead of word-by-word as it generates.
ifconfig: A terminal command on Mac and Linux that displays your computer's network addresses, useful for finding the IP address other devices on your network can use to reach you.
ip addr: A terminal command on Linux (modern alternative to ifconfig) that shows all network interfaces and their IP addresses.
ipconfig: A terminal command on Windows that displays your computer's network configuration including its local IP address.

Flags

OLLAMA_HOST: An environment variable that controls which network address Ollama listens on; set it to 0.0.0.0:11434 to allow other computers on your local network to connect.
OLLAMA_KEEP_ALIVE: An environment variable that sets how long a model stays loaded in memory after its last use; the default is 5 minutes, but you can set values like 24h to keep it loaded longer.

Files & config

http://localhost:11434: The default web address where Ollama's API server runs on your own computer, reachable only from that same machine.
/api/chat: Ollama's built-in REST API endpoint for sending chat messages and receiving model responses programmatically.
/v1/: The URL prefix for Ollama's OpenAI-compatible API, which lets software written for OpenAI's API talk to your local Ollama models instead.
~/.hermes/config.yaml: The main configuration file for Hermes Agent, stored in a hidden folder in your home directory, where you set the model provider, base URL, and other non-secret preferences.
~/.hermes/.env: A file in your Hermes Agent folder that stores secret values such as API keys, kept separate from the main config file so credentials are not accidentally shared.
provider: custom: A setting in the Hermes Agent config.yaml that tells Hermes to call a custom OpenAI-compatible endpoint directly, such as your local Ollama server, using the base_url you specify.
[Service]: A section header in a Linux systemd unit file where you place environment variable definitions that apply to the service being configured.

Models

llama3: Meta's Llama 3 open-weight language model, available through Ollama and described as the most capable openly available LLM at the time of its release.
qwen2.5: Alibaba's Qwen 2.5 open-weight language model series, available through Ollama and well-regarded for coding and mathematics tasks.
gemma: Google's open-weight language model, available through Ollama in 2B and 7B parameter sizes.
mistral: Mistral AI's 7B open-weight language model, available through Ollama and distributed under the Apache license.

LM Studio 21 lessons ↗

Commands

lms: The command-line tool bundled with LM Studio that lets you start the server, download models, and manage everything from a terminal instead of the desktop app.
lms server start: Launches LM Studio's local API server so other programs on your computer (or network) can send it requests and get AI responses back.
lms server stop: Gracefully shuts down the running LM Studio API server, terminating any in-progress requests before stopping.
lms server status: Prints whether the LM Studio API server is currently running and which port it is listening on.
lms --version: Prints the installed version number of the lms command-line tool — the actual documented subcommand is lms version, but both forms report the current CLI version.
llmster: The headless (no desktop window) daemon version of LM Studio designed for servers or machines without a screen — it runs as a standalone background service and can still serve models over the API.
hermes setup: A setup command for the Hermes AI agent that guides you through configuring your model provider, including connecting it to a local LM Studio server.
hermes --tui: Starts Hermes in its text user interface (TUI) mode — a keyboard-driven chat panel that runs entirely inside your terminal with live streaming and modal overlays.
chmod +x start-local-llm.sh: A shell command that marks a script file as executable on Mac or Linux so you can run it directly; without this step the operating system refuses to run the script.
pip install openai: The Python package-manager command that downloads and installs the OpenAI Python library, which LM Studio also accepts because it speaks the same API format.

API & URLs

http://localhost:1234/v1: The full address of LM Studio's OpenAI-compatible API server on your own machine — localhost means 'this computer', 1234 is the default port number, and /v1 is the path prefix for the OpenAI-compatible endpoints.
localhost:1234: The host and port where LM Studio's server listens by default — shorthand for 'your own machine, port 1234'.
localhost: A special hostname that always means 'this computer' — using it ensures the connection never leaves your machine.
http://<your-ip>:1234/v1: The address other devices on your local network use to reach your LM Studio server — replace <your-ip> with your computer's actual network IP address (e.g. 192.168.1.5).
0.0.0.0: A special network address meaning 'listen on all network interfaces' — when LM Studio binds to this (via lms server start --bind 0.0.0.0), devices on your local Wi-Fi or wired network can connect to it, not just your own computer.

Libraries & Code

openai: The name of a Python library originally made for OpenAI's cloud API; LM Studio intentionally speaks the same format, so you can reuse this library to talk to your local models instead.
api_key: A configuration field where you provide a password or token to authenticate with an API; LM Studio does not require a real key by default, but the field must still be present (any placeholder string works).
base_url: A configuration field that tells a client library where the API server lives — for LM Studio you set this to your local server address instead of OpenAI's cloud address.

Files & Config

config.yaml: A plain-text configuration file written in YAML format — tools like Hermes read this file at startup to know which server URL, model, and preferences to use.
~/.hermes/config.yaml: The main configuration file for the Hermes tool, stored in a hidden folder in your home directory — you edit it to point Hermes at your local LM Studio server.
~/.hermes/.env: A hidden environment-variable file inside the Hermes config folder where you can store API keys and secrets separately from the main config file.

Jan 9 lessons ↗

Concepts

http://localhost:1337: A common way to write the base URL of Jan's built-in API server; Jan's docs show http://127.0.0.1:1337 as the actual default address, and localhost is simply a hostname alias for 127.0.0.1 on most computers.
localhost:1337: The host and port of Jan's local API server (shorthand without the http:// prefix); Jan's docs use 127.0.0.1:1337 as the canonical form, and you can change the port under Settings > Local API Server > Configuration.
model: A field in an API request body that tells the server which AI model to use; when talking to Jan you set this to the model ID shown in Jan's model list.
openai: A Python library originally made for OpenAI's cloud service that can also talk to any OpenAI-compatible server — including Jan's local server — using the same code.
api_key: A string you set in Jan's API server configuration that callers must include in requests; Jan accepts any string you choose, and you can also leave it empty to disable authentication entirely.

Commands

pip install openai: A shell command that downloads and installs the openai Python library onto your computer so you can import it in your scripts.
base_url: The openai SDK parameter set to Jan's local server so code written for the OpenAI API is redirected to your local model with no other changes.
curl: The command-line tool used in the lessons to send a test request to Jan's local API and confirm the server is responding.

Endpoints

http://localhost:1337/v1: The base URL of Jan's local OpenAI-compatible API server once enabled; append /chat/completions to send chat requests as you would to OpenAI.

Onyx 12 lessons ↗

Concepts

connector: A plug-and-play integration that indexes and syncs one source (Google Drive, Slack, GitHub, Confluence, Salesforce…) into Onyx, so its content becomes searchable and citable. Onyx ships 50+.
agentic RAG: Onyx's retrieval approach: instead of one search, AI agents plan and run multiple retrieval steps over your connected sources, combining hybrid search and contextual retrieval for a more accurate, cited answer.
hybrid search: Searching with both keyword (exact-match) and vector (meaning-based) indexes at once, then merging the results — so you find a document whether you remember its wording or just its topic.
knowledge graph: An LLM-built map of the entities and relationships across your indexed documents, which Onyx uses to answer questions that span many sources rather than sitting in one file.
AI agent (Onyx): A custom assistant you configure with its own instructions, a scoped set of knowledge (connectors), and actions it may take — e.g. a 'policy' agent that answers only from the HR handbook and cites the clause.
Actions: Onyx's mechanism for letting an agent call external applications (with flexible authentication), so a chat can do things — look up or update a record — not just retrieve documents.
MCP: Model Context Protocol — an open standard Onyx supports for connecting agents to external tools and data sources beyond its built-in connectors.
deep research: An Onyx mode where an agent plans a multi-step investigation across your sources and the web, then writes a structured, cited brief — for questions too broad for a single answer.
Onyx Cloud: The managed, hosted version of Onyx (cloud.onyx.app) — sign up and connect sources without running any infrastructure; billed per user.
Community Edition (CE): The free, MIT-licensed build of Onyx you self-host yourself; covers chat, RAG, agents and actions. The Enterprise Edition adds SSO/SAML, granular access controls and white-labeling.
Onyx Lite: A lightweight, chat-only deployment of Onyx that runs in under 1GB of memory — for testing or simple chat use, versus the full stack with vector indexes and background workers.

Commands

docker compose up: The command that brings up a self-hosted Onyx stack (web app, indexes, workers, storage) from its official compose file on your own machine or server.

AnythingLLM 8 lessons ↗

Commands

@agent: A mention you type in a chat message in AnythingLLM to explicitly start an agent session, giving the conversation access to tools like web search or file reading.
/api/docs: A URL path you open in your browser on a running AnythingLLM instance to see its full interactive API reference, listing every endpoint you can call from code.
@agent: A prefix you type in a workspace chat to turn it into an active agent that can take actions (e.g. summarise the newest file) rather than only answer.
docker run: The command used to pull and start the official mintplexlabs/anythingllm server image so you can self-host AnythingLLM.

Files & config

mintplexlabs/anythingllm: The official Docker Hub image name for AnythingLLM, which you reference when running the app inside a container on your own machine or server.

Concepts

requests: A popular Python library that lets your code send HTTP requests (GET, POST, etc.) to web addresses, commonly used to call REST APIs like AnythingLLM's.
workspace: A named container that holds a set of uploaded documents and its own chat history, keeping different projects or topics separate.
Show Citations: A toggle under an answer that reveals which uploaded files it was drawn from, so you can verify each claim against the source.

Open Notebook 23 lessons ↗

Interface

Add Source: Button in the interface that lets you attach a new document or web page to the current notebook.
Sidebar: Panel on the left side of the app that lists all your notebooks for quick switching.
Podcast dialog: Settings window where you choose source documents, speakers, and tone before generating audio.
web UI: Standard web page you open in any browser to interact with the Open Notebook application.

File Types

Web Page: A live internet article whose URL you paste so its text is fetched and indexed like a PDF.
PDF: Portable Document Format file that can be uploaded and searched inside a notebook.
MP3: Audio file format that can be uploaded and turned into searchable text or played back as a podcast.
WAV: Uncompressed audio file format that works like MP3 for uploading and transcription.

Concepts

Notebook: A self‑contained collection of documents and its own chat thread within Open Notebook.
Workspace: Higher‑level grouping of multiple notebooks, used as an alternative organization model.
port 3000: Network endpoint that Open Notebook listens on so browsers can connect to its web UI.
DNS: System that maps a readable domain name to your server’s IP address for easier access.
TLS: Encryption protocol that secures data between the browser and the Open Notebook site.

Actions

Drag: Mouse action used to move a file from one place to another, such as placing a PDF into a notebook.
Upload: Process of sending a local file (e.g., PDF, MP3) to the Open Notebook server so it becomes part of a notebook.
Search: Enter a word or phrase to find matching content across one or many notebooks.

Features

Speaker: Named voice profile (up to four) that reads lines in a generated podcast.
Tone: Overall style option—academic, casual, or debate—that shapes how the podcast sounds.

Files

.env: Configuration file where you place API keys or local model settings for Open Notebook to use.

Commands

git clone: Command that copies the Open Notebook source code from its online repository onto your server.
UFW: Simple firewall tool; the command `ufw allow 3000/tcp` opens network traffic on port 3000 for the app.
Certbot: Command‑line tool that obtains and installs a Let's Encrypt certificate for your server.

Tools

Let's Encrypt: Free service that provides TLS certificates so your custom domain uses HTTPS.

ChatGPT 18 lessons ↗

Models

o3: OpenAI's most capable reasoning model available in ChatGPT, designed for difficult problems in coding, mathematics, and science that require extended multi-step thinking before responding.

Concepts

prompt: The message or question you type into ChatGPT — it is the instruction that tells the AI what you want it to do.
context window: The total amount of text (measured in tokens) that ChatGPT can read and hold in a single conversation; content beyond this limit may no longer be considered when generating a response.
token: A small chunk of text — roughly three-quarters of a word — that ChatGPT uses internally to read and generate language; token limits determine how long a conversation or document can be.
ChatGPT Plus: A paid subscription tier that gives individual users access to more powerful models, higher usage limits, and features like Deep Research and Advanced Voice.

Features

Custom Instructions: A settings feature that lets you tell ChatGPT persistent preferences — such as your profession or preferred response style — so you don't have to repeat them in every new chat.
Memory: A feature where ChatGPT saves useful facts you share across conversations (like dietary preferences or your job) so future chats feel more personalised; you can view, edit, or delete saved memories at any time.
Projects: A workspace inside ChatGPT that groups related chats, uploaded files, and shared context under one goal, useful for ongoing work that spans multiple sessions.
Canvas: A side-by-side editing workspace that opens automatically for longer writing or coding tasks, letting you directly edit the output and ask ChatGPT to revise specific sections.
GPTs: Custom versions of ChatGPT built with specific instructions, uploaded knowledge, and selected tools for a particular purpose — for example, a GPT focused on cooking advice or legal summaries.
GPT Store: A public directory at chatgpt.com/gpts where anyone can browse and use GPTs created by OpenAI, partners, and the wider community, organised by category.
Deep Research: A ChatGPT tool that autonomously searches the web, reads multiple sources, and compiles a long-form referenced report on a topic you specify.
Advanced Voice: A mode that lets you speak to ChatGPT and hear it respond in a natural-sounding voice, available on the ChatGPT website, iOS, Android, and Windows app.
Data Analysis: A built-in ChatGPT capability that lets you upload spreadsheets or data files and ask questions about the data, create charts, or run calculations — no coding required.
File Uploads: The ability to attach documents such as PDFs, Word files, or spreadsheets to a ChatGPT conversation so the model can read, summarise, or answer questions about their contents.
Image Generation: A ChatGPT capability that creates original images from a text description you provide, or edits an existing image based on your instructions.
Web Search: A ChatGPT tool that looks up current information on the internet in real time, allowing it to answer questions about recent events or facts beyond its training data.
ChatGPT Agent: A feature that lets ChatGPT perform multi-step tasks on your behalf — such as browsing the web, filling forms, or running code — with minimal input from you.

Make 11

Workflows

Scenario: One automation in Make: a trigger plus the connected modules that run when it fires.
Module: A single step in a scenario, representing one app action — read a row, send an email, call an API.
Bundle: One packet of data passing from one module to the next.
Router: A module that splits a scenario into several parallel routes.
Iterator: A module that loops over a list, running the later modules once per item.
Aggregator: A module that combines many bundles back into a single one.

Billing

Operation: One module action. Make meters usage by operations — now billed as "credits".
Credit: Make's unit of metered usage; each module action costs one (1,000/month on the free plan).

Advanced

Make Code: A module for running custom JavaScript or Python when no ready-made app module fits.

Maia: Make's AI assistant — it builds and troubleshoots scenarios from a plain-language description.

Triggers

Webhook: A URL that triggers a scenario the instant another service posts data to it.

Zapier 11

Workflows

Zap: One automated workflow in Zapier: a trigger plus one or more actions.
Trigger: The event that starts a Zap — a new email, a new spreadsheet row, a form submission.
Action: A step a Zap performs after the trigger — create, update, or send something in another app.
Multi-step Zap: A Zap with more than one action chained together (a paid-plan feature).

Billing

Task: One action that completes successfully. Zapier bills by tasks, so each action that runs counts.

Logic

Path: Conditional branching — different actions run depending on the incoming data.
Filter: A step that stops a Zap from continuing unless its conditions are met.
Formatter: A built-in step that reshapes data — dates, text, numbers — between other steps.

Copilot: Zapier's AI that builds a Zap for you from a plain-English description.
Agents: Zapier AI agents that carry out multi-step tasks such as research or data lookups.

Data

Tables: Zapier's built-in database for storing and reading data inside your automations.

KNIME 20 lessons ↗

Concepts

Workflow: A collection of connected nodes arranged on the editor canvas that together carry out a complete data analysis from reading in data to producing a result.
Node: A single building block in a KNIME workflow — a colored box that performs one task, such as reading a file, filtering rows, or training a model.
Port: A connection point on the side of a node — input ports (left) receive data and output ports (right) send data to the next node.
Data Port: A port that passes a data table between nodes; shown as a black triangle and can only connect to another data port.
Model Port: A port that passes a trained machine-learning model from one node (e.g. a trainer) to another (e.g. a predictor).
Flow Variable: A named value (like a file path or a number) that travels between nodes through flow-variable ports and can change how a node is configured without editing it by hand.
Node Status: A traffic-light indicator beneath each node: red means not yet configured, yellow means configured and ready, green means successfully executed.
Workspace: The folder on your computer where KNIME stores all your workflows, node settings, and any data the workflow produces.
Columnar Backend: An optional KNIME execution engine that stores table data column-by-column using Apache Arrow, which reduces memory use on large datasets.
RowID: A unique identifier automatically assigned to every row in a KNIME data table, similar to a row number in a spreadsheet.
Execution: The act of running a node or an entire workflow so that it processes its input data and produces output; triggered by pressing F7 or clicking the Execute button.

Features

Node Repository: The searchable panel listing every node available in your KNIME installation; you drag nodes from here onto the workflow canvas.
Workflow Editor: The central canvas where you place and connect nodes to build a workflow.
Component: A reusable, shareable group of nodes packaged as a single custom node with its own configuration dialog; can be published to KNIME Hub for others to use.
Metanode: A group of nodes collapsed into one box purely to keep the canvas tidy; unlike a Component it cannot be shared or given a custom dialog.
KNIME Hub: The online repository where you can store, share, and download KNIME workflows and components; available as a free Community Hub or an enterprise Business Hub.
K-AI: The built-in KNIME AI assistant that can answer questions about the platform (Q&A mode) or automatically extend your workflow by suggesting and adding nodes (Build mode).
Space Explorer: The file-browser panel in KNIME where you navigate and manage your workflows, folders, components, and data files.
Node Monitor: The bottom panel that shows the output table, statistics, or flow variables produced by a selected node after it has been executed.
Workflow Annotation: A free-text box you can place anywhere on the workflow canvas to document what a section of the workflow does; supports basic markdown formatting.

Cursor 8 lessons ↗

Concepts

sns.clustermap: A function from the seaborn visualisation library that draws a heatmap with rows and columns automatically reordered so that similar values cluster together.
Agent mode: A mode where Cursor autonomously reads your project and writes changes across multiple files in one session, rather than answering a single question.
Tab: Cursor's line-by-line code suggestion that appears as you type; press Tab to accept it or keep typing to ignore it.
model picker: The dropdown that lets you switch which model handles a request (Claude, GPT, Gemini, or Auto) on a per-task basis.
diff: The view Cursor shows of what the AI changed in a file; you review it and choose to accept or reject before it is saved.
ModuleNotFoundError: A Python error meaning a required package is not installed; in Agent mode Cursor can detect this and install the missing package automatically.
Auto: The model-picker option that lets Cursor choose the best model for each request automatically, useful for routine edits.

Files & config

utils.py: A Python file named by convention to hold small helper functions shared across multiple scripts in the same project, keeping the main files shorter and easier to read.

GitHub Copilot 13 lessons ↗

Concepts

.py: The file extension for a Python source code file — any file ending in .py contains Python instructions the computer can run.
def: A Python keyword that marks the start of a new function definition — everything indented beneath it is the code that runs when you call that function.
Counter: A Python built-in class (from the `collections` module) that counts how many times each item appears in a sequence and stores the results as a dictionary.
DataFrame: A table of data provided by the pandas library — it has named columns and numbered rows, similar to a spreadsheet you can manipulate with code.
KeyError: A Python error that occurs when you try to access a dictionary or DataFrame column using a name that does not exist in it.
ValueError: A Python error that occurs when a function receives a value of the right type but an inappropriate content — for example, passing an empty list where data is required.
groupby: A pandas operation that splits a table into groups based on the values in a column (like splitting experiment rows by treatment condition) so you can calculate statistics for each group separately.
.div(): A pandas method that divides every value in a Series or DataFrame by a number or another Series — commonly used to convert raw counts into proportions.
pd.read_csv: A pandas function that reads a CSV (comma-separated values) file from disk and loads it into a DataFrame so you can analyse it with Python.
sns.heatmap(...): A seaborn function that draws a colour-coded grid where each cell's colour represents a numeric value — useful for spotting patterns across many samples or genes at once.
method: A function that belongs to an object or class — for example, `.mean()` is a method on a pandas DataFrame that calculates the average of a column.

Features

@: In GitHub Copilot Chat (VS Code), typing @ opens a list of chat participants — domain-expert agents such as @workspace or @github — that you can direct your question to for specialised help.
/: In GitHub Copilot Chat, typing / opens a list of slash commands — shortcuts for common tasks like /explain (explain selected code) or /tests (generate unit tests) — so you do not need to write a full prompt.

Devin Desktop 10 lessons ↗

Concepts

argparse: A built-in Python module that lets your script accept named options (like --input or --threshold) typed on the command line, so you don't have to hard-code values inside the file.
evalue: Short for "expect value" — a BLAST statistic that measures how likely a sequence match is to be a coincidence; lower values (e.g. 1e-10) mean a more trustworthy biological match.
import csv: A Python statement that loads the built-in csv module so your script can read and write spreadsheet-style files with rows and columns.
NameError: A Python error that fires when your code refers to a variable or function that hasn't been defined yet — usually a typo or a missing assignment.
TypeError: A Python error that fires when an operation is applied to the wrong kind of value — for example, trying to do arithmetic on a piece of text instead of a number.
Cascade: Devin Desktop's (formerly Windsurf's) agent panel that reads your whole project and applies multi-file changes from a plain-English task description.
checkpoint: A snapshot of your project saved before each Cascade step, letting you roll an agent change back in one click.
Send to Cascade: An action that pushes the editor's Problems-panel errors into the Cascade conversation so the agent can fix them in context.
Auto-fix: A Cascade setting that detects lint errors introduced mid-task and corrects them automatically before the task finishes.

Flags

--input: A command-line flag passed to a Python script (via argparse) that tells the script which file to read; you type it after the script name, e.g. python filter.py --input data.csv.

Aider 6 lessons ↗

Flags

--model: An Aider command-line flag that specifies which AI model to use for the main chat session, for example --model claude-3-opus-20240229 to select a specific Claude model.
--model: The launch flag that sets which LLM Aider uses for the session (e.g. 'aider --model sonnet' or '--model o4-mini'), so you can match model to task.

Slash commands

/undo: An Aider slash command that undoes the last git commit if it was made by Aider, restoring your files to how they were before that change.
/tokens: An Aider slash command that reports how many tokens the current chat context is using, so you can see how much of the model's context window is occupied.

Concepts

auto-commit: Aider's default behaviour of committing every AI-made change to Git with an auto-written message, so each edit has an audit trail you can undo.
codebase map: An index Aider builds of your project so the model can reason across files (callers, definitions, imports) without you pasting every file in.

Flowise 22 lessons ↗

Concepts

Chatflow: A visual builder in Flowise for creating single-agent chatbots and simple LLM workflows by connecting nodes on a drag-and-drop canvas.
Agentflow: Flowise's most powerful visual builder — a superset of both Chatflow and Assistant — that supports multi-agent systems, branching logic, loops, and human-in-the-loop checkpoints.
Assistant: The most beginner-friendly Flowise builder, which lets you create an AI agent that follows instructions, uses tools, and retrieves answers from uploaded files — without wiring individual nodes.
Node: A single building block on the Flowise canvas — each node performs one job (e.g. call an LLM, search a document, run a tool) and connects to other nodes via edges.
Canvas: The visual workspace inside Flowise where you drag, drop, and wire together nodes to design an AI workflow.
LLM: Large Language Model — the AI text engine (such as GPT-4 or Claude) that reads instructions and generates responses inside a Flowise workflow.
Agent: An autonomous AI component that can reason, plan, decide which tools to use, and take actions — unlike a plain LLM node, it makes decisions dynamically.
RAG: Retrieval-Augmented Generation — a technique where the AI fetches relevant passages from your own documents before answering, so responses are grounded in your data rather than general training.
Vector Store: A specialised database that stores text as lists of numbers (vectors) so that semantically similar content can be found quickly, even if the exact words differ.
Embedding: A numerical representation of a piece of text — two embeddings that are close together in number-space mean the texts have similar meaning, enabling similarity search.
Chunk: A small segment of a document created by splitting the original file into pieces before indexing, so that only the most relevant part is retrieved rather than the whole document.
MCP: Model Context Protocol — an industry-standard interface that lets AI agents connect to external tools and data sources through a common, provider-maintained interface.

Features

Tool: A function that an agent can call to interact with the outside world, such as searching the web, running a calculation, or making an HTTP request.
Document Store: A Flowise feature that lets you upload, split, and index your own files so that agents can search and retrieve information from them.
Upsert: The action in Flowise that sends your prepared document chunks into a Vector Store — it adds new entries and updates existing ones without creating duplicates.
Flow State: A runtime key-value store that passes data between nodes within a single Agentflow run, letting distant nodes read values set by earlier nodes.
Human Input node: An Agentflow node that pauses execution and waits for a real person to review, approve, or provide information before the workflow continues.
Memory: A component that stores previous conversation messages so the AI can refer back to earlier exchanges within the same chat session.
Buffer Window Memory: A memory type that keeps only the most recent K conversation turns, discarding older ones, to avoid sending too much history to the LLM.
Streaming: A mode where the AI sends its reply token-by-token in real time as it is generated, rather than waiting until the full response is complete before showing anything.
Retriever: A node that queries a Document Store using semantic similarity to fetch the passages most relevant to the user's question.
Execute Flow node: An Agentflow node that calls another Chatflow or Agentflow as a sub-workflow, letting you reuse or nest existing flows inside a larger one.

Langflow 4 lessons ↗

Commands

pip: The standard tool for installing Python packages; running `pip install something` downloads and installs a library so your Python code can use it.
uv: A fast Python package and project manager (made by Astral) that works like pip but runs significantly faster, especially when installing many packages at once.

Concepts

Playground: Langflow's live testing panel where you message a flow and watch the agent's step-by-step reasoning and tool choices in real time.
canvas: The visual workspace where you drag blocks and draw wires between them to build a flow without writing glue code.

CrewAI 12 lessons ↗

Commands

pip install crewai: The terminal command that downloads and installs the CrewAI library onto your computer so Python can use it.
crewai create crew: A CrewAI CLI command that generates a ready-to-run project folder with all the starter files your crew needs (config files, crew.py, and a .env template).
crewai run: A CrewAI CLI command that executes your crew or flow, reading the project type automatically from pyproject.toml and running all the agents and tasks you have defined.

Files & config

.env: A hidden text file in your project folder where you store secret settings like API keys so they are not baked into your code.
agents.yaml: A CrewAI configuration file (in YAML format) where you describe each agent's role, goal, and backstory without writing Python code.
tasks.yaml: A CrewAI configuration file (in YAML format) where you describe each task — what it asks for, what output it expects, and which agent handles it.
crew.py: The main Python file generated by CrewAI that wires your agents and tasks together into a runnable crew using the settings in your YAML config files.
expected output: A field in tasks.yaml describing what a finished task should produce, guiding the assigned agent's response.

Concepts

Crew: The core CrewAI Python class that groups your agents and tasks together and controls how they collaborate to complete a goal.
role: A plain-English field in agents.yaml naming what an agent is (e.g. 'Senior Researcher'), shaping how it approaches its tasks.
goal: A plain-English field in agents.yaml stating what an agent is trying to achieve, steering its reasoning and output.
backstory: A plain-English field in agents.yaml giving an agent context about its experience, further tuning how it behaves.

Claude Opus 4.8 15

Size & speed

parameters: The adjustable weights a model learns during training; more parameters (e.g. 7B vs 120B, where B = billion) usually means smarter but slower and heavier to run.
quantization: Shrinking a model by storing its weights at lower precision (e.g. 4-bit instead of 16-bit) so it fits a smaller machine, at a small quality cost.
tokens per second: How fast a model generates text — higher feels snappier. It depends on both the model size and your hardware.
context window: How much text a model can consider at once (your prompt plus its reply), measured in tokens; a bigger window lets you paste in more.

How models are built

MoE: Mixture of Experts — an architecture that activates only a slice of the model's parameters per token, so a huge model can run at the cost of a much smaller one (e.g. DeepSeek, GLM, MiniMax).
reasoning model: A model trained to "think" through steps before it answers, trading speed for accuracy on hard problems.
distillation: Training a smaller model to imitate a bigger one, keeping much of the quality at a fraction of the size.
multimodal: A model that handles more than text — images, audio, sometimes video — not just words.

Access & cost

open-weight: A model whose trained weights you can download and run yourself — free to run and private — as opposed to a closed cloud API.
open weights vs open licence: You can download an open-weight model, but its licence may still restrict commercial use — always check before shipping (some MiniMax and Llama terms do this).
closed / API model: A model you can only use over the vendor's cloud API: highest quality, but you pay per token and your data leaves your machine.
per-token pricing: Cloud models bill by the token, charged separately for input and output; a small model can be roughly 5× cheaper than a frontier one.
frontier model: The current top tier of most-capable models (e.g. Claude Opus, GPT-5, Gemini Pro) — the most powerful and the most expensive.

Running locally

local model: A model that runs on your own hardware so nothing leaves your machine; what you can run is limited by your memory.
VRAM: The memory on your graphics card — the main limit on which local models you can run (rough rule: the model's size in GB must fit in VRAM).

ElevenLabs 12

Tools/Modules

langchain-community: A collection of extra tools for LangChain that lets you connect to services like ElevenLabs.
ELEVENLABS_API_KEY: A secret code you paste into the program so it can talk to ElevenLabs’ online service.
ElevenLabsTextToSpeech: A ready‑made component that sends text to ElevenLabs and returns the path of the generated audio file.

File Types

WAV file: An audio file format that stores sound without compression, often used for high‑quality playback.

Features

Voice Library: A list inside ElevenLabs where you can browse, preview, and save pre‑made AI voices for later use.
Instant Voice Clone: A quick way to create a copy of your own voice by uploading about 30 seconds of recording.
Professional Voice Clone: A high‑quality custom voice built from at least 30 minutes of studio‑recorded audio.

Settings

Style Exaggeration slider: A control that tells the model how strongly to emphasize the chosen speaking style, from subtle to extreme.
<break time="1.5s"/>: An inline tag you insert in your script to make the generated speech pause for the specified number of seconds.
[break]: A short shortcut that adds a brief pause in the spoken output when placed inside brackets.
[whisper] (or other bracketed tags): A tag you wrap around words to make the voice speak with a specific expression like whispering or excitement.
Speaker Boost: An optional toggle that makes the chosen voice sound louder and clearer in the final audio.

Cartesia (Sonic) 12

Concepts

API key: A secret code you copy from Cartesia that lets other programs prove they are allowed to use Cartesia’s voice service.

Technology

WebSocket: A live internet connection that lets Cartesia send text of spoken words instantly to another program.
Webhook: A URL that receives data (like audio) from Cartesia when a phone call is answered.

Files

.mp3/.wav file: Common audio file formats you can download after the speech is generated.

Features

Instant Clone: A feature that creates a new synthetic voice from a short recording of a real speaker.
Multi‑Voice Narration: A page where you can assign different synthetic voices to each line of dialogue in a script.
Design a Voice: A tool that blends two or more existing voices and lets you adjust speed, pitch, and emotion to create a new custom voice.

Tools

Voice Studio Flow: A visual workflow in Twilio where you can add steps like calling Cartesia to produce spoken replies.

Data Format

JSON: A simple text format used to package the transcript of spoken words for sending over the WebSocket.

Interface

Emotion sliders: Controls that let you increase or decrease feelings such as anger or sadness in the generated voice.

Tips

Pronunciation fixes: Adding spaces, hyphens, or phonetic spellings to your script so Cartesia says a word correctly.

Settings

high‑stability: An option when cloning a voice that makes the synthetic voice work reliably even with imperfect input audio.

Deepgram (Nova-3) 12

General

API key: A secret string that proves you are allowed to call Deepgram’s services.
Dashboard: The web page where you manage your Deepgram account, keys and settings.
Endpoint: A specific URL on Deepgram’s servers that receives a request, such as the transcription or streaming service.
WebSocket: A two‑way internet connection that lets you send audio to Deepgram and receive transcripts instantly.
JSON: A text format that represents data as name‑value pairs, used for sending configuration and receiving results.
CSV: A simple file where each line is a row of values separated by commas, often used to export logs or transcripts.
SDK: A collection of ready‑made code libraries (for languages like Python or JavaScript) that simplify calling Deepgram APIs.
.env file: A plain text file that stores environment variables such as your API key so programs can read them securely.
async: A way of writing code that can pause while waiting for data (like audio chunks) without stopping the whole program.
coroutine: A special function declared with async that can be started, paused, and resumed as part of asynchronous processing.
asyncio queue: A thread‑safe container used in Python’s async code to hold audio chunks until they are sent over a WebSocket.
utterance_ms: A setting that tells Deepgram how many milliseconds of silence must follow speech before it treats the spoken part as finished.

Kokoro 82M (open source) 12

Setup

virtual environment: An isolated Python setup that keeps the packages you install separate from other projects on your computer.
pip: The standard command‑line tool for installing Python libraries from an online repository.

Objects

Pipeline: A ready‑made object that takes text input and returns spoken audio when you call it like a function.

Parameters

language='en_us': A parameter telling the pipeline to use the English (United States) voice model.
voice_id: The name of a specific speaker model that the pipeline uses to generate speech.

Files

.wav: A common audio file format that stores raw sound data and can be played by most media players.

Functions

sf.write: A function from the SoundFile library that saves an array of audio samples to a .wav file.
np.concatenate: A NumPy function that joins several audio arrays end‑to‑end into one longer array.

Concepts

IPA: International Phonetic Alphabet, a set of symbols that represent exact speech sounds.

Syntax

slashes (e.g., /kɒˈkoʊroʊ/): Characters placed around an IPA string to tell Kokoro to use those phonemes instead of guessing the pronunciation.

Interface

ipywidgets.Textarea: A widget that creates a multi‑line text box inside a Jupyter notebook for user input.

Scripts

run_cokoro.bat: A batch file you double‑click to start a local server that runs Kokoro either in CPU or GPU mode.

OpenAI Realtime API 12

Platform

LiveKit: A software platform that handles real‑time audio routing and lets you connect speech‑to‑text, language models, and text‑to‑speech services.

Classes

AgentSession: An object that represents a single voice conversation session and coordinates the chosen speech and AI components.

Decorators

@entrypoint: A Python decorator that marks the method where the voice agent starts running.
@livekit.agents.function_tool: A decorator that tells LiveKit to treat a regular Python function as a tool the language model can call during a voice chat.

Commands

livekit.cli.run_app(entrypoint): A command‑line call that launches your agent script using the function you marked with @entrypoint.

Concepts

docstring: The text placed right under a function definition that describes what the function does and how to use it.

Protocols

MCP (Model Context Protocol): A standard way for language models to discover and call external APIs without custom code.

Files

.env file: A plain‑text file that stores configuration values such as API keys, which the program reads at startup.

Components

relay server: A small backend service that forwards audio data between your web app and OpenAI’s Realtime API over WebSocket.

Networking

WebSocket: A persistent internet connection that lets the browser send and receive audio data instantly without reloading the page.

Data Formats

tool schema: A JSON description that tells the model what a custom function does, what inputs it needs, and how to call it.

Methods

add tools method: A LiveKit command used on an open WebSocket connection to register your custom tool schemas so the model can invoke them.

Google Gemini Live 12

Components

LiveKit: A Python library that handles real‑time audio routing and lets you connect speech‑to‑text, language models, and text‑to‑speech services.
AgentSession: An object that represents a single voice conversation session and manages the chosen audio pipeline providers.
livekit.agents.Agent: The base class you inherit from to create your own voice assistant logic.

Commands

@entrypoint: A decorator that marks the method LiveKit should call first when starting an agent.
livekit.cli.run_app(entrypoint): A command‑line call that launches the agent using the method marked with @entrypoint.
@livekit.agents.function_tool: A decorator that tells LiveKit to expose a regular Python function as a tool the language model can call.
lk cloud login / lk app env / lk start / lk agent create: LiveKit CLI commands that log you into the cloud service, upload secret variables, prepare deployment settings, and build & launch a containerized agent.

Concepts

docstring: The text placed right under a function definition that describes what the function does and its parameters; LiveKit uses it as instructions for the model.
MCP (Model Context Protocol): A standard way for language models to discover, validate, and call external tools over HTTP.
WebSocket: A persistent network connection that lets the frontend send audio to the server and receive responses instantly without re‑loading the page.

Files

.env: A plain‑text file that stores environment variables such as API keys so they are not hard‑coded in the script.
Dockerfile: A text file that tells Docker how to build a container image for your agent, including dependencies and start commands.

ElevenLabs Conversational AI 12

Platform

LiveKit: A software platform that lets you build real‑time voice applications by handling audio routing and connections for you.

Classes

AgentSession: An object that represents a single conversation instance, keeping track of the room state and history while running the voice pipeline.
livekit.agents.Agent: The base class you inherit from to create your own voice assistant, providing built‑in hooks for speech‑to‑text, language model, and text‑to‑speech integration.

Decorators

@entrypoint: A decorator that marks a method as the starting function that LiveKit will call when launching your agent.
@livekit.agents.function_tool: A decorator that tells LiveKit to treat the following Python function as a tool the assistant can call when the user asks for it.

Concepts

docstring: The text placed right under a function’s definition that describes what the function does; LiveKit uses this description to match user requests to tools.

Protocols

MCP: Short for Model Context Protocol, a standard way for language models to discover and call external APIs without custom code.

Files

.env file: A simple text file where you store configuration values like API keys so the program can read them securely at runtime.

Networking

WebSocket: A network connection that stays open, allowing real‑time two‑way communication between your app and a server such as OpenAI’s Realtime API.

Data Formats

tool schema: A JSON description that defines what a custom function does, its required inputs, and how the model should call it.

CLI Commands

lk cloud login: A command in the LiveKit CLI that authenticates you with your LiveKit cloud account so you can deploy apps.

Methods

add tools method: A function call on the WebSocket connection that registers your custom tool schemas so the Realtime model can invoke them during a conversation.

Retell AI 12

Components

LiveKit: A platform that provides Python classes and tools for building real‑time voice applications.
AgentSession: An object that holds the state of a voice conversation, including history and active audio pipelines.
livekit.agents.Agent: The base class you inherit from to create your own voice assistant logic.
relay server: A small backend program that forwards WebSocket messages between your front‑end app and an external API like OpenAI’s Realtime service.

Commands

@entrypoint: A decorator that marks a method as the starting function for launching an agent session.
livekit.cli.run_app(entrypoint): A command‑line call that runs the specified entrypoint method to start the agent.
@livekit.agents.function_tool: A decorator that tells LiveKit to treat a regular Python function as a callable tool for the assistant.

Concepts

docstring: The text placed right under a function definition that describes what the function does and its parameters.
MCP (Model Context Protocol): A standard way for language models to discover, validate, and call external tools over HTTP.
WebSocket: A persistent internet connection that lets the client and server exchange audio or data instantly in both directions.

Files

.env: A file that stores environment variables such as API keys in a simple key‑value format.
Dockerfile: A script that tells Docker how to build a container image for your application.

Pipecat 12

Classes

livekit.agents.Agent: A base Python class provided by LiveKit that you extend to create a custom voice AI agent.
AgentSession: An object that manages a single voice interaction, handling audio routing and tool calls for the agent.

Decorators

@entrypoint: A decorator that marks the method where the agent’s conversation session is started.
@livekit.agents.function_tool: A decorator that tells LiveKit to treat a regular Python function as a tool the LLM can call during conversation.

Commands

livekit.cli.run_app(entrypoint): A command‑line helper that launches your Python script by calling the function you marked with @entrypoint.

Concepts

MCP: Short for Model Context Protocol, a standard that lets the agent discover and invoke external APIs without custom code.

Files

Dockerfile: A text file generated by the LiveKit CLI that describes how to build a container image for your agent.
.env: A simple configuration file where you store secret keys and settings as name‑value pairs.

APIs

OpenAI Realtime API: An OpenAI service that streams audio to and from a model over a WebSocket, enabling live voice interactions.

Protocols

WebSocket: A network connection that stays open so the client and server can exchange messages instantly in both directions.

Data Formats

JSON schema: A structured description of a tool’s input parameters written in JSON format, used by the Realtime API to validate calls.

Methods

add tools method: A function you call on the WebSocket connection to register custom tool definitions so the model can invoke them.

Moshi (Kyutai) 12

Framework

LiveKit: A software platform that provides building blocks for real‑time audio and video applications.

Class/Interface

livekit.agents.Agent: A base Python class you extend to create a voice AI agent with LiveKit.
AgentSession: An object that manages the state of a conversation, including audio pipelines and history, for one user session.

Decorator

@entrypoint: A decorator that marks the method LiveKit should call first when starting an agent.
@livekit.agents.function_tool: A decorator that tells LiveKit to expose a regular Python function as a tool the LLM can call.

Command

livekit.cli.run_app(entrypoint): A command‑line function that launches your script by calling the method you marked with @entrypoint.
add tools method: A LiveKit function you call on the WebSocket to register custom tool definitions so the model can invoke them during a voice session.

Concept

docstring: The text placed right under a function definition that describes what the function does and its parameters.

Protocol

MCP: Short for Model Context Protocol, a standard way for language models to discover and call external tools.

File

Dockerfile: A text file that tells Docker how to build a container image for your application.
.env: A file that stores environment variables such as API keys, which the program reads at startup.

API

WebSocket: A network connection that stays open so client and server can exchange messages instantly in both directions.

HeyGen 12

Components

Avatar: The on‑screen digital presenter that speaks and moves in your video.

Interface

AI Studio: The main editing workspace where you adjust script, captions, background and avatar settings.

Features

Motion Engine: A feature that adds preset expressive gestures and facial movements to an avatar automatically.
Avatar Shots: A function that creates short cinematic clips with rapid scene changes and outfit swaps from a single prompt.
AutoAvatar: A feature that generates a personalized avatar from uploaded photos or a short video of yourself.
AutoVoice: A function that clones a voice by analyzing a brief audio sample and creates a synthetic speech model.

Tools

Video Agent: A tool that builds a video from a text description by selecting scenes, avatars, voices and styles before rendering.
Nano Banana: An AI image model you can call on to generate custom background images for your video.
Quick Create: A shortcut that produces a simple video from a brief text prompt without opening the full editor.

Technology

Seedance 2.0: The underlying technology used by Avatar Shots to synthesize dynamic camera moves and wardrobe changes.

Core Terms

Credits: The internal currency you spend to generate avatars, voices or videos within HeyGen.

Settings

Brand Kit: A collection of your logo, colors, fonts and templates that can be applied automatically to new videos for consistent branding.

Synthesia 12

Features

Personal Avatar: A lifelike AI copy of you that can appear and speak in Synthesia videos.
Enterprise plan: The paid subscription level that lets you upload a custom logo onto avatars.
Custom Avatar: An avatar whose outfit, setting and voice are defined by typing a description in plain text.
Translate (in export): A one‑click option that creates separate video files with dubbed audio and subtitles in chosen languages.
Multi‑Angle Avatars: Three separate personal avatars recorded from different camera positions that can be swapped to change viewpoint within a single video.

Interface

Avatars → Customize: The menu path to edit an avatar’s colors, logo, clothing or background.
Avatar dropdown: A list in the video editor where you pick which avatar (or angle) appears in a scene.
Change All: An option that replaces the default presenter with your chosen avatar across every scene at once.
Add Space: A button that lets you select or upload a background image for an avatar’s scene.
Action Prompt: A field where you type a short command (e.g., “walk across the screen”) to make the avatar perform that motion.
Media tab: The panel on the right side of the editor used for entering natural‑language action descriptions.

Settings

hex code: A six‑digit combination (like #FF5733) that specifies an exact color for branding.

Sora 2 10

Features

Cameo: A digital avatar of your own likeness that you can insert into Sora videos by uploading a photo and granting permission.
Pick a Mood: A filter in the main feed where you type a vibe or genre to see AI videos matching that mood.
Reference Image Integration: Uploading a photo alongside your prompt so Sora can use its visual details for more accurate video generation.

Tools

draft editor: The tool that lets you reopen a generated video’s prompt, make changes, and regenerate without losing the original draft.
Storyboard: A feature that chains multiple short prompts together to create a continuous multi‑scene video sequence.
Blend tool: A function that merges two videos using adjustable timing curves to control how one clip morphs into another.
Loop tool: A feature that extends a clip by blending its start and end frames to create a seamless repeating background video.

Prompt Techniques

Multi‑Cut Prompting: A prompting style where you write ‘cut to’ between scene descriptions so Sora creates internal cuts within one video.
Physics‑Safe Prompting: A strategy of describing simple or static actions instead of complex physics to avoid visual artifacts in the output.
Cinematic Prompt Formulas: Structured templates that combine scene description, camera movement, and style to guide Sora toward professional‑looking clips.

Google Veo 3 10

Interface

reference image field: The place in the video generation interface where you upload a photo to guide the AI’s visual output.
drafts folder: A storage area in Sora where generated videos are saved so you can reopen and edit them later.

Features

Pick a Mood: A filter on Sora’s main feed that lets you type a vibe or genre to see example AI videos matching that mood.
Blend feature: A tool in Sora that merges two videos into one by adjusting a timing curve for a smooth transition.
Loop tool: A function that extends a video by blending its start and end frames to create a seamless repeating clip, useful for background footage.

Settings

cameo permissions: Settings that decide who can see the digital avatar of your likeness, such as only you, approved friends, or everyone.

Access

invite code: A special alphanumeric key required to join Sora’s limited rollout when you have a ChatGPT Plus or Pro subscription.
ChatGPT Plus: A paid version of ChatGPT that provides higher usage limits and is needed to access Sora’s advanced features.

Prompt Techniques

Multi-Cut Prompting: A way to tell the AI to create several shots with internal transitions in a single video by using the phrase “cut to” between scene descriptions.
Physics‑Safe Prompting: A strategy of avoiding complex actions like splashing liquids or heavy wind in prompts to prevent visual glitches in the generated video.

Runway Gen-4 12

Interface

reference image field: A place in the video generation interface where you upload a photo to guide the AI’s visual output.
drafts folder: A storage area that saves generated videos and lets you reopen and edit their prompts later.
Sora 2 app: The mobile or web application where you create, edit, and generate AI videos with Sora’s tools.

Features

Pick a Mood filter: A search option on Sora’s main feed that shows videos matching a typed vibe or genre.
Blend feature: A tool that merges two videos into one by adjusting a timing curve for the transition.
Loop button: A control that creates a seamless repeat of a video by blending its start and end frames.
Storyboard button: An option that lets you chain several prompts together to build a longer narrative sequence.

Settings

Cameo permissions: Settings that decide who can see or use your uploaded likeness, such as only you, friends, or everyone.

Access

invite code: A special alphanumeric key required to gain access to Sora during its limited rollout.
ChatGPT Plus or Pro subscription: A paid plan that unlocks higher‑tier features and is needed to use Sora 2 fully.

Prompting

cut to phrase: The words “cut to” used in a prompt to tell the AI to insert a scene transition between shots.
physics‑safe prompting strategy: A guideline to avoid describing complex motions like splashing liquids, which often cause visual errors.

Kling 12

Interface

reference image field: The place in the Sora interface where you upload a photo to guide the AI’s visual output.
Pick a Mood feed: A filter on the Sora main page where you type a vibe or genre to see example AI videos matching that mood.
Storyboard button: The interface control that lets you chain multiple short prompts together to build a longer, continuous video sequence.

Prompting Techniques

multi-cut prompting: A way of writing a prompt that tells the AI to create several shots with cuts inside one video generation.
physics-safe prompting: Choosing simple actions and motions in your prompt to avoid unrealistic effects like splashing liquids or impossible movements.

Features

cameo avatar: A digital copy of your likeness that Sora can animate in generated videos after you upload a photo or short video of yourself.
draft editor: The tool inside Sora that lets you reopen a generated video’s prompt, edit details, and regenerate without losing the original version.
Blend feature: A Sora tool that merges two videos by adjusting a timing curve to create custom transitions.
Loop tool: A function in Sora that extends a clip by smoothly joining its start and end frames for seamless background loops.

Account

invite code: A special alphanumeric key required to create a Sora account during its limited rollout.
ChatGPT Plus: A paid subscription tier for ChatGPT that is needed to access Sora’s advanced video generation features.
Pro subscription: An upgraded plan (ChatGPT Pro) that unlocks higher‑quality, longer video generation and extra settings in Sora.

Wan 2.2 12

Interface

reference image field: The place in the video generation interface where you upload a photo to guide the AI’s visual output.
draft editor: The tool that lets you reopen and modify a previously generated video's prompt before regenerating it.
Pick a Mood filter: A search option on Sora’s main feed where you type a vibe or genre to see AI‑generated videos matching that mood.

Commands

cut to: A phrase used in prompts that tells the model to transition from one scene description to the next within the same video.

Access

invite code: A short alphanumeric key required to gain access to Sora 2 during its limited rollout.
ChatGPT Plus: A paid subscription tier for ChatGPT that is needed to use Sora 2 and obtain an invite code.

Features

cameo permissions: Settings that control who can see or use your uploaded personal avatar in generated videos (e.g., only you, friends, or everyone).
Storyboard feature: A function that lets you chain several short prompts together to create a longer, continuous video sequence.
Blend feature: A tool for merging two separate video clips by adjusting timing curves to control the transition between them.
Loop tool: An option that extends a clip by smoothly joining its start and end frames, creating a seamless repeating video.

Settings

high resolution setting: A selection in Sora 2 Pro that sets the output video’s detail level to ‘High’ for better visual quality.

Best Practices

physics‑safe prompting: A strategy of avoiding complex actions like splashing liquids or heavy wind in prompts to prevent unnatural AI video artifacts.

HunyuanVideo 12

Concepts

Cinematic Prompt Formulas: Pre‑made sentence structures that tell the AI what scene, camera movement and style to use, helping it create professional‑looking video clips.
Multi-Cut Prompting: Writing a single prompt that includes the phrase “cut to” to tell the AI to create several shots with transitions in one video.
Physics‑Safe Prompting Strategy: Choosing simple actions and gentle movements in your description to avoid AI glitches caused by complex physics like splashing water or flowing fabric.

Features

Reference Image Integration: Uploading a photo alongside your text prompt so the AI can copy exact visual details from that image into the generated video.
Pick a Mood feed: A filter in the Sora app where you type a vibe or genre and see AI videos that match, letting you copy their prompts for inspiration.
Cameo avatar: A digital version of your own face created from a photo or short video, which you can insert into AI‑generated scenes via text prompts.
Storyboard feature: An option that lets you chain several short prompts together in sequence, producing a longer narrative made of multiple AI‑generated clips.

Workflow

Remix and Iterate Workflow: A step‑by‑step method of changing only one part of a prompt at a time (like lighting) and regenerating the video until it matches what you want.

Tools

draft editor: An interface inside Sora where saved video drafts can be opened, edited, and regenerated without losing the original prompt.
Blend tool: A function that merges two separate videos by adjusting a timing curve so one clip smoothly morphs into the other.
Loop tool: A feature that extends a video by blending its start and end frames, creating a seamless loop ideal for background footage.

Access

invite code: A short alphanumeric key you obtain from community channels that unlocks access to Sora during its limited rollout.

LTX-Video 10

Interface

reference image field: A place in the video generation interface where you upload a photo to guide the AI’s visual output.
drafts folder: A storage area that saves generated videos so you can reopen and edit their prompts later.
Storyboard button: An interface element that lets you chain multiple prompts together to build longer, sequential video narratives.

Features

Pick a Mood filter: A tool on Sora’s main feed that lets you type a vibe or genre to see AI videos matching that mood.
Cameo: A digital avatar of yourself created from an uploaded photo, which the AI can insert into generated scenes.
Blend feature: A function that merges two videos by adjusting timing curves to create custom transitions between them.
Loop tool: A utility that extends a video by smoothly joining its start and end frames for seamless background loops.

Access

invite code: A special alphanumeric key required, along with a ChatGPT Plus or Pro subscription, to access Sora 2 during its limited rollout.

Prompting

cut to: A phrase used in a prompt to tell the AI to transition from one scene description to the next within the same clip.

Concepts

Physics-Safe Prompting Strategy: A guideline advising you to avoid describing complex physical actions like splashing liquids, which the AI often renders poorly.

Midjourney V8.1 12

Commands

/imagine: The core Midjourney command you type to ask the AI to create images from a text description.
/blend: Command used after uploading up to five source pictures to combine their visual ideas into a single new image.

Buttons

U1‑U4: Buttons that upscale (increase resolution of) the first through fourth thumbnail in the result grid.
V1‑V4: Buttons that generate four new variations based on the selected thumbnail.

Parameters

--no: A parameter you add to a prompt (e.g., `--no faces`) telling Midjourney to omit that element from the image.
--ar: A flag followed by width:height (e.g., `--ar 16:9`) that sets the canvas aspect ratio of the generated images.
--seed: A numeric argument (`--seed 12345`) that forces the AI to start from the same random seed, producing similar results each time.
--stylize: Parameter (`--stylize 500` or `-s 500`) that controls how strongly Midjourney applies its artistic style; lower values stay closer to the prompt.
--chaos: Parameter (`--chaos 80` or `-c 80`) that adds randomness, making outputs more varied and unexpected.

Modes

Relaxed Mode: A setting that removes fast‑hour limits by queuing jobs when GPU demand is low, allowing unlimited video generation with longer wait times.

Features

Personalization: Feature you enable so Midjourney learns from the images you like (by clicking heart) and biases future results toward your taste.
Mood Board: A collection of reference images you create to serve as a style guide, ensuring new generations share a consistent visual theme.

Adobe Firefly (Image Model 5) 10

Parameters

prompt: A short text description you write to tell the AI what image, video or edit you want.
aspect ratio: The width‑to‑height proportion of the generated picture or video, like 16:9.
shot size: A setting that tells the video generator how close or far the camera appears to be from the subject.
camera angle: The direction from which the virtual camera views the scene in a generated video.

Models

model: The specific trained AI system (such as “Firefly commercial safe”) that creates the output.
Runway Gen 4: One of the AI models offered in Firefly for editing video clips.

File Types

SVG: A file format for vector graphics that can be scaled without losing quality.

Features

variation: An alternative version of the generated image that you can choose from after the AI finishes.
dubbed audio: New spoken sound that replaces the original language track after translation.
avatar: A digital character you can select to appear on screen and speak your script.

Abacus.ai 12

Interface

prompt: A text description you write that tells the AI what to create or do.
Route LLM: A button that lets the system automatically pick the best language‑model for your question.
ChatLLM: The chat window where you type prompts and receive AI answers within Abacus Studio.
Thinking Mode: A setting you enable so the AI knows it should do more complex work like generating a full presentation.

File Types

vertical video (9:16): A video format taller than it is wide, common for phone screens like Instagram Stories.
horizontal video (16:9): A widescreen video format wider than it is tall, typical for YouTube or presentations.

Features

media plan: An outline generated by the AI that lists each scene, its length, camera moves, text and music before making a video.
upscale: A tool that increases the resolution of an image or video to make it look sharper.
mini models: Low‑cost versions of big language models that run without using your credit balance.
Deep Agent: An advanced AI mode that can search the web, write code and design slides all from one instruction.

Concepts

credits: Units that count how much of your paid usage an AI request consumes.
hero section: The top part of a webpage that usually contains a large image or headline, which the AI can build from a design mockup.

Genspark 12

Features

Super Agent: A GenSpark feature that takes one natural‑language question and returns a brief overview with pros/cons and an action plan.
Spark Page: The Deep Research tool that creates a full web‑page with sections, citations and an AI copilot from a single query.
AI Slides (Guide Mode): A mode in the AI Slides app that asks you about audience, style and length before automatically building a presentation deck.
AI Sheet: An assistant that turns plain English instructions into tables, formulas and charts inside a spreadsheet.
AI Docs: A tool that expands an outline prompt into a multi‑section long‑form document with headings and paragraphs.
AI Developer: A feature that converts a design brief into ready‑to‑copy HTML, CSS (and optionally JavaScript) code for a website.

Models

Nano Banana: The image‑generation model GenSpark uses to create pictures from text descriptions.
Gemini VO3: One of the video‑generation models that can synthesize short clips based on a textual prompt.

Agents

Claw: GenSpark’s chat‑based AI agent that you can command via Slack, WhatsApp or Telegram to run research, create documents and more.

Tools

Speakly: A voice‑to‑text tool that cleans up spoken input into a clear written prompt for GenSpark agents.

Collaboration

Hub: A shared workspace where you can collect related documents, sheets, slides, designs and videos for a project.

Commands

Mark to edit: An instruction you give to an AI agent to modify a specific element in an image or slide, such as changing a jacket’s color.

Perplexity Max 12

Tool

Perplexity Computer: A feature that breaks a user’s goal into sub‑tasks and runs the best AI model for each task in parallel.

Prompting

Outcome‑Focused Prompting: Writing a prompt that describes the desired final product instead of step‑by‑step instructions, letting the system decide how to achieve it.
Deep Research Mode: A toggle that tells Perplexity to produce an in‑depth, multi‑section report with tables and citations automatically.

Features

Perplexity Profile: A saved set of custom instructions that automatically apply to every new conversation you start.
Focus Feature: An option that limits searches to a chosen source category such as Academic, News, Social or Web for more relevant answers.
Collections: Named groups that store related chats and an overarching role prompt so future conversations inherit the same context.
Attach PDFs: A button that lets you upload PDF files to a chat so the AI can read and cite information from them.

Automation

Scheduled Tasks: A setting that creates a recurring query you define, delivering results at chosen intervals via email or notification.

Collaboration

Spaces Collaboration: Shared workspaces where multiple users can add chats, files, and prompts to co‑author projects in real time.

Integration

Connectors: Integrations that link external services like Gmail or Google Drive so the AI can fetch or write data directly from them.

Tool Settings

Model Selection: A dropdown that lets you choose which underlying language model (e.g., GPT‑4, Claude) will answer a specific query.

Interface

Voice & Dictation: A microphone icon that records spoken questions and can read answers aloud for hands‑free interaction.

Dokploy 12 lessons ↗

Provider

Hetzner Cloud: A German cloud service that provides virtual machines billed by the hour with data stored in the EU.

Concepts

project: A logical container in Hetzner Cloud used to group servers, networks and other resources together.

Server Types

CX33: A Hetzner server type that offers 4 virtual CPUs, 8 GB RAM and an 80 GB disk.

Authentication

SSH public key: A cryptographic key you paste into the Hetzner creation form so you can log in without a password.

Network

IPv4 address: The publicly reachable numeric address of your server that you use for SSH and web access.

Commands

`ssh root@<ip>`: A command that opens a secure shell session as the root user on the server whose IP replaces <ip>.

Tools

Docker: Software that runs applications inside isolated containers, used by Dokploy to host your services.
Traefik: A reverse‑proxy router that directs web traffic to your containers and can obtain HTTPS certificates automatically.
Postgres: An open‑source relational database that Dokploy can set up for your applications.

Interface

dashboard: A web interface served on port 3000 where you manage Dokploy projects, apps and settings.

DNS

A record: A DNS entry that maps a hostname to the server’s IPv4 address so traffic reaches your app.

Storage

S3‑compatible bucket: An object storage location that follows the S3 API, used by Dokploy to store backup zip files.