Glossary

A file that tells Git which files to NOT track or upload. Used for passwords, downloaded libraries, and machine-specific settings.

Your .env file with API keys goes in .gitignore so it never gets uploaded to GitHub where strangers could see it.

Building your site so it works for everyone — screen readers, keyboard navigation, high-contrast mode. Not a feature you add later. It's how the web is supposed to work.

Curb cuts were designed for wheelchairs. They also help parents with strollers, delivery workers with carts, and anyone dragging luggage. Accessibility improvements make things better for everyone — not just the people you designed them for.

The repeating cycle that makes an AI agent work: it observes the current state (reads files, checks errors), thinks about what to do next (plans a step), acts (writes code, runs a command), then observes the result and repeats. This loop runs until the task is done or it gets stuck.

You say 'Fix the failing tests.' The agent reads the test output (Observe), identifies the broken assertion (Think), edits the function (Act), runs tests again (Observe), sees one more failure (Think), fixes that too (Act). Each cycle gets closer to done.

AI that can take actions autonomously — not just answering questions, but planning steps, using tools, reading files, running code, and making decisions in a loop. Instead of one prompt → one response, agentic AI works through multi-step tasks like a junior developer following instructions.

You say "Fix the bug in my login form." Instead of just suggesting code, an agentic AI reads your files, identifies the bug, writes a fix, runs tests, and reports back. Tools like Cursor, GitHub Copilot Workspace, and Gemini Code Assist work this way.

Software that uses AI to help you write, review, and debug code. These range from autocomplete assistants to full agentic environments that can work through entire features.

GitHub Copilot suggests code as you type. Cursor is an AI-native code editor that can edit multiple files. Gemini Code Assist, Amazon Q, and ChatGPT's code interpreter are other major players. The landscape changes fast.

Tools that track how people use your site — what pages they visit, where they come from, how long they stay, where they leave. The difference between guessing what works and knowing.

You published ten articles. Four get traffic. Two get read past the first paragraph. Without analytics, you'd keep writing all ten types. With them, you write more of the two that actually land.

Something you specifically don't do — a practice, habit, or approach that you've learned to avoid. In voice profiling, your anti-patterns ('I never use exclamation marks for enthusiasm') are often more useful than your patterns because they give AI clear constraints.

In code: using global variables everywhere is an anti-pattern. In writing: starting every paragraph with 'I' is an anti-pattern. Naming what NOT to do is often clearer than describing what TO do.

A defined set of rules for how different pieces of software talk to each other. You don't need to know how the other system works internally — you just need to know what to ask for and what you'll get back.

Like a power outlet. You don't need to know how the power plant works or what's behind the wall. You just need to know that if you plug your specific plug into this specific hole, you get electricity. An API is the hole software provides so other tools can get what they need without seeing the mess inside.

An ordered collection of items, accessed by position. Positions start at 0, not 1 (a common gotcha).

A grocery list: ["milk", "eggs", "bread"]. "milk" is at position 0, "eggs" at position 1.

A way to handle tasks that take time (like fetching data from a server) without freezing the rest of the app. Async doesn't mean slow — it means polite. It says 'this might take a second, so keep doing other things while I wait.' Await is the pause that says 'okay, now I actually need that data before the next step.'

You order coffee and a bagel. Synchronous: you stand at the counter staring at the toaster until the bagel is done, then order your coffee. Async: you order both, sit down, and they bring each one when it's ready. Your app works the same way.

Proving who you are. The process of verifying identity — "Are you really who you claim to be?"

Entering your email and password to log in. Scanning your fingerprint to unlock your phone. Showing your ID at a bar.

Determining what you're allowed to do after identity is confirmed. Authentication = "who are you?" Authorization = "what can you access?"

You badge into the office building (authentication). But only managers can enter the server room (authorization).

The range of how much independence you give an AI agent, from fully manual (you approve every action) to fully autonomous (it runs without asking). Most productive setups are somewhere in the middle — autonomous for safe operations, human-approved for irreversible ones.

Level 1: Autocomplete (suggests the next word). Level 2: Copilot (suggests whole functions, you accept/reject). Level 3: Agent with approval (plans and executes, pauses for confirmation). Level 4: Fully autonomous (runs unsupervised). Most AI coding tools today operate at Level 2-3.

The brain behind the scenes. It handles business logic, verifies passwords, processes data, and talks to the database. Users never see this directly.

When you log into your bank, the backend checks your password, retrieves your account balance, and sends that info to the frontend to display.

Systematic errors in an AI's output that come from gaps, skews, or prejudices in its training data. The AI isn't being malicious — it learned from a lopsided dataset and reproduces those patterns.

If you learned world history only from books written in 1950s America, your view of global events would be heavily skewed. AI trained on biased data produces biased outputs — not intentionally, but systematically.

Repetitive, standard code that every project needs but isn't unique. Config files, folder structures, basic setup. AI is excellent at generating boilerplate.

Every web app needs an HTML skeleton, a CSS file, and some configuration. That's all boilerplate — necessary but not creative.

A value that can only be true or false. The simplest type of data — a yes/no switch.

isLoggedIn = true, hasPermission = false. Like a light switch: it's either on or off, nothing in between.

An alternate timeline for your code. Work on a new feature without risking the stable version. If it works, merge it back. If not, delete the branch.

Like drafting a chapter in a separate document. You edit freely without changing the published version. When it's ready, you merge it into the book.

A document that defines what you're building, who it's for, and how you'll know it's done — written before anyone touches code. Forces you to think through scope and priorities so you don't build the wrong thing at full speed.

Without a BRD, you start coding immediately and realize three weeks in that you and the client had two completely different features in mind. The BRD is the meeting you have before the build starts, not after it derails.

An error in the code causing unexpected behavior. The term dates back to a literal moth found in a 1940s computer relay.

A shopping cart that shows a total of $0 when you have 3 items — the math logic has a bug.

Storing a copy of frequently requested data so you don't have to fetch it from scratch every time. Trades freshness for speed.

Your browser caches images from websites you visit. The second visit loads faster because the images are served from local storage instead of re-downloaded.

A prompting technique where you ask the AI to explain its step-by-step reasoning before giving a final answer. This dramatically improves accuracy for complex logic, math, and multi-step problems.

Instead of 'What's the answer?', you say 'Think through this step by step.' Like a math teacher saying 'Show your work!' — writing out each step catches mistakes the AI would otherwise make by jumping to conclusions.

A record of what changed between versions. Good changelogs tell users what's different and why it matters. Bad ones list commit hashes nobody understands.

Good: "Fixed a bug where discounts weren't applied to the first item." Bad: "refactor: updated applyDiscount util fn re: #847." One helps users. The other helps nobody — including future you.

Continuous Integration / Continuous Deployment — automated pipelines that test and deploy your code whenever you push changes. If tests fail, deployment is blocked.

An assembly line with a quality check station. Every time code is pushed: build → test → if tests pass → deploy to production. All automatic.

A blueprint for creating things with shared properties. A class defines the template; objects are individual items created from that template.

A "Car" class might define that every car has a make, model, and year. A specific car — say a 2024 Honda Civic — is an object built from that class.

Having another person (or AI) read your code before it ships. Catches bugs, improves readability, and spreads knowledge across the team. The most underrated quality tool in software.

You wrote a clever one-liner that works perfectly. A reviewer looks at it and says "I have no idea what this does." That's the point. If a human can't read it, maintaining it later will be a nightmare.

A saved snapshot of your code at a specific point in time, with a message describing what changed. Each commit is a checkpoint you can return to.

Like hitting "save" in a video game before a boss fight. If things go wrong, you reload from that save. git commit -m "add login form" saves that checkpoint.

A self-contained, reusable piece of a user interface. Instead of building one massive page, you build small pieces — a button, a search bar, a card — and snap them together like LEGO bricks.

A "UserCard" component might show an avatar, name, and email. You build it once, then reuse it 50 times in a user directory page without duplicating code.

Code that makes decisions based on whether something is true or false.

"If the user is logged in, show the dashboard. Otherwise, show the login page." The app takes a different path depending on the condition.

A pre-packaged box containing your app plus everything it needs to run. Guarantees "if it works on my machine, it works on any machine."

Like shipping a product in a box with batteries included — the recipient doesn't need to find the right batteries separately.

When an AI session slowly 'forgets' or deprioritizes your early instructions as the conversation gets longer. Different from running out of context window — the instructions are still technically visible, but the AI stops following them.

You start by saying 'Use TypeScript and Tailwind for everything.' By message #40, the AI is generating plain JavaScript with inline styles. It didn't forget — it just lost focus. The fix: restate important constraints periodically.

The AI's total working memory for a conversation. It can only "see" a limited amount of text at once. Once exceeded, earlier messages silently drop off — the AI doesn't tell you it forgot something.

Like a desk that fits 20 pages. When you add page 21, page 1 falls off the back. The AI loses its earliest context without warning — which is why long conversations eventually go off the rails.

The four basic operations for data: Create, Read, Update, Delete. Nearly every app is a CRUD app at its core.

A contacts app: Create a new contact, Read the list, Update a phone number, Delete an old entry. That's CRUD.

The language that controls how a webpage looks — colors, fonts, spacing, layouts, and animations. HTML defines what's on the page; CSS defines how it appears.

Without CSS, a webpage looks like a college term paper — just text and links. CSS transforms it into a modern, polished interface with colors, spacing, and responsive layouts.

Persistent rules you set for an AI tool (like ChatGPT or Claude) that apply to every conversation automatically. A natural home for your voice profile — set it once, and every response reflects your preferences.

Setting 'Always use TypeScript, never use semicolons, prefer functional components' as custom instructions means you don't have to repeat these preferences in every new chat.

Permanent storage for data — the filing cabinet of your application. Without a database, all data disappears when the app restarts.

When you save a contact in your phone, that name and number go into a database. Even if your phone restarts, the contacts are still there.

The process of finding and fixing bugs. It's detective work — reading error messages, adding temporary print statements, and narrowing down where things go wrong. AI is surprisingly good at debugging when you give it the error message and the relevant code.

Your login form submits but nothing happens. You check the browser console, see a 401 error, trace it to the API endpoint, and discover the auth token expired. That investigation is debugging.

Someone else's code that your project relies on. Modern software is basically a tower built on other people's towers. Efficient — until someone removes a block near the bottom.

Your app uses a library for date formatting. That library depends on another library for time zones. That one depends on a locale package. One Tuesday morning, the locale maintainer deletes their package and your entire build breaks. This has actually happened.

Moving your app from your computer to a server on the internet so other people can use it. Like moving from rehearsal to opening night.

You build a website on your laptop, then deploy it to Vercel or Netlify. Now anyone with the URL can see it.

The phonebook of the internet. It translates human-friendly names (like google.com) into the computer-friendly IP addresses (like 142.250.190.46) that actually locate servers. You never think about it until it breaks.

You know your friend as 'Steve,' but your phone dials 555-0123. If Steve changes his number but the phonebook hasn't updated yet, you end up calling a stranger. That's a DNS propagation issue — and it's why your new domain sometimes takes 48 hours to 'work.'

A way to convert text (or images, audio) into a list of numbers that capture its meaning. Similar concepts get similar numbers, which is how AI "understands" that related things are related.

"king" and "queen" would have embeddings close together because they're related concepts. "king" and "refrigerator" would be far apart. It's how machines measure conceptual distance.

Scrambling data so only someone with the right key can read it. The data is useless to anyone who intercepts it without the key.

HTTPS encrypts everything between your browser and a website. Even if someone intercepts the data, it looks like random gibberish without the decryption key.

Tests that simulate a real user doing real things — clicking buttons, filling forms, navigating pages. The slowest and most expensive tests, but the closest to what actually happens in production.

A bot walks into your site, creates an account, adds something to a cart, checks out, and verifies the confirmation email. If any step breaks, you know before your users do. Ideally.

A specific URL in an API that does one job. Like individual service counters at a government office — one for licenses, one for passports.

/api/orders might return all orders, while /api/orders/123 returns just order #123.

Secret settings stored outside the code — API keys, passwords, and database URLs that you don't want accidentally shared. Stored in a .env file locally (never uploaded to GitHub). When you deploy, services like Vercel, AWS, and Netlify have their own dashboards for managing these safely.

Instead of writing your API key directly in code (dangerous!), you put API_KEY=abc123 in a .env file and reference it as process.env.API_KEY.

The practice of anticipating what can go wrong and writing code that gracefully handles failures instead of crashing. Good error handling shows users helpful messages and recovers when possible.

Instead of the whole page going blank when the server is down, error handling shows: 'We couldn't load your data. Try again in a moment.' The user knows what happened and what to do next.

Training an existing AI model on your own specialized data to make it better at a specific task. Expensive and complex — typically done by teams, not individuals.

A general AI model fine-tuned on medical data becomes better at understanding medical terminology. The base model stays the same; it just learns a specialty.

Pre-written code so you don't build everything from scratch. A library is a toolbox you pick from. A framework is a pre-built structure you fill in.

An electric drill (library) — you decide when to use it. An IKEA kit with instructions (framework) — it tells you the structure, you assemble the pieces.

What the user sees and interacts with — buttons, text, layouts, animations. Think of it as the storefront of a shop: the signs, the displays, and the door handle.

When you open Instagram and scroll your feed, everything you see — the photos, the like button, the search bar — is the frontend.

Both the frontend and backend together. A "full-stack application" has a user interface and server-side logic working together.

An online store is full-stack: the product pages (frontend) + the checkout logic, payment processing, and inventory database (backend).

A reusable mini-factory. It takes inputs, does a specific job, and usually returns an output. Functions prevent you from writing the same code over and over. Technical note: a "method" is just a function that belongs to a class or object — the concept is identical.

calculateTip(mealCost, tipPercent) takes your meal total and tip percentage, does the math, and returns the tip amount. You define it once, use it everywhere.

A version control system that tracks every change to your code. It runs locally on your computer and keeps a complete history of who changed what and when. Git is the tool; GitHub is the cloud platform built on top of it.

Without Git, collaborating means emailing files named "final_v2_REAL_final.zip." With Git, every change is logged, reversible, and mergeable. It's the undo button for your entire project history.

A 'black box' AI gives you an answer but hides how it got there — you can't see its reasoning. A 'glass box' (or 'white box') shows its work: the steps it considered, the tools it called, and why it made each decision. As a director, always prefer glass box tools because you can catch mistakes mid-process instead of only seeing the wrong final result.

Black box: 'Here's your updated code.' (Did it even read the right file?) Glass box: 'I read auth.py, found the expired token check on line 42, and replaced the hardcoded timeout with a config variable.' You can verify every step.

Giving the AI real, verified information to base its answers on instead of relying on its training data. Grounded responses are more accurate because the AI has actual source material to reference rather than generating from patterns.

Instead of asking "Write me an API for our user table," you paste your actual database schema and say "Write an API that matches this schema exactly." The AI is now grounded in your real data.

Constraints built into an AI agent to prevent it from doing harmful, irreversible, or out-of-scope actions. Like safety rails on a highway — the agent can drive freely within the lanes but can't go off the cliff. Good guardrails protect without being so restrictive that the agent becomes useless.

A coding agent might have guardrails that prevent it from: deleting production databases, exposing API keys in code, making external network requests without approval, or modifying files outside the project directory. It can still do its job — it just can't do dangerous things.

When AI confidently generates something that doesn't exist — fake functions, fake libraries, fake documentation, fake citations. The output looks authoritative and syntactically correct, but the content is fabricated. This happens because AI predicts plausible text, not verified facts.

The AI might tell you to use someLibrary.magicFunction() with perfect syntax and a detailed explanation — but magicFunction() was never a real thing. Always verify AI claims against official docs.

A one-way transformation that converts data into a fixed-length string of characters. Unlike encryption, hashing cannot be reversed — it's used for storing passwords securely, verifying data integrity, and tracking changes in version control.

When you create an account, the site hashes your password before storing it. Even the site never knows your actual password. It's also how Git knows if you changed a single comma in a 10,000-line file — if the content changes, the hash changes. The ultimate digital fingerprint.

The skeleton of every webpage. HTML defines the structure and content — headings, paragraphs, images, links, buttons — using tags like <h1>, <p>, <img>, and <a>. It doesn't handle how things look (that's CSS) or how they behave (that's JavaScript).

<h1>Welcome</h1> creates a main heading. <p>Hello world</p> creates a paragraph. <a href="/about">About</a> creates a clickable link. You rarely write HTML by hand anymore — AI generates it.

A design pattern where the AI agent pauses at critical decision points and asks for human approval before proceeding. The human reviews the plan, approves or redirects, and the agent continues. This balances AI speed with human judgment.

The agent says: 'I'm about to delete the old database table and migrate to the new schema. This is irreversible. Proceed?' You review the migration plan, approve it, and the agent executes. Without HITL, it would have just done it — and if wrong, you'd lose data.

The app where you write code. An IDE (Integrated Development Environment) bundles a code editor with debugging tools, file management, and extensions. VS Code is the most popular. AI-native editors like Cursor add AI features directly into the editing experience.

VS Code is like a writer's studio — it has your manuscript (code), spell-check (linting), a library (extensions), and now an AI co-author. You don't need to memorize all its features on day one.

The persistent, nagging suspicion that you're the only person who doesn't know what's going on — and that you're moments away from being exposed as a fraud. In tech, this isn't a bug. It's a feature. Everyone feels it.

Senior engineers with 20 years of experience still Google 'how to center a div in CSS' on a weekly basis. The only difference between a junior and a senior is that the senior doesn't panic when they don't know the answer. Working with AI makes this worse — the machine seems to know everything, and you seem to know nothing. It's lying. So are you.

When a trained AI model puts its learning into action — processing new input and generating a response. Training is the learning phase; inference is the using-what-you-learned phase. Every time you send a prompt, the AI is performing inference.

Training is the semester spent studying textbooks. Inference is sitting down for the final exam, reading a new question you've never seen, and using your knowledge to write an answer.

Tests that verify multiple pieces work together — the API talks to the database, the frontend talks to the API. Individual parts can pass their own tests and still break when connected.

Every function works perfectly in isolation. Then you plug them together and discover the login form sends data the API doesn't expect. Individual A-students, group-project F.

A to-do item or bug report on GitHub. Can be assigned to people, labeled by priority, and linked to the code that fixes them.

"Login button doesn't work on Safari" would be filed as an Issue. A developer picks it up, creates a branch, fixes it, and links their PR to close the Issue.

JavaScript Object Notation — the standard text format for sending data between systems. It's structured as labeled values, readable by both humans and machines.

{ "name": "Alex", "age": 30, "isAdmin": true } — each piece of data has a label and a value, like a form with named fields.

A database that maps relationships between things, not just the things themselves. It stores "A is connected to B because of C" — making it possible to discover indirect connections.

Google's Knowledge Graph powers those info panels in search results. Search "Tom Hanks" and it knows his movies, co-stars, awards — all connected. It didn't just look up Tom Hanks; it traversed relationships.

When AI generates partial code with placeholders like '// ... existing code ...' or '// rest of implementation here' instead of writing the complete solution. This forces you to manually reconstruct what should have been generated.

You ask for a complete login form and get the HTML structure but '// ... add validation logic here ...' for the important part. The fix: explicitly say 'Write the complete implementation. Do not use placeholders or comments like ... existing code.'

Automatic code quality checks that catch style issues, potential bugs, and bad patterns before the code runs. Like spell-check for code.

A linter might flag: "You declared a variable but never used it" or "This line is 300 characters long — consider breaking it up." Catches mistakes before they become bugs.

The type of AI behind tools like ChatGPT, Claude, and Gemini. Trained on massive amounts of text, it predicts the most likely next word given everything before it. It's a pattern-matching engine, not a thinking engine — it generates plausible text, not verified truth.

When you ask an LLM to write code, it's generating the most statistically likely code given your prompt — like a supercharged, context-aware autocomplete trained on billions of pages.

Your own computer acting as a server. When you see http://localhost:3000, the app is running on your machine, not on the internet. Only you can access it.

During development, you run your app on localhost to test it. It's like rehearsing a play in your living room before performing on stage.

Code that repeats a task a specific number of times or until a condition is met.

"For each student in the class, print their name." The loop runs once per student, then stops.

The primary branch — the "official" version. You typically don't work directly on main; you create branches and merge back.

The published book is "main." You write new chapters on separate branches, review them, then merge the finished chapter into the published edition.

A simple text formatting language used everywhere in software — README files, documentation, chat messages, and AI conversations. Uses symbols like # for headings, ** for bold, and - for lists. Much simpler than HTML.

# My Title becomes a heading. **bold text** becomes bold. - item becomes a bullet point. You're probably already using Markdown in Slack, Discord, or GitHub without knowing it.

An open standard that lets AI models connect to external tools, databases, and APIs in a standardized way. Think of it as USB for AI — instead of each tool needing a custom integration, MCP provides one universal plug.

With MCP, an AI assistant can query your database, read your GitHub issues, check your calendar, and send a Slack message — all through the same standardized protocol instead of separate custom integrations.

When two people change the same lines and Git can't automatically decide which version to keep. You resolve it manually by choosing which changes to keep.

Two authors edit the same paragraph. One changes "red" to "blue," the other changes "red" to "green." Git asks: which one do you want?

Data about your data — page titles, descriptions, image alt text, author info. Invisible to most visitors, but it's what search engines and social platforms read to decide what your page is.

The label on a shipping box. Your users see the contents. Google sees the label. If the label says nothing, the package goes nowhere.

Code that sits between the request and the response — a checkpoint that runs before the main logic. Used for logging, authentication checks, and data validation.

A bouncer at a club entrance (middleware) checks your ID before you reach the dance floor (the actual endpoint). If your ID is bad, you never get in.

A controlled, versioned change to a database's structure. Instead of manually editing the database, you write a script that makes the change repeatably and reversibly.

Need to add a "phone number" column to your users table? Write a migration. If it breaks, roll it back. Like having an undo button for database changes.

Replacing a real dependency with a fake version during tests. You don't want your test suite charging real credit cards or sending real emails every time you hit "run."

Your code calls a payment API. In tests, a mock stands in and says "yep, payment went through" — so you can test your logic without the side effects. Or the invoice.

The specific version of AI you're using. Different models have different strengths, speeds, costs, and knowledge cutoff dates. Choosing the right model for the right task matters.

GPT-4o, Claude Sonnet, Gemini Flash are all different models. Like choosing between a sports car (fast, expensive) and a sedan (reliable, cheaper) for different jobs.

Architectures where multiple specialized AI agents collaborate on a task, each with a different role. Instead of one generalist agent doing everything, you have specialists — one plans, one codes, one reviews, one tests — coordinated by an orchestrator.

A coding team of agents: a 'Planner' decomposes the task, a 'Coder' writes the implementation, a 'Reviewer' checks for bugs and style, and a 'Tester' verifies it works. Just like a real dev team, but running in seconds.

AI that can understand and generate more than just text — it can process images, audio, video, and code simultaneously. Instead of being text-only, multimodal models can "see" screenshots, "hear" audio, and reason across different types of content.

You screenshot a website and ask "Recreate this layout in React." A multimodal AI can see the image, understand the design, and generate the code — no need to describe every element in words.

A computing system inspired by the brain's structure. It consists of layers of connected nodes that process data and learn to recognize patterns. Neural networks are the foundation under every modern AI model.

Just as your brain strengthens pathways the more you practice catching a ball, a neural network adjusts its internal connections as it learns from millions of examples. The more data it sees, the better its pattern recognition.

A standard that lets you log in to one service using your existing account from another.

"Sign in with Google" on a third-party website — you don't create a new password. Google confirms your identity and the website trusts it.

Special metadata tags that control how your page looks when shared on social media. Without them, Twitter and Discord show a bare URL. With them, you get a rich preview with an image, title, and description.

You share your new project on Twitter. Without Open Graph tags, it's a plain link nobody clicks. With them, it's a preview card that actually looks like you tried. First impressions happen before anyone visits.

Software whose code is publicly available for anyone to view, use, modify, and share. Most AI tools, frameworks, and libraries you'll use are open source — meaning a global community builds and maintains them, not a single company.

React, Python, Linux, VS Code, and even many AI models are open source. You can read the actual code, report bugs, or suggest improvements.

The app store for code libraries. Instead of downloading files manually, you use a command to install what you need.

npm install express (JavaScript) or pip install flask (Python) — one command downloads the library and its own dependencies.

An agent's ability to break a complex request into smaller, ordered steps before executing. Good planning means the agent tackles dependencies first, tests incrementally, and doesn't try to do everything at once. Bad planning leads to cascading failures.

You say 'Add user authentication.' A well-planning agent breaks it into: 1) Create user model, 2) Add registration endpoint, 3) Add login endpoint, 4) Add auth middleware, 5) Protect routes, 6) Test each step. A poorly-planning one tries to write everything at once and misses edge cases.

A numbered door on a computer. Different apps use different ports to avoid conflicts, like offices in a building having different room numbers.

localhost:3000 means "my computer, door 3000." If another app is already using door 3000, you pick a different one like 3001.

The skill of writing instructions that get the best results from AI. Not just "what you say" but how you structure context, constraints, examples, and format to guide the output. The biggest lever you have for improving AI output quality.

Vague prompt: "Make a website." Engineered prompt: "Create a React component for a pricing table with 3 tiers. Use Tailwind CSS. Include a highlighted 'recommended' tier. Mobile-responsive." Same AI, vastly different results.

A formal request to merge your branch into main. It's also a built-in review process — others can comment on your changes before they're accepted.

Like submitting a document for review before it's published. Reviewers leave comments, request changes, and eventually approve the merge.

A pattern where AI searches a knowledge base (using embeddings + vector database) before answering, so it can reference real, up-to-date information instead of relying solely on its training data.

Instead of asking AI "What's our refund policy?" and hoping it knows, RAG first searches your company docs, finds the actual policy, and hands it to the AI: "Answer based on this document." Much more accurate.

The front page of a repository. Explains what the project is, how to install it, and how to use it. The first thing people see.

Like the back cover of a book — it tells you what's inside, who it's for, and how to get started.

A newer class of AI models (like OpenAI's o1/o3 or Gemini 2.5 Pro) that 'think' internally before answering — spending extra compute time on a hidden chain of thought. They're slower and more expensive but dramatically better at complex logic, math, and multi-step problems.

Standard model: instantly answers '42' (might be wrong for hard problems). Reasoning model: pauses for 10-30 seconds, works through the logic step by step internally, then gives a carefully considered answer. Like the difference between blurting out a guess and actually thinking it through.

Rewriting code to make it cleaner or more efficient without changing what it does. The outcome stays the same; the internals improve.

Reorganizing a messy closet — same clothes, better arrangement. A refactored kitchen puts utensils closer to where you cook.

When something that used to work breaks after a code change. The fix for Bug A accidentally creates Bug B. This is why automated tests exist — they catch what you forgot to re-check.

You fix the login page. Deployment goes smooth. Then customer support asks why the password reset emails stopped working. Welcome to your Friday night.

The folder that holds all the code, history, and documentation for a project. Every change ever made is recorded.

An open-source project like React has a public repo on GitHub where anyone can see the code, report issues, and suggest changes.

Building interfaces that automatically adjust to fit any screen size — phone, tablet, or 4K monitor. Uses flexible layouts and CSS media queries to reorganize content based on available space.

A three-column layout on desktop becomes a single scrollable column on mobile. The navigation bar collapses into a hamburger menu. Same content, different arrangement.

The most common style of API. Uses standard web addresses (URLs) and actions like GET (read), POST (create), PUT (update), DELETE (remove).

GET /api/users returns a list of users. POST /api/users creates a new one. DELETE /api/users/42 removes user #42. The URL defines the "what," the action defines the "how."

Undoing a change and returning to the previous working state. Can apply to code (reverting a commit), databases (undoing a migration), or deployments (switching back to the last stable version).

You deployed a new feature and it crashed the site. A rollback reverts to the last working version in minutes while you fix the bug. Always have a rollback plan.

Explaining your code or problem step-by-step to the AI — not to get it to write code, but to clarify your own thinking. Named after the original technique of explaining code to a rubber duck on your desk. AI makes this even more powerful because it can ask follow-up questions.

Instead of 'Fix my bug,' you say 'Let me walk you through what this code does line by line and you tell me where my logic breaks down.' Half the time, you realize the bug yourself while explaining it.

An isolated environment where you can experiment freely without affecting real data or production systems. Like a practice field — you can try anything without consequences.

Before testing changes on your live website, you test in a sandbox. If it breaks, no real users are affected. Payment APIs often have sandbox modes for testing with fake credit cards.

The code and infrastructure wrapped around a raw LLM that transforms it into a useful agent. The LLM is the brain; scaffolding is the nervous system, hands, and eyes. It includes prompt templates, tool integrations, memory management, error recovery, and output parsing.

ChatGPT the chatbot is an LLM with minimal scaffolding. Cursor is the same class of LLM with heavy scaffolding — file system access, code execution, diff generation, multi-file editing, and project-wide context. Same brain, radically different capabilities.

The blueprint for how data is organized. Defines what fields exist, what type each field holds, and which are required.

A "Users" schema might define: name (text, required), email (text, required), age (number, optional). Any data that doesn't match gets rejected.

What a variable can "see" — where in the code it's accessible. A variable created inside a function usually can't be used outside it.

A pass to the VIP lounge doesn't work in the parking garage. Each area has its own scope — its own set of things you can access.

When a project slowly grows beyond its original plan — one more feature, one more page, one more "quick" change — until it's twice the size and half-finished. The most common way projects fail isn't crashing. It's never shipping.

This site was supposed to be a few AI guides. Then it needed a glossary. Then dispatches. Then a toolkit widget. Then voice-calibrated examples for 135 glossary terms. It's 3 AM and I'm writing the definition of Scope Creep. You see the problem.

Search that understands meaning, not just matching exact words. Powered by embeddings and vector databases, it finds results based on what you meant, not just what you typed.

Searching "affordable places to eat near me" returns results for "budget restaurants nearby" and "cheap diners in your area" — it understands the intent, not just the keywords.

Structuring your content so search engines can find, understand, and rank it. Not a trick — it's clear titles, semantic HTML, and fast pages. The baseline stuff most people skip.

You write the best guide on the internet. Nobody reads it because the page title is "Untitled" and the meta description is blank. Google doesn't rank what it can't understand.

Giving an AI examples of your actual writing instead of describing your style with adjectives. 'Write casually' is vague and means different things to everyone. Pasting three paragraphs of your real writing gives the AI a concrete target to match.

Instead of 'write in a friendly, professional tone,' paste a paragraph you've written and say 'match this voice.' The AI picks up sentence length, word choice, rhythm, and personality — all without you describing any of it.

When AI-generated code runs without errors but produces wrong results. More dangerous than a crash because there's no error message to alert you — the output just quietly incorrect.

An AI writes a function to calculate discounts. It runs fine, no errors. But it's applying the discount to the wrong field, so every customer is overcharged by 10%. The code works — it's just wrong. The fix: always test with known inputs and check the output yourself.

An XML file that lists every page on your site, telling search engines what exists and how often it changes. Without one, crawlers wander your site and hope they find everything.

Handing a librarian a complete index vs. telling them "the books are around here somewhere, good luck." One gets your pages indexed. The other gets them ignored.

The error message a program prints when something goes wrong. It shows exactly where the error happened and the chain of functions that led to it. Learning to read these is one of the most valuable skills when working with AI-generated code.

TypeError: Cannot read property 'name' of undefined at line 42 in UserCard.js — tells you the variable doesn't exist at that line. Copy this into AI and ask it to explain.

Data that can change over time and affects what your app shows. When state changes, the UI updates to reflect it. Think of it as your app's "current mood" or "current situation" at any given moment.

A shopping cart's state includes which items are in it and the total price. When you add an item, the state changes, and the displayed total automatically updates.

Text data in code, always wrapped in quotes. Called a "string" because it's a string of individual characters.

"Hello, world" is a string. "12345" is also a string (text, not a number) — you can't do math with it until you convert it.

The tendency of AI to agree with your incorrect assumptions rather than correcting you. It wants to be 'helpful' so badly that it validates wrong ideas instead of pushing back.

You say 'I think this bug is in the database layer' and the AI agrees and starts rewriting your database code — even though the actual bug is in the frontend. It went along with your wrong diagnosis. The fix: ask 'What are ALL the possible causes?' before assuming.

The grammar rules of a programming language — where to put semicolons, brackets, and keywords. Each language has its own syntax.

In English, "I go store to the" is wrong grammar. In code, a missing bracket or quotation mark is a syntax error. You don't need to memorize syntax — AI handles it.

A hidden set of instructions given to an AI before a conversation starts. It shapes how the AI behaves, what voice it uses, and what rules it follows — like stage directions the audience never sees.

When ChatGPT responds differently depending on which app you're using (customer support vs creative writing), it's because each app has a different system prompt telling the AI how to act.

Shortcuts taken during development that make the code harder to maintain long-term. Like borrowing time now and paying interest later.

Duct-taping a leaky pipe instead of replacing it. It works today, but the tape will fail eventually and the fix will be harder than if you'd done it right.

Explaining complex things in plain language. Not dumbing it down — translating it. The ability to describe what software does so that someone who didn't build it can use, maintain, or decide to buy it.

Bad docs: "The module instantiates a singleton factory for dependency injection." Good docs: "This file creates one shared instance of the database connection so every part of the app uses the same one." Same concept. One is helpful.

A setting that controls how "creative" vs. "predictable" the AI's responses are. Lower = more focused and deterministic. Higher = more varied and exploratory. The scale is typically 0 to 2.

Temperature 0.1 for code (you want precision). Temperature 0.8 for brainstorming (you want variety). Most coding tools default to low temperature.

The text-based control panel where you type commands. No buttons or menus — just a blinking cursor. Looks intimidating but is often faster than clicking.

Instead of right-clicking → New Folder → typing a name, you type mkdir my-project and it's done in one step.

A measurement of how much of your code is exercised by tests. 80% coverage doesn't mean 80% bug-free — it means 20% is completely unchecked and you're hoping for the best.

Security cameras covering 80% of the building. Guess which 20% the problems come from.

A temporary digital key that proves you're logged in, so you don't resend your password with every action.

Like a wristband at a concert. You show your ticket once at the gate (login), get a wristband (token), and flash the wristband for the rest of the night.

The unit AI uses to measure text. A token is roughly 3-4 characters in English — sometimes a whole word, sometimes part of one. The context window is measured in tokens, and longer prompts consume more of it.

"Hello world" ≈ 2 tokens. "Antidisestablishmentarianism" ≈ 6 tokens (it gets split into pieces). A 1,000-word essay ≈ 1,300 tokens. Models range from 8K to 1M+ token windows.

Adjusting how an AI writes for different contexts within the same voice. Your joke voice and your error-message voice are different — tone calibration maps situations to the right register so the AI doesn't use humor where it shouldn't.

A tone table might say: Teaching → patient and clear. Error messages → honest and calm. Thanking someone → quiet and genuine. The AI picks the right tone for each context.

An AI agent's ability to call external tools — file readers, web browsers, terminal commands, APIs, databases — rather than relying solely on its training knowledge. This is what separates an agent from a chatbot. The quality of an agent depends heavily on which tools it has access to.

A chatbot guesses what's in your file. An agent with tool use actually opens and reads the file, runs your test suite, checks the output, and edits the specific line that failed. Same AI brain, vastly more capable because it can interact with the real world.

Refers to the inherent, flawed, and vulnerable nature of humanity — where mortality, limitation, and the capacity for error make life both beautiful and heartbreaking. It embodies the inherent, flawed, and vulnerable nature of being human — and the stubborn insistence on building something anyway.

You named your AI site after the *very* thing that makes you bad at AI. *That tracks...*

The massive dataset (text, code, images) fed into an AI model during its creation so it can learn patterns. The quality and breadth of training data directly determines what the AI knows and its blind spots.

If a student only reads biology textbooks, they'll ace biology but fail history. AI trained mostly on English text will be worse at other languages. The training data is the library the AI read before it started working.

A small, isolated test that checks whether one piece of code does one specific thing correctly. Runs in milliseconds. If it fails, you know exactly where the problem is.

A sanity check on a calculator. Before you run a complex tax return, you press 2 + 2 to make sure it still equals 4. If that basic math fails, nothing else matters.

A labeled box where you store information. You give it a name and put a value inside.

userName = "Alex" creates a box labeled userName with "Alex" inside. Later, you can use userName anywhere and it means "Alex."

A specialized database that stores data as lists of numbers (vectors) representing the "meaning" of text, images, or other content. Instead of searching by exact keywords, it finds things by how similar their meanings are.

Search for "how to fix a flat tire" and it also returns articles about "changing a punctured wheel" — different words, same concept. A traditional database would miss that.

A numbering system for software releases — MAJOR.MINOR.PATCH (e.g., 2.1.3). MAJOR means breaking changes. MINOR means new features, nothing breaks. PATCH means bug fixes only. It tells users exactly how scared to be of an update.

Going from 1.4.2 to 1.4.3? Safe — just bug fixes. Going from 1.4.2 to 2.0.0? Read the changelog first. Something you depend on probably changed.

Coding with AI by prompting vaguely and accepting whatever comes back without understanding it. Feels like magic for the first hour and like a hostage situation for the next ten when you realize you have no idea how to fix the 'magic' when it breaks.

Saying 'Make me an app' and just hitting accept on every AI suggestion for 2 hours. You end up with something that kind of works but nobody — including the AI — can modify without breaking. The antidote: plan before you prompt.

A specification document that teaches AI how your project communicates — tone, humor, personality, mechanics, and anti-patterns. Feed it to any AI tool so the output sounds like it was written on a good day, not generated by a corporate chatbot on autopilot.

Instead of telling AI 'write casually,' a voice profile says: 'Short sentences. Em dashes over semicolons. Dry humor that comes from confidence. Never use exclamation marks for enthusiasm. Warm through honesty, not cheerleading.'

A reverse API. Instead of your app asking a server 'Do you have anything new?' over and over, the server sends data to you the moment something happens. The difference between checking your mailbox every hour and having the mailman knock on your door.

Polling — the opposite of a webhook — is like a kid in the backseat asking 'Are we there yet?' every ten seconds. A webhook is the parent saying 'I'll tell you when we get there.' Your server stays quiet until there's actually something to say.

The numerical values inside an AI model that determine how it responds. These are learned during training and then frozen. When people say a model is 'static,' they mean its weights don't change after training — the AI can't learn new things from your conversations.

Think of weights as the muscle memory of a trained athlete. Once training camp is over, the athlete performs using what they've already learned. AI weights work the same way — they're set during training and locked in place.

Zero-shot: asking the AI to do something without giving examples. Few-shot: providing a few examples of the input/output pattern you want before your actual request. Few-shot almost always produces better results for structured or formatted tasks.

Zero-shot: 'Classify this email as spam or not.' Few-shot: 'Here are 3 examples — Email: "You won a prize!" → Spam. Email: "Meeting at 3pm" → Not spam. Now classify this email...' The AI locks onto the pattern.