A starting path into AI

When people say AI today, they usually mean large language models (LLMs) and the apps around them: chatbots, coding assistants, image tools, and APIs your scripts call. The model predicts the next chunk of text from patterns in training data. It does not keep a verified copy of your syllabus or last week’s lab unless the product puts that text in front of it.

That is why answers can sound confident and still be wrong. Fluent nonsense is a hallucination. Models also skip steps, mirror your tone, and quietly fail on math, citations, and “did this code run?” Treat output as a draft you can explain, test, and fix.

If health, money, legal risk, or academic integrity is on the line, check a real source or ask a human who is accountable. The model will not take the hit for a bad submission. You will.

Start with the chat loop. A prompt is what you send. Prompting is shaping that input on purpose. A completion is what comes back. A token is a chunk of text the system counts for length and billing. The context window is how much the model can see at once: your prompt, history, and room for the reply. System prompts (or custom instructions) are standing rules for the session, like “be a tutor” or “never invent citations.” Temperature and top-p control how wander-y the sampling feels. Many UIs hide those knobs.

Behind the chat: inference is running a trained model to get an answer. Training built the weights. Fine-tuning is extra training on a narrower set. Embeddings turn text into number vectors so software can find similar meaning. RAG (retrieval-augmented generation) fetches useful docs, then generates with those docs in the prompt. Tool use means the model asks your app to run something mid-answer (search, calculator, API). An agent loops model plus tools until some stop condition. Multimodal means text plus images, and sometimes audio or video.

Buying and running models: open weights means you can download the files. A closed model usually only shows up as a website or API. Quantization compresses weights (Q4, GGUF, and friends) so weaker hardware can run them. A model card is the publisher’s notes on use and limits. An eval or benchmark is a scored test set. Useful, gameable, never the whole story. A harness is the setup around the model that runs and judges the work.

In coding editors you will also hear skill (a task playbook) and AGENTS.md (standing project rules). They are not the same. See the section below. You do not need this list memorized tonight. You need to recognize the words when Tools pages and job posts use them.

Context is everything the model can see for this answer: your latest message, earlier turns, attached files, retrieved docs, tool results, and system instructions. If it is not in that pile, the model is guessing from training patterns. It is not looking up your life.

Every model has a context window, a hard size limit in tokens. Paste too much and the product chops older turns, or the useful sentence gets buried and the answer gets worse. Long threads feel convenient and still lose the plot. That is a capacity limit, not proof you are bad at prompting.

People say “memory” for a few different things. The chat thread itself. A product Memory feature that stores facts about you. Custom instructions you saved. Notes you paste at the top of a new chat. RAG docs fetched for this question only. When someone says the AI forgot, usually one of those layers was empty, truncated, wrong, or never updated after you changed your mind.

Three interview traps: training data is frozen into the weights. You cannot “remind” a model of a private repo unless you put that text in context. Vendor chat logs are a privacy question, not long-term understanding. Local tools like Ollama keep more of the stack on your machine. Cloud chats trade convenience for upload risk. Follow school rules either way.

Practical habits: new topic, new chat. Put the important facts in the current message (course, language version, “no external libraries”). If Memory saved something wrong, edit or delete it. When code breaks, paste the error and the failing snippet. “Fix my project” with no context wastes everyone’s time.

A harness is everything around the model that makes a run mean something: how you call it, what you feed it, what you forbid, and how you decide the answer is good enough. The model writes text. The harness is the test bench: UI, prompts, rubrics, unit tests, safety filters, logging. Without one, “this model is amazing” usually means one lucky screenshot.

Build a tiny one in an evening. Write three prompts you care about: explain a concept from class, debug a short failing snippet, outline a weekend project. Run them on two tools from the Tools index. Score each answer 1 to 5 for correctness, clarity, and whether you could defend it to a professor. Save the prompts. Reuse them when you try the next app. Ugly is fine. Consistency is the point.

Your coding course already ships a harness: autograders and unit tests. If an assistant wrote the code and tests fail, listen. When someone posts a ranking, ask which harness, which version, and which date. The Comparisons pages here are written notes between tools. Your own three saved prompts are a second check you control, for homework and whichever app you try next.

Open weights means you can download the model files and run them yourself, often through Ollama or LM Studio (see Run locally and Open weights in the Tools index). That unlocks privacy experiments, offline practice, and a feel for how slow or fast generation is on a laptop.

Open weights is not automatically open source. Check the license, whether training code and data are public (often they are not), and what the model card claims. Read before you ship a public repo.

Parameter count (7B, 70B) is a rough capacity dial. Bigger can reason better and eats more RAM. Quantization compresses weights for consumer hardware. Lower quant usually means smaller, faster, and weaker on hard tasks. If a giant model at a tiny quant sounds broken, try a smaller model at a higher quant first.

Closed cloud models still win for many students on hard reasoning and “it just works.” Local wins when you should not upload the data, or when you want to feel inference. A common pattern: draft locally, then escalate hard questions to a stronger cloud model with a cleaned prompt. Start with a 7B or 8B-class instruct model before you download a giant.

A model card is the publisher’s homework: intended uses, limits, safety notes, sometimes scores. Skim it like a syllabus, especially the out-of-scope part. No card and only Discord hype? Assume you are the beta tester.

Benchmarks help you shortlist. They also get gamed. Leaderboards shuffle weekly, and your homework is not MMLU. Use benchmarks to narrow the field. Use your three-prompt harness to choose. On social posts, check the date, model version, and whether the demo was cherry-picked.

Cloud chat and APIs (ChatGPT, Claude.ai, Gemini, and peers): nothing to install, strong models, usage caps, and data policies you have to read for school work. Good for first practice and hard questions.

Local runners (Ollama, LM Studio, and peers): models live on your disk. Speed depends on your hardware. Privacy is stronger if you keep cloud extras off. Pair them with open-weight models from the catalog.

If your syllabus forbids uploading assignments, local or school-approved tools matter more than leaderboard scores. If your laptop is weak, cloud is hardware reality, not cheating. Pathways on the Tools index exist so you pick one lane first instead of twelve apps.

A chat UI is one way in. An API is another: your code sends messages and gets completions. API keys prove it is you. Treat them like passwords. Never commit them to GitHub, never paste them in public Discord, never put them in client-side frontend code.

Bills spike from long context, retries, and agent loops that call tools while you are away. Set spending limits when a vendor offers them. Student plans and rate limits matter. For class projects, prefer patterns your instructor already allows.

Say who it is for, what you need, the constraints (length, format, language, libraries), and what done looks like. Vague wishes get vague essays. Paste the error. Paste the function. Paste the rubric bullet.

Vibe prompting means describing the feel and goal in normal language (“calm lab handout, not a sales page”) while you still add constraints and check the result. Useful for sketches. Not a free pass to skip reading the output.

Work in tight loops: ask, check, fix one issue, repeat. If the thread is full of bad assumptions, start a new chat with a clearer brief. Ask for structure when you need to reuse the answer. Ask it to flag guesses, then verify those parts yourself.

Embeddings turn text into vectors so software can find nearby meaning. RAG pulls chunks from your notes, PDFs, or code, puts them in the prompt, then generates. The model can still misread a chunk. At least the grounding text is yours to inspect.

“Chat with PDF” products are RAG with a friendly face. They fail when chunking is bad, the wrong page comes back, or you ask something the doc never answers. Prefer tools that show the cited passage. RAG is not fine-tuning. Fine-tuning changes weights. RAG changes what is in context this time. Most student projects should try RAG or plain paste before fine-tuning ever shows up.

Prompting steers one session. RAG adds your sources into context. Fine-tuning specializes weights with curated examples. That means data work, evals, and maintenance. Teams reach for fine-tuning when prompting plus retrieval are not enough and they can own the ops cost.

In job posts, “prompt engineering” and “RAG” show up a lot for junior-adjacent work. “Fine-tuning” and “agents” often mean more responsibility. Read the stack, not only the buzzword.

Plain chat: you ask, it answers, you decide next. A workflow is steps you designed where the model fills a step. An agent may choose tools and loop until it thinks it is done. Agents are powerful, harder to predict, and can burn tokens or break things.

Most learning should start with chat and workflows. Add agent features when you can watch the tool calls and undo the mess. Coding agents in editors are only as good as your tests and review habits. That is the harness again.

In AI coding editors, two files get mixed up. AGENTS.md (often at the repo root) is standing project policy: how agents should behave in this codebase. Stack preferences, what not to touch, how to run tests. Other products call the same idea Cursor rules or custom instructions. Always-on for that repo. Not a one-off tutorial.

A skill is a modular playbook for a kind of work (UI review, performance pass, a framework setup), often a short SKILL.md plus optional extras. Load it when the task matches. Do not dump every skill into every chat. That wastes the context window.

AGENTS.md answers how we work here. Skills answer how we do this type of task. Keep the root file short and stable. Keep skills focused and optional. Your prompt still names the goal. Your tests still decide whether the result is good. Builder tools on the Tools index are where these show up first. Chat-only apps usually only have custom instructions.

Multimodal models accept or produce more than text, commonly images in and images or UI out. Useful for a whiteboard photo or a layout sketch. Same rule as text: fluent does not mean correct. Check the numbers yourself.

Coding assistants are specialized harnesses over LLMs: repo context, diffs, terminals. They shine when you provide the failing test. They fail when you accept a patch you cannot explain.

Follow your course and campus AI policy first. Some classes ban generators. Some require disclosure. Some allow outlining only. When in doubt, ask the instructor in writing.

Never paste secrets into random web UIs: API keys, passwords, unpublished research, other students’ private data. Prefer local models for sensitive drafts. Do not outsource take-home exams if that is banned.

Models can produce biased, toxic, or overconfident content. If an answer targets people or makes medical or legal claims, slow down. Your name is on the work.

AI detectors and Turnitin-style tools are imperfect. A “human” score is not a hall pass. A “AI” flag is not automatic proof of cheating. Your syllabus and instructor decide what is allowed. When disclosure is required, say what you used and what you changed.

The Tools index is large on purpose. Do not install everything. Pick a pathway: new-to-AI chat, local or open weights, or builders. Open two tool pages max, run your three-prompt harness, then decide. Kind labels are maps, not trophies.

Comparisons are side-by-side product notes. Use them when two names keep fighting in your head. Explorations are deeper essays. On each tool page you get official links, what it is best for, and a tip. We do not host the models. We help you choose where to go next.

Experience is a project you can explain end to end: inputs, what the model did, how you checked it, what broke. Quiz yourself from lecture notes with a local model. Call one API from a tiny script. Compare two open models on the same harness and write a one-page lab note.

Document failures. “I tried twelve apps” impresses no one. “I measured X on prompts A, B, and C and picked Y because Z” is the kind of note that survives an internship interview. Depth beats a pile of unused accounts.

It does not “know your repo” unless the product indexed it or you pasted it. Bigger context does not always win. Noisy context loses. Open does not mean safe or legal for anything. The leaderboard winner is best for that harness, not necessarily your homework. Agents do not replace learning CS. One perfect prompt does not solve everything. Loops and harnesses beat hoping harder. Root AGENTS.md is not a skill.

Stay curious. Drop the magic thinking. That is how you adapt when next semester’s tools rename themselves again.