Agentic Engineering Jargon Bank

This is a plain-English bank of engineering terms you can use when prompting Codex, Claude Code, or another coding agent. The goal is not to sound technical. The goal is to name the work precisely so the agent reaches the right mental model faster.

Use this pattern:

Do [term] on [specific file/system], with [constraint], and verify by [proof].

Example:

Do a narrow refactor of the auth flow. Keep the public API stable, minimize blast radius, and verify with typecheck, lint, and the existing auth tests.

Agentic Engineering

Agentic engineering means using an AI coding agent as an execution partner, with clear goals, constraints, context, verification, and handoff proof.

Term	Easier definition	Prompt example
Agentic workflow	A workflow where an AI agent plans, edits, runs tools, checks results, and reports proof.	Use an agentic workflow: inspect the repo, make the change, run verification, and summarize evidence.
Execution partner	Treating the agent as someone who should do the work, not just advise.	Act as an execution partner for this bug and take it through implementation and verification.
Goal state	The concrete end condition you want.	The goal state is a working login flow with tests passing and no new console errors.
Current state	What is true right now in the repo, app, browser, CRM, or logs.	First establish the current state from the live app and git diff before changing anything.
Desired behavior	What the system should do after the change.	The desired behavior is that skipped lessons still allow moving to the next lesson.
Acceptance criteria	The conditions that prove the work is done.	Use these acceptance criteria: mobile works, progress persists, and the lesson test remains optional.
Definition of done	The full checklist for calling the task complete.	Define done as code changed, tests passing, browser smoke tested, and notes updated.
Scope	The boundary of what should and should not be changed.	Keep scope limited to the onboarding route and its tests.
Non-goal	Something you explicitly do not want handled in this task.	Non-goal: do not redesign the dashboard or touch billing.
Constraint	A rule the solution must obey.	Constraint: preserve the existing API response shape.
Assumption	Something accepted as true until checked.	List assumptions before editing, then verify the risky ones.
Blocker	Something that prevents progress until fixed or clarified.	If credentials are the blocker, stop and show the exact missing env var.
Decision log	A short record of important choices and why they were made.	Add a decision log entry explaining why we kept SQLite for local progress.
Handoff	A package another person or agent can continue from.	Create a handoff with files changed, commands run, failures, and next steps.
Durable artifact	A saved file that survives beyond chat.	Save this as a durable Markdown artifact in docs.
Source of truth	The place that should be trusted most.	Treat the live sheet headers as the source of truth, not the old notes.
Inspect first	Look at the real files, logs, UI, or backend before deciding.	Inspect first, then propose or implement the smallest safe change.
Verify against reality	Check the actual app, deployment, browser, or CRM, not just theory.	Verify against reality by opening the local app and testing the flow.
Evidence	The proof that supports a claim.	Include evidence from test output and the browser smoke pass.
Repro	A repeatable way to make a bug happen.	Find a repro for the broken progress state before patching it.
Minimal repro	The smallest example that still shows the bug.	Build a minimal repro for the API validation failure.
Failure mode	The specific way something breaks.	Identify the failure mode before changing the retry logic.
Root cause	The real underlying reason something broke.	Find the root cause, not just the line that threw the error.
Mitigation	A change that reduces damage even if the root cause remains.	Add a mitigation so failed enrichment does not block the whole run.
Guardrail	A rule or check that prevents bad behavior.	Add a guardrail so the agent never sends live emails during preview mode.
Human-in-the-loop	A human must approve or decide before the system acts.	Keep sending as human-in-the-loop until previews are verified.
Autonomy boundary	The point where the agent must stop and ask.	Treat secrets, production data mutation, and client sends as autonomy boundaries.
Tool use	The agent using shell, browser, APIs, or connectors to act.	Use tool use to inspect the live page before answering.
Browser smoke test	A quick manual-style check in the browser.	Run a browser smoke test for the changed onboarding path.
Regression	A feature that used to work but now broke.	Check for regressions in lesson routing after this change.
Regression test	A test that prevents a fixed bug from coming back.	Add a regression test for skipped tests still unlocking next lesson.
Blast radius	How much of the system a change could affect.	Keep the blast radius small by changing only the parser module.
Risk surface	The set of places where the change could create problems.	Call out the risk surface before touching auth or billing.
Rollback plan	How to undo a bad change safely.	Include a rollback plan before deploying this migration.
Idempotent	Safe to run multiple times without duplicate damage. Like pressing an elevator button twice, it still only calls one elevator.	Make the import idempotent so reruns do not create duplicate contacts.
Dry run	A preview run that does not mutate real data.	Do a dry run of the CRM sync and show the records that would change.
Preview mode	A mode that shows output before taking final action.	Build preview mode for WhatsApp drafts before any send step.
Production boundary	The line between safe local changes and live customer-impacting changes.	Respect the production boundary and do not mutate live CRM records without approval.
Client-facing proof	Evidence you could show a client.	Produce client-facing proof: screenshot, exported CSV, and exact workflow status.
Shared context	The common understanding between user and agent.	Build shared context by summarizing current state, goal state, and constraints.
Prompt contract	A reusable instruction block that tells the agent how to behave.	Write a prompt contract for future agents working in this repo.
Instruction hierarchy	The priority order of system, developer, user, and repo instructions.	Follow the instruction hierarchy and treat AGENTS.md as repo guidance.
Context window	The amount of information the model can consider at once.	Keep the prompt within the context window by summarizing older logs.
Context compaction	Compressing older chat context into a shorter summary.	After context compaction, continue from the latest verified state.
State drift	When memory or docs stop matching the real system.	Check for state drift between docs and the live deployment.
Overclaiming	Saying something is true without enough proof.	Avoid overclaiming; mark unverified deployment status as unverified.
MCP	Model Context Protocol, a standard for connecting AI agents to external tools and data.	Use the Notion MCP to read the database instead of scraping the page.
Subagent	A separate agent spawned to handle a subtask with its own fresh context.	Spawn a subagent to research library options while you keep implementing.
Skill	A reusable instruction package an agent loads for a specific task type.	Load the PDF skill before extracting the tables.
Plan mode	Agent proposes a plan for approval before editing anything.	Start in plan mode and show me the approach before touching files.
Checkpoint	A saved point you can roll back to if the work goes wrong.	Commit a checkpoint before the risky migration so we can roll back.
Context engineering	Deciding what information goes into the model’s context and what stays out.	Apply context engineering: include the schema, skip the old logs.

Prompting And Specs

Term	Easier definition	Prompt example
PRD	Product Requirements Document, a document explaining what to build and why.	Write a PRD for the CRM follow-up dashboard before implementation.
Technical spec	A document explaining how the system should be built.	Create a technical spec for the webhook retry system.
Functional requirement	Something the product must do.	Capture functional requirements for import, dedupe, and export.
Non-functional requirement	Quality requirements like speed, reliability, security, or accessibility.	Add non-functional requirements for latency, uptime, and data privacy.
User story	A feature written from a user’s point of view.	Convert this into user stories for a broker using the CRM.
Use case	A real situation where someone uses the system.	List the main use cases before designing the dashboard.
Edge case	An unusual but possible situation.	Handle edge cases like empty CSVs and duplicate emails.
Happy path	The normal successful flow.	Verify the happy path first, then test errors.
Unhappy path	A failure or error flow.	Add unhappy-path tests for invalid login codes.
Requirements ambiguity	When the request can mean multiple things.	Flag requirements ambiguity before choosing the data model.
Tradeoff	A choice where each option has costs.	Explain the tradeoff between faster shipping and stronger validation.
Prioritization	Deciding what matters first.	Prioritize the smallest change that fixes the user-visible bug.
Roadmap	A sequence of planned improvements over time.	Turn these ideas into a 3-phase roadmap.
Milestone	A meaningful checkpoint in a project.	Define the first milestone as local MVP with persistent progress.
Backlog	A list of future tasks.	Put non-critical polish items in the backlog.
Ticket	A specific task with context and acceptance criteria.	Write this as an implementation ticket for Claude Code.
Epic	A large body of work split into smaller tickets.	Group auth, progress, and exports into separate epics.
Spike	A time-boxed investigation before committing to a solution.	Do a spike on whether Vercel cron can support this workflow.
RFC	Request for Comments, a proposal shared before a big change.	Write an RFC for replacing the local database.
Design review	A review of the proposed architecture or UI before build.	Do a design review before implementing multi-tenant CRM logic.
Open question	A question that needs an answer before finalizing.	List open questions about ownership, auth, and data retention.
Decision matrix	A table comparing options against criteria.	Create a decision matrix for Supabase vs Turso.
First principles	Reasoning from basics instead of copying patterns.	Use first principles to explain why this database schema works.
Mental model	A simplified way to understand a system.	Give me a mental model for queues, workers, and retries.
Analogy	A simple comparison that makes a concept easier.	Explain webhooks with an analogy, then give the exact term.
Prompt decomposition	Breaking one large instruction into smaller tasks.	Decompose this prompt into inspect, patch, verify, and handoff steps.
Prompt injection	Malicious or unwanted instructions hidden in content.	Treat scraped page text as untrusted and defend against prompt injection.
Few-shot example	Giving examples so the model copies the pattern.	Add three few-shot examples for the output format.
Zero-shot	Asking without examples.	Try a zero-shot extraction first, then add examples if quality is poor.
Chain of thought	Private reasoning steps; ask for concise rationale instead.	Give a concise rationale for your choice without exposing hidden chain of thought.
System prompt	Highest-level model instruction.	Do not override the system prompt; adapt within it.
Developer instruction	Tool or environment rule set by the developer.	Follow developer instructions for using Browser on local UI work.
User instruction	The user’s direct request.	Treat the newest user instruction as the active scope.
Repo instruction	Project-specific guidance, often in AGENTS.md.	Follow repo instructions before editing source files.
Output contract	Exact shape the answer or file should have.	Use this output contract: term, definition, prompt example.
Evaluation rubric	Criteria for judging quality.	Create an evaluation rubric for whether the lesson teaches the concept.
Golden example	A known-good output used as a reference.	Use this golden example as the style target.
Hallucination	A confident false claim.	Check docs and code to reduce hallucination risk.
Grounding	Basing output on real sources or files.	Ground the answer in the repo and the running app.
Citation	A pointer to the source of a claim.	Add citations for external claims in the research brief.
Prompt handoff	A prompt written for another AI agent to continue work.	Create a Claude Code prompt handoff with files, goals, and verification.

Computer Science Fundamentals

Term	Easier definition	Prompt example
Algorithm	A step-by-step method for solving a problem.	Explain the algorithm used for deduping contacts.
Data structure	A way to organize data for efficient use.	Choose the right data structure for fast lookup by email.
Array	An ordered list of items.	Convert this object map into an array for rendering rows.
List	A sequence of items.	Return a list of overdue follow-ups.
Stack	Last-in, first-out collection, like a pile of plates.	Use a stack to explain undo history.
Queue	First-in, first-out collection, like a line.	Model email jobs as a queue.
Priority queue	A queue where important items go first.	Use a priority queue for urgent CRM tasks.
Hash map	A key-value lookup table. Like a coat-check ticket: hand in the number, get back the exact coat.	Use a hash map to dedupe contacts by normalized email.
Set	A collection of unique values.	Use a set to prevent duplicate lesson IDs.
Tree	Data with parent-child relationships.	Represent the curriculum as a tree.
Graph	Nodes connected by edges.	Model CRM relationships as a graph.
Node	One item in a tree or graph.	Treat each lesson as a graph node.
Edge	A connection between nodes.	Add edges for prerequisite relationships.
Traversal	Visiting items in a structure.	Traverse the lesson graph to find unlocked lessons.
Search	Finding a target item.	Implement search across lessons and terms.
Sort	Ordering items by a rule.	Sort leads by last contact date.
Recursion	A function calling itself. Like a set of nesting dolls, each one opens to a smaller same-shaped doll.	Avoid recursion here unless the tree depth is bounded.
Iteration	Repeating steps in a loop.	Use iteration to process each CSV row.
Big O	A rough way to describe how work grows as input grows. Like asking, “if I have way more stuff, how much slower does this get?”	Explain the Big O cost of this dedupe method.
Time complexity	How runtime grows with input size. Like checking if doing twice the work takes twice as long, or way longer.	Reduce time complexity from nested loops to a map lookup.
Space complexity	How memory use grows with input size. Like checking how many boxes you need as you collect more toys.	Discuss space complexity before caching all records.
O(1)	Constant time, roughly same speed regardless of size. Like grabbing the top book off a pile, fast no matter how tall the pile is.	Make contact lookup O(1) by indexing by email.
O(n)	Linear time, work grows with item count. Like counting every kid in line one by one.	An O(n) scan is fine for this small list.
O(n^2)	Nested-loop time that grows quickly. Like every kid in class shaking hands with every other kid, gets slow fast.	Remove the O(n^2) duplicate check.
Brute force	Trying the simple direct way, often inefficient.	Start with brute force, then optimize only if needed.
Optimization	Making code faster, smaller, cheaper, or cleaner.	Optimize the slow import after measuring where time is spent.
Cache	Stored result reused to avoid repeated work. Like keeping your favorite snack on the counter instead of the far cupboard.	Cache the profile lookup for this request.
Cache invalidation	Deciding when cached data is stale. Like knowing when the milk in the fridge has gone bad.	Define cache invalidation for industry update cards.
Memoization	Caching function results. Like writing down a math answer so you don’t have to redo it next time.	Use memoization for expensive lesson summaries.
Concurrency	Multiple tasks making progress during the same period. Like cooking dinner while laundry spins, both moving along together.	Add concurrency for independent API calls.
Parallelism	Multiple tasks literally running at the same time. Like two cooks chopping veggies at the exact same time.	Use parallelism to process independent files faster.
Race condition	A bug where timing changes the result. Like two kids grabbing the last cookie at once, who wins changes the result.	Check for a race condition in progress saving.
Deadlock	Tasks wait on each other forever. Like two people in a doorway each waiting for the other to move first.	Make sure this locking design cannot deadlock.
Atomic operation	A change that fully succeeds or fully fails. Like a light switch, it’s either all the way on or all the way off, never half.	Make marking a lesson done atomic.
Transaction	A group of database changes committed together.	Wrap contact import and audit log writes in a transaction.
Consistency	Data remains valid after changes.	Preserve consistency between progress rows and lesson IDs.
Deterministic	Same input always gives same output. Like a vending machine: same button always gives the same snack.	Make the test deterministic by freezing time.
Non-deterministic	Output can vary between runs. Like rolling dice, you can’t be sure what you’ll get.	Remove non-deterministic ordering from the test.
State	Stored information the system remembers.	Inspect state before fixing the stale lesson route.
Stateless	No stored memory between requests.	Keep this API route stateless if possible.
Stateful	Keeps memory or data over time.	Treat onboarding progress as stateful.
Side effect	A change outside the function, like writing data or sending email. Like leaving footprints, the function changed something outside itself.	Separate side effects from pure validation.
Pure function	A function with no side effects. Like a calculator, same numbers in, same answer out, nothing else changes.	Extract this date calculation into a pure function.
Input	Data given to a function or system.	Validate input before writing to the database.
Output	Data returned by a function or system.	Keep output shape stable for existing clients.
Invariant	A rule that must always be true. Like a rule that’s always true, water is always wet.	Add an invariant that every lesson has a unique slug.
Precondition	Something that must be true before an operation.	Check the precondition that the user is authenticated.
Postcondition	Something that must be true after an operation.	Assert the postcondition that progress was saved.
Boundary condition	The edge of valid input, like zero items.	Test boundary conditions: zero lessons, one lesson, many lessons.
Null	An intentional empty value. Like an empty box you left empty on purpose.	Handle null profile fields without crashing.
Undefined	A missing value in JavaScript or TypeScript. Like a box you never even made yet.	Guard against undefined route params.
Boolean	True or false value.	Use a boolean for whether the lesson is completed.
String	Text data.	Normalize string emails before comparing them.
Number	Numeric data.	Validate that duration is a number.
Object	A grouped set of fields.	Define the contact object shape clearly.
Schema	The expected shape and rules of data.	Add a Zod schema for this request body.
Serialization	Turning data into a format like JSON. Like flattening a tent into a bag so you can carry it.	Fix serialization so dates survive API responses.
Deserialization	Reading serialized data back into objects. Like popping that tent back up from the bag.	Validate during deserialization of imported JSON.
Encoding	Representing data in a specific format.	Check encoding before parsing the CSV.
Parsing	Turning text into structured data.	Use a real parser for CSV parsing.
Tokenization	Splitting text into smaller units. Like cutting a sentence into separate word cards.	Tokenize search text before matching terms.
Compiler	A tool that converts code into another form.	Explain what the TypeScript compiler is complaining about.
Interpreter	A tool that runs code directly.	Clarify whether this code is compiled or interpreted.
Runtime	The environment where code runs.	Check whether this bug happens in the browser runtime or Node runtime.
Memory leak	Memory that is never released and grows over time. Like a sink slowly filling because the drain is clogged.	Look for a memory leak in the polling loop.
Garbage collection	Automatic cleanup of unused memory. Like a robot that quietly throws out toys nobody plays with anymore.	Explain whether garbage collection matters for this issue.
Synchronous	Steps run one after another, each waiting for the previous. Like waiting in line, you can’t move till the person ahead is done.	Keep the import synchronous since row order matters.
Asynchronous	Work starts now and finishes later without blocking other work. Like ordering food, you get a buzzer and do other stuff while it cooks.	Make the email send asynchronous so the request returns fast.
Blocking	Work that stops everything else until it finishes. Like a closed gate that stops everyone until it opens.	Move the blocking file read off the request path.
Callback	A function passed in to run when something finishes. Like telling a friend “call me back when you’re done.”	Replace the nested callbacks with async/await.
Promise	A JavaScript object representing a value that arrives later. Like a “your order will be ready soon” ticket.	Return a promise and handle the rejection case.
Async/await	Syntax for writing asynchronous code that reads top to bottom.	Convert the promise chains to async/await.
Event loop	The mechanism JavaScript uses to schedule work one task at a time. Like a single helper doing one chore at a time off a to-do list.	Explain why this loop blocks the event loop.
Mutation	Changing data in place. Like erasing and rewriting on the same paper.	Avoid mutation; return a new array instead.
Immutability	Never changing data in place, always creating new copies. Like writing in pen, you don’t erase, you start a fresh copy.	Keep the state object immutable to avoid stale renders.
Closure	A function that remembers variables from where it was created. Like a backpack a function carries that remembers things from home.	Check whether the stale value comes from a closure.
Class	A blueprint for creating objects with shared behavior.	Keep this a plain function; a class is overkill here.
Instance	One object created from a class.	Create one client instance and reuse it across requests.
Inheritance	A class reusing behavior from a parent class.	Prefer composition over inheritance for the message builders.
Composition	Building behavior by combining small independent parts.	Use composition so each formatter stays testable.
Encapsulation	Hiding internal details behind a clean interface.	Encapsulate the retry logic inside the API client.
Enum	A fixed set of named values.	Use an enum for lesson status instead of raw strings.
Generics	Code that works across many types via a type parameter. Like a lunchbox that fits any food, not just sandwiches.	Make the helper generic so it works for any record type.
Type inference	The compiler figuring out types without explicit annotations. Like a teacher guessing it’s a number because you wrote one.	Rely on type inference and remove the redundant annotations.
Regex	Pattern language for matching text. Like a search rule for finding patterns in text, like “all words starting with B.”	Use a regex to validate the slug format.
Off-by-one error	A bug from counting one too many or one too few.	Check for an off-by-one error in the pagination math.

Programming And Code Quality

Term	Easier definition	Prompt example
Lint	Static style and bug checks on code. Like spellcheck for code.	Run lint and fix only issues caused by this change.
Linter	The tool that performs lint checks. Like the spellcheck tool itself.	Use the repo’s linter before calling this done.
Typecheck	Checking that types line up without running the app. Like making sure you don’t put a sock where a shoe goes.	Run typecheck after editing TypeScript files.
TypeScript	JavaScript with static types.	Use TypeScript types to prevent invalid lesson states.
Static analysis	Checking code without executing it. Like proofreading without actually reading it out loud.	Use static analysis to catch unused imports.
Dynamic analysis	Checking behavior while code runs. Like testing a toy by actually playing with it.	Use dynamic analysis with a browser smoke test.
Compile error	Code cannot be converted or checked successfully.	Fix the compile error without weakening types.
Runtime error	Code fails while running.	Reproduce the runtime error in the browser.
Exception	A thrown error that interrupts normal flow.	Catch the exception and return a useful API error.
Error handling	How code responds when something fails.	Improve error handling for failed CRM API calls.
Validation	Checking data before trusting it.	Add validation for the onboarding payload.
Sanitization	Cleaning input to reduce risk.	Sanitize user-provided HTML before rendering.
Normalization	Converting values into a consistent form.	Normalize phone numbers before deduping contacts.
Refactor	Improve code structure without changing behavior.	Refactor the lesson state logic without changing UI behavior.
Rewrite	Rebuild a part more substantially.	Rewrite the parser only if refactor cannot fix the core issue.
Abstraction	A simpler interface hiding details.	Add an abstraction only if two routes share the same logic.
Indirection	Solving through an extra layer.	Avoid unnecessary indirection in this small helper.
Coupling	How much one part depends on another. Like two train cars chained together, move one and the other follows.	Reduce coupling between UI state and API response format.
Cohesion	How well code in one module belongs together. Like keeping all your art supplies in one art box.	Improve cohesion by moving progress helpers into one file.
DRY	Do not repeat yourself. Like writing a rule once instead of copying it everywhere.	Apply DRY to the repeated validation code.
WET	Write everything twice, meaning duplication exists. Like writing the same thing over and over by hand.	Leave this WET for now if abstraction would be premature.
Premature abstraction	Creating a general solution before it is needed.	Avoid premature abstraction; keep this helper local.
Premature optimization	Speeding up code before proving speed matters.	Avoid premature optimization until profiling shows a bottleneck.
Technical debt	Code that works but will cost more later. Like a messy room you’ll have to clean up later, and it gets worse.	Note this shortcut as technical debt with a follow-up.
Code smell	A sign code may be poorly structured. Like a funny smell that hints something might be wrong.	Identify code smells in this route before refactoring.
Hot path	Code that runs often and affects performance.	Be careful optimizing the hot path for lesson rendering.
Dead code	Code no longer used.	Remove dead code after confirming no imports reference it.
Unused import	Imported code that is not used.	Clean up unused imports from the changed file.
Dependency	A package or module that code relies on.	Check whether adding this dependency is justified.
Dev dependency	A dependency only needed for development or tests.	Add the test helper as a dev dependency.
Transitive dependency	A dependency pulled in by another dependency.	Check whether the vulnerability is transitive.
Semantic versioning	Version format meaning major, minor, patch.	Respect semantic versioning when upgrading packages.
Breaking change	A change that can break existing users or callers.	Avoid breaking changes to the export API.
Backward compatibility	New code still works with old callers or data.	Preserve backward compatibility with existing progress rows.
Public API	The interface other code or users depend on.	Do not change the public API of this route.
Internal API	An interface used only inside the app.	You can change the internal API if all callers are updated.
Interface	A defined shape or contract between parts.	Define an interface for CRM contact fields.
Contract	A promise about inputs, outputs, and behavior.	Keep the API contract stable.
Implementation detail	Hidden internal choice callers should not rely on.	Treat database table names as implementation details.
Module	A file or package with related code.	Move parsing into a separate module.
Component	A reusable UI building block.	Extract the lesson card into a component.
Hook	A React function for state or side effects.	Create a hook only if state logic is reused.
Utility function	A small helper function.	Add a utility function for slug normalization.
Config	Settings that change behavior.	Move the polling interval into config.
Environment variable	A setting supplied outside the code, often secret.	Read DATABASE_URL from an environment variable.
Secret	Sensitive value like API key or token.	Do not print secrets in logs or docs.
Feature flag	A switch to turn behavior on or off.	Put the new dashboard behind a feature flag.
Toggle	A switch for a setting or UI state.	Add a toggle for showing completed lessons.
Polyfill	Code that adds missing modern behavior to old environments. Like a booster seat that lets an old chair work like a new one.	Avoid a polyfill unless the target browser needs it.
Package manager	Tool that installs dependencies.	Use the existing package manager in this repo.
Build step	Process that prepares code for deployment.	Ensure the build step passes after the change.
Bundle	The packaged JavaScript sent to the browser.	Check whether this library increases bundle size.
Tree shaking	Removing unused code from a bundle. Like shaking a tree so the dead leaves you don’t need fall off.	Confirm the import supports tree shaking.
Minification	Shrinking code for production. Like squishing clothes into a vacuum bag to save space.	Do not debug using minified production stack traces only.
Source map	File mapping built code back to source code. Like a key that turns the squished code back into the readable version.	Use source maps to trace this production error.
Monorepo	One repo containing multiple projects.	Check package boundaries if this becomes a monorepo.
Workspace	A package-manager concept for multiple linked packages.	Add this package to the workspace config.
CLI	Command-line interface.	Use the Vercel CLI to inspect deployment status.
SDK	Software development kit, a library plus tools for an API.	Use the official SDK rather than hand-rolling API calls.
Boilerplate	Repeated setup code.	Remove boilerplate from the generated route.
Scaffold	Generate a starting structure.	Scaffold the new API route and then adapt it.
Stack trace	The chain of function calls that led to an error.	Paste the full stack trace before proposing a fix.
Debugger breakpoint	A marked line where execution pauses so you can inspect values.	Set a debugger breakpoint instead of adding ten console logs.
Console log	Printing values to see what code is doing.	Add temporary console logs, then remove them before commit.
Log level	Severity tag like debug, info, warn, error.	Log this at warn, not error; it is recoverable.
Magic number	An unexplained raw number in code.	Replace the magic number with a named constant.
Hardcoded	A value written directly into code instead of config.	Move the hardcoded URL into an environment variable.
Monkey patch	Changing library behavior at runtime; fragile. Like taping a new ending onto a toy that wasn’t built for it, wobbly.	Do not monkey patch the SDK; wrap it instead.
Shim	A small compatibility layer between mismatched interfaces. Like an adapter plug so two things that don’t match can connect.	Add a shim so the old import path keeps working.
No-op	An operation that intentionally does nothing. Like a button that does nothing on purpose.	Make the send handler a no-op in preview mode.
Stale	Data or state that is out of date.	The UI shows stale data; check the cache key.
Singleton	One shared instance used everywhere. Like the one and only TV remote everyone in the house shares.	Make the database client a singleton to avoid connection leaks.
Global state	Data accessible from everywhere; risky and hard to test. Like a whiteboard anyone can change, easy to mess up.	Reduce global state in favor of passed-in dependencies.

Testing And Verification

Term	Easier definition	Prompt example
Unit test	Tests one small function or module.	Add a unit test for email normalization.
Integration test	Tests multiple parts working together.	Add an integration test for API route plus database write.
End-to-end test	Tests the full user flow like a real user.	Add an end-to-end test for onboarding through lesson start.
E2E	Short for end-to-end.	Run the E2E test that covers the demo flow.
Smoke test	A quick check that the main thing works.	Do a smoke test after deployment.
Sanity check	A quick check that the result makes sense.	Sanity check the exported CSV row count.
Test fixture	Prepared test data.	Add a fixture for a contact with missing phone number.
Mock	Fake replacement for a dependency. Like a stunt double standing in for the real actor.	Mock the email provider in tests.
Stub	A simple fake response. Like a toy phone that just says one thing when you press it.	Stub the CRM API response.
Spy	A test helper that records whether something was called. Like a hidden counter that tallies how many times a thing got used.	Use a spy to confirm saveProgress was called once.
Assertion	A test statement that must be true.	Add an assertion for the success message.
Test coverage	How much code or behavior tests exercise.	Increase coverage for the failed import path.
Flaky test	A test that sometimes passes and sometimes fails.	Fix the flaky test by waiting for a stable UI state.
Deterministic test	A test that gives the same result every run.	Make this deterministic by seeding dates.
Snapshot test	A test comparing output to a saved snapshot.	Avoid a huge snapshot test for volatile UI copy.
Golden test	A test comparing to a known-good output.	Add a golden test for the prompt template.
Contract test	A test confirming two systems agree on an API shape.	Add a contract test for webhook payloads.
Mutation test	A test of whether tests catch intentional code changes.	Consider mutation testing for critical validation.
Test pyramid	More unit tests, fewer slow E2E tests.	Follow the test pyramid for this feature.
Red-green-refactor	TDD loop: failing test, passing code, cleanup.	Use red-green-refactor for the progress bug.
TDD	Test-driven development.	Use TDD: write the failing behavior test first.
BDD	Behavior-driven development using behavior scenarios.	Write BDD scenarios for the CRM follow-up flow.
QA	Quality assurance.	Do QA on mobile and desktop before deploy.
UAT	User acceptance testing by the real user or client.	Prepare a UAT checklist for the client workflow.
Reproduction steps	Exact steps to see a bug.	Document reproduction steps before fixing.
Expected result	What should happen.	Include expected result in the bug report.
Actual result	What actually happened.	Compare actual result against expected result.
Test data	Data used during testing.	Use test data that includes duplicates and blanks.
Seed data	Starting data inserted for tests or local dev.	Add seed data for three lessons and one user.
Regression suite	Tests run to catch old bugs.	Run the regression suite after touching progress logic.
CI	Continuous integration, automated checks on code changes.	Make sure CI runs typecheck, lint, test, and build.
CI failure	Automated checks failed.	Diagnose the CI failure from the first failing command.
Local verification	Checks run on your machine.	Do local verification before suggesting deploy.
Production smoke	Quick check on the live site after deploy.	Run a production smoke check on /demo after deploy.
Observed behavior	What you saw during verification.	Report observed behavior, not guesses.

Web Development

Term	Easier definition	Prompt example
Frontend	Code users see and interact with.	Update the frontend to show saved progress.
Backend	Server-side code handling data and logic.	Update the backend route to validate the payload.
Full stack	Frontend plus backend together.	Treat this as a full-stack change and test both sides.
Client	Browser or app making requests.	Check whether the client sends the right JSON.
Server	Computer or runtime responding to requests.	Check the server logs for the failed request.
Request	Message sent to a server.	Inspect the request body sent by the form.
Response	Message returned by a server.	Keep the response JSON shape stable.
HTTP	Protocol browsers and APIs use.	Explain the HTTP status codes this route returns.
HTTPS	Encrypted HTTP.	Make sure production uses HTTPS links.
URL	Web address.	Preserve the current URL hash route behavior.
Query parameter	Value after ? in a URL.	Add a query parameter for filtering completed lessons.
Route	A URL path handled by the app.	Add a route for exporting progress.
Dynamic route	Route with a variable part.	Check the dynamic route for labs by ID.
Middleware	Code that runs before a request reaches the final handler. Like a security guard who checks you before you reach the door.	Add middleware only if multiple routes need the auth check.
API route	Server endpoint inside the web app.	Update the API route for onboarding.
REST	API style based on resources and HTTP methods.	Keep this as a REST endpoint unless GraphQL is justified.
GraphQL	API query language where clients request specific fields.	Do not introduce GraphQL for this small API.
Webhook	A server-to-server notification triggered by an event. Like a doorbell, the other site rings you when something happens.	Add a webhook handler for new CRM leads.
Polling	Repeatedly checking for updates. Like asking “are we there yet?” over and over.	Avoid aggressive polling; use a longer interval.
WebSocket	Persistent two-way browser-server connection.	Use WebSocket only if live updates are needed.
SSE	Server-Sent Events, one-way live updates from server to browser.	Consider SSE for streaming job progress.
Cookie	Small browser-stored value sent with requests.	Store the session in an HTTP-only cookie.
Session	Server-recognized logged-in state.	Verify the session survives page refresh.
JWT	Signed token often used for auth claims. Like a wristband that proves you already paid to get in.	Avoid JWT unless we need stateless auth.
OAuth	Standard for letting users sign in or connect accounts. Like using your house key to let a friend in without giving them a copy.	Use OAuth for Google account connection.
CORS	Browser rule controlling cross-origin requests. Like a bouncer deciding which other websites are allowed in.	Fix the CORS error for the frontend origin.
CSRF	Attack where a site tricks a browser into sending a request. Like a trick that makes your browser do something you didn’t mean to.	Add CSRF protection for state-changing forms.
XSS	Attack where malicious script runs in a page. Like a stranger sneaking a note into your homework.	Prevent XSS by escaping user content.
SSR	Server-side rendering.	Use SSR for pages that need server data before paint.
SSG	Static site generation.	Use SSG for static lesson pages if content rarely changes.
ISR	Incremental static regeneration.	Use ISR if static pages need periodic refresh.
CSR	Client-side rendering.	Use CSR for highly interactive dashboard state.
Hydration	React attaching interactivity to server-rendered HTML. Like adding water to make dried noodles soft and usable.	Check for hydration mismatch in this component.
Hydration mismatch	Server HTML and client render do not match. Like the picture on the box not matching what’s inside.	Fix the hydration mismatch caused by Date.now.
SPA	Single-page app where navigation happens in the browser.	Treat the demo shell as an SPA-style experience.
PWA	Progressive web app, a website installable like an app.	Verify PWA readiness after changing the service worker.
Service worker	Browser script for offline/cache behavior.	Check the service worker is not caching stale assets.
Responsive design	UI adapts to screen size.	Verify responsive design on mobile and desktop.
Breakpoint	Screen width where layout changes.	Add a breakpoint for the two-column dashboard.
Viewport	Visible browser area.	Test the viewport at mobile width.
DOM	Browser’s page structure. Like the skeleton of a web page that the browser builds.	Inspect the DOM for duplicate buttons.
Event handler	Code that runs when a user action happens.	Fix the click event handler for Mark done.
Form submission	Sending form data.	Prevent double form submission.
Debounce	Wait until rapid actions stop before running. Like waiting till someone stops talking before you reply.	Debounce the search input.
Throttle	Limit how often something can run. Like only letting one kid down the slide every few seconds.	Throttle scroll-based updates.
Lazy loading	Load only when needed. Like only unwrapping a gift when you’re ready to use it.	Lazy load heavy lesson content.
Code splitting	Split app code into smaller chunks.	Use code splitting for the admin panel.
Asset	Image, font, script, or static file.	Compress the large asset before shipping.
CDN	Network of servers serving assets quickly.	Serve static images through a CDN.
SEO	Search engine optimization.	Keep SEO metadata intact while changing layout.
Metadata	Page title, description, and related info.	Add metadata for the new lesson page.
Accessibility	Making UI usable for people with disabilities.	Check accessibility labels on icon buttons.
ARIA	HTML attributes for assistive technology.	Add ARIA labels to icon-only controls.
Semantic HTML	HTML tags that express meaning.	Use semantic HTML for navigation and main content.
HTTP method	The verb of a request: GET, POST, PUT, PATCH, DELETE.	Use PATCH, not PUT, for partial updates.
GET	Read data with no side effects.	Keep GET routes free of side effects.
POST	Create or submit data.	Send the form as a POST with a JSON body.
Status code	A number describing how a request ended, like 200, 404, 500.	Return a 400 with a clear message for invalid input.
4xx error	A client-side request problem.	Treat 4xx errors as input issues; do not retry them.
5xx error	A server-side failure.	Alert on repeated 5xx errors from the API route.
Header	Metadata sent with a request or response.	Set the content-type header to application/json.
Payload	The body data of a request or response.	Log the payload shape, never the secret values.
JSON	Standard text format for structured data.	Return JSON, not HTML, from the API route.
DNS	The system mapping domain names to server addresses. Like a phone book that turns a name into a number.	Check DNS records before blaming the deploy.
Port	A numbered channel where a service listens on a machine. Like a specific door number on a building.	The dev server runs on port 3000; check for conflicts.
Localhost	Your own machine acting as the server.	Test on localhost before deploying.
Proxy	A middleman that forwards requests. Like a friend who passes your note to someone for you.	Use a dev proxy to avoid CORS locally.
Reverse proxy	A server in front of backends that routes traffic. Like a receptionist who decides which office your request goes to.	Check the reverse proxy timeout for the slow endpoint.
Load balancer	Spreads traffic across multiple servers. Like a host seating diners evenly across all the waiters.	Sticky sessions matter if a load balancer is involved.
localStorage	Browser storage that persists across sessions.	Persist progress to localStorage as an offline fallback.
sessionStorage	Browser storage cleared when the tab closes.	Use sessionStorage for the draft form state.
Hot reload	The dev server updating the app instantly as you edit.	If hot reload looks stale, restart the dev server before debugging.
.env file	A local file holding environment variables.	Add the key to .env.local and never commit it.
Props	Data passed into a React component from its parent.	Pass the lesson as a prop instead of refetching it.
Prop drilling	Passing props through many layers that do not use them.	Avoid prop drilling; lift state or use context.
Re-render	React redrawing a component after state or props change.	Find what triggers the extra re-renders on this page.
Controlled component	A form input whose value React state owns.	Make the search box a controlled component.

Web Design And UX

Term	Easier definition	Prompt example
UI	User interface, what users see and touch.	Improve the UI for the lesson completion state.
UX	User experience, how it feels to use.	Improve UX by reducing clicks in the review flow.
Information architecture	How content and screens are organized.	Review the information architecture of the dashboard.
Navigation	How users move through the app.	Fix navigation so completed lessons route correctly.
User flow	The path a user takes to complete a task.	Map the user flow from login to first lesson.
Wireframe	Low-detail layout sketch.	Create a wireframe for the CRM dashboard.
Mockup	Higher-detail static design.	Turn this wireframe into a polished mockup.
Prototype	Clickable or working model before final build.	Build a prototype of the onboarding flow.
Design system	Reusable design rules and components.	Follow the existing design system.
Component library	Collection of reusable UI components.	Use the existing component library before adding custom UI.
Pattern library	Reusable interaction patterns.	Match the existing tab and modal patterns.
Visual hierarchy	Making important things visually clear first.	Improve visual hierarchy on the lesson page.
Layout	Arrangement of UI elements.	Simplify the layout for mobile.
Grid	Structured columns and rows.	Use a grid for the lesson cards.
Whitespace	Empty space that improves readability.	Add whitespace between dense sections.
Density	How much information appears in a space.	Increase density for the CRM table but keep it readable.
Affordance	A visual clue that something can be used.	Make the Mark done button have clearer affordance.
Signifier	A signal showing what action is possible.	Add a signifier for collapsed sections.
Feedback	UI response after an action.	Show feedback after progress is saved.
Loading state	UI shown while work is happening.	Add a loading state for the export button.
Empty state	UI shown when there is no data.	Create an empty state for no saved lessons.
Error state	UI shown when something fails.	Add an error state for failed progress save.
Disabled state	UI shown when action is unavailable.	Use disabled state while the form submits.
Hover state	UI reaction when pointer is over an element.	Add a hover state for desktop cards.
Focus state	UI indication for keyboard selection.	Ensure visible focus states for buttons.
Active state	UI showing current selection.	Fix active state for the current lesson tab.
Skeleton	Placeholder layout shown while loading.	Use a skeleton for loading lesson content.
Toast	Temporary notification.	Show a toast after export completes.
Modal	Dialog overlay.	Use a modal for destructive confirmation.
Drawer	Panel sliding from side or bottom.	Use a drawer for mobile filters.
Tooltip	Small helper text on hover or focus.	Add tooltips to icon-only buttons.
CTA	Call to action, the main next button.	Make the CTA say the exact next action.
Above the fold	First visible screen before scrolling.	Put the active lesson above the fold.
First viewport	Same idea as above the fold.	Ensure the product identity is clear in the first viewport.
Progressive disclosure	Show advanced details only when needed.	Use progressive disclosure for advanced settings.
Cognitive load	Mental effort required to use something.	Reduce cognitive load by grouping related controls.
Scannability	How easy it is to scan quickly.	Improve scannability with short labels and grouped sections.
Readability	How easy text is to read.	Improve readability of lesson explanations.
Contrast	Difference between colors for visibility.	Check contrast on muted text.
Typography	Font, size, spacing, and text style.	Tighten typography inside compact cards.
Design token	Named design value like color or spacing.	Use design tokens for spacing instead of one-off values.
Color palette	Set of colors used in the UI.	Adjust the color palette so sections are easier to distinguish.
Interaction design	How controls behave when used.	Review interaction design for the lesson test flow.
Microcopy	Small bits of UI text.	Rewrite microcopy on the error message.
Heuristic evaluation	UX review using standard usability rules.	Do a heuristic evaluation of the onboarding screen.
Accessibility audit	Review for accessibility issues.	Run an accessibility audit on the main flow.
Mobile parity	Mobile has equivalent usable functionality.	Verify mobile parity after changing navigation.

App Development And Architecture

Term	Easier definition	Prompt example
Architecture	The high-level structure of a system.	Review the architecture before adding a second database.
System design	Planning components, data flow, scale, and failure handling.	Do a system design pass for the CRM sync service.
Client-server architecture	Browser/app talks to backend server.	Explain this feature using client-server architecture.
Monolith	One app containing most functionality.	Keep this as a monolith until deployment complexity justifies splitting.
Microservices	Many small services communicating over APIs.	Avoid microservices unless independent scaling is needed.
Serverless	Code run on demand without managing servers.	Check serverless limits before adding long-running jobs.
Edge runtime	Code running close to users at network edge locations.	Do not use edge runtime if the database client is unsupported.
API	Interface for code systems to communicate.	Design the API before wiring the UI.
Endpoint	A specific API URL and method.	Add an endpoint for exporting lessons.
Handler	Function that handles a request or event.	Update the POST handler for onboarding.
Service layer	Code layer holding business logic.	Move CRM business logic into a service layer.
Controller	Code that receives requests and calls logic.	Keep the controller thin.
Repository pattern	Data-access wrapper around database queries.	Use a repository pattern if queries are repeated.
Domain model	Code representation of business concepts.	Define the domain model for lessons, labs, and progress.
Entity	A main business object with identity.	Treat Contact as an entity.
Value object	Data object defined by its values, not identity.	Treat EmailAddress as a value object.
DTO	Data Transfer Object, shape passed between layers.	Create a DTO for exported progress.
Adapter	Code that translates one interface to another.	Write an adapter for the CRM provider.
Facade	Simple interface hiding complex internals.	Add a facade for lesson progress operations.
Orchestrator	Code that coordinates multiple steps or services.	Build an orchestrator for enrichment, dedupe, and follow-up creation.
Worker	Background process handling jobs.	Use a worker for slow enrichment tasks.
Job	A unit of background work.	Create a job for each CSV import.
Scheduler	Runs jobs at specific times.	Use a scheduler for weekly industry updates.
Cron	Time-based scheduled job. Like an alarm clock that runs a chore on schedule.	Add a cron job for daily CRM follow-up checks.
Queue	Stores jobs until workers process them.	Put outbound email tasks in a queue.
Retry	Try again after failure.	Add retry with a limit for transient API errors.
Backoff	Waiting longer between retries. Like waiting a little longer each time before knocking again.	Use exponential backoff for rate-limited calls.
Circuit breaker	Stop calling a failing service temporarily. Like a fuse that trips so the rest of the house stays safe.	Add a circuit breaker around the enrichment API.
Timeout	Stop waiting after a time limit.	Add a timeout to the webhook call.
Rate limit	Maximum allowed requests in a time period.	Respect the provider rate limit.
Idempotency key	Unique key preventing duplicate operations. Like a stamp on your hand so the ride only charges you once.	Use an idempotency key for payment or contact creation.
Event-driven	System reacts to events.	Make the follow-up workflow event-driven.
Event	A fact that happened.	Emit an event when a lesson is completed.
Event bus	System for publishing and subscribing to events. Like a school PA system anyone can announce on or listen to.	Use an event bus only if multiple modules need the same events.
Pub/sub	Publishers send messages to subscribers. Like a newsletter, one sender, many readers who signed up.	Consider pub/sub for independent notification handlers.
State machine	Explicit allowed states and transitions. Like a board game where you can only move to certain next squares.	Model lesson attempts as a state machine.
Finite state machine	State machine with limited states.	Use a finite state machine for onboarding steps.
Workflow	Ordered steps to complete a process.	Map the CRM workflow before automating it.
Pipeline	Data flowing through processing stages.	Build a pipeline for import, clean, enrich, and export.
ETL	Extract, transform, load. Like grabbing ingredients, prepping them, then stocking the kitchen.	Treat the CSV import as an ETL pipeline.
ELT	Extract, load, transform.	Use ELT if the warehouse should store raw imports.
Migration	Change to database structure or data.	Write a migration for the new progress column.
Seed	Insert starting data.	Add seed data for local demo users.
Config drift	Environment settings differ unexpectedly.	Check for config drift between local and production.
Dependency injection	Passing dependencies in so code is easier to test. Like handing a chef the ingredients instead of making them shop.	Use dependency injection for the email sender.
Separation of concerns	Each part handles one kind of responsibility.	Improve separation of concerns between rendering and saving.
Single responsibility	One module should have one main job.	Apply single responsibility to the export helper.
Layering	Organizing code into levels like UI, API, data.	Preserve layering when adding CRM sync.
Boundary	The line where one system or module meets another.	Validate data at the API boundary.
Adapter boundary	Translation layer between your code and outside service.	Put provider-specific fields at the adapter boundary.
Scalability	Ability to handle growth.	Discuss scalability before adding per-user polling.
Availability	How often the system is up and usable.	Design for availability if this becomes client-facing.
Reliability	How consistently the system behaves correctly.	Improve reliability of scheduled jobs.
Resilience	Ability to recover from failures.	Add resilience when the CRM API is down.
Fault tolerance	Keeps working despite some failures.	Make the import fault tolerant so one bad row does not stop all rows.

Databases And Data

Term	Easier definition	Prompt example
Database	Organized place to store data.	Check the database schema before changing progress logic.
Table	Rows and columns for one type of data.	Add a table for lesson attempts.
Row	One record in a table.	Insert one row per completed lesson.
Column	One field in a table.	Add a column for completed_at.
Primary key	Unique ID for a row.	Use lesson_id as part of the primary key.
Foreign key	Link from one table to another.	Add a foreign key from progress to user.
Index	Data structure that speeds up lookup.	Add an index on user_id and lesson_id.
Unique constraint	Rule preventing duplicate values.	Add a unique constraint on user plus lesson.
Not-null constraint	Rule requiring a value.	Add a not-null constraint for slug.
Query	Request for data from a database.	Optimize the query fetching progress.
SQL	Language for relational databases.	Write SQL for this migration.
NoSQL	Non-relational databases with flexible structure.	Use NoSQL only if flexible document shape matters.
Relational database	Database with structured tables and relationships.	Keep progress in a relational database.
Document database	Stores JSON-like documents.	Consider a document database for variable CRM payloads.
ORM	Tool mapping database rows to code objects. Like a translator between the database and the code.	Use the existing ORM patterns for new queries.
Drizzle	TypeScript ORM used in many Next.js apps.	Follow existing Drizzle schema style.
Migration file	File describing database changes.	Add a migration file for the new table.
Schema drift	Database shape differs from code expectations.	Check for schema drift before debugging the route.
Data integrity	Data remains accurate and valid.	Preserve data integrity during import.
Referential integrity	Links between tables remain valid.	Enforce referential integrity for user progress.
Upsert	Insert if missing, update if present. Like “add it if it’s new, fix it if it’s already there.”	Use upsert for idempotent progress saves.
Join	Combine rows from multiple tables.	Join lessons with progress by lesson ID.
N+1 query	Bug where code runs one query plus many extra queries. Like asking the librarian for one book, then walking back 100 times for one more.	Avoid an N+1 query when loading lesson cards.
Pagination	Splitting large lists into pages.	Add pagination for CRM contacts.
Cursor pagination	Pagination using a pointer to the next page.	Use cursor pagination for stable activity feeds.
Offset pagination	Pagination using page number or row offset.	Offset pagination is fine for small admin lists.
Data model	The structure of stored data.	Review the data model before adding attempts.
ERD	Entity Relationship Diagram.	Create an ERD for users, lessons, labs, and progress.
Denormalization	Duplicating data to make reads easier or faster. Like keeping a copy of a phone number in two places so it’s faster to find.	Denormalize lesson title only if export performance needs it.
Normalization	Structuring data to reduce duplication.	Normalize repeated CRM company fields.
Backup	Copy of data for recovery.	Take a backup before running this migration.
Restore	Recover data from backup.	Document the restore path.
Retention	How long data is kept.	Define retention for imported lead files.
PII	Personally identifiable information.	Treat email and phone as PII.
Data lineage	Where data came from and how it changed.	Track data lineage for enriched CRM fields.
Audit log	Record of important actions.	Add an audit log entry when contacts are merged.
Soft delete	Mark deleted without removing from database. Like moving a file to the trash but not emptying it yet.	Use soft delete for CRM contacts.
Hard delete	Permanently remove data. Like emptying the trash for good.	Only hard delete test records.
ACID	Transaction guarantees: atomic, consistent, isolated, durable. Like a promise the bank won’t lose or mess up your money during a transfer.	Confirm the database is ACID before relying on transactions.
Connection pool	A reused set of open database connections. Like a stack of clean cups ready to reuse instead of washing one each time.	Use a connection pool; serverless can exhaust connections fast.
Connection string	A URL with credentials for reaching a database.	Keep the connection string in env vars, never in code.
Read replica	A copy of the database used only for reads. Like a photocopy you read from so the original isn’t crowded.	Send heavy report queries to a read replica.
Eventual consistency	Data syncs eventually, not instantly. Like two clocks that catch up to the same time after a moment.	The cache is eventually consistent, so allow a short delay.
Locking	Preventing simultaneous conflicting writes.	Check locking behavior before parallelizing the import.
Optimistic locking	Assume no conflict, detect it at write time with a version check. Like editing a shared note and checking nobody changed it before you save.	Use optimistic locking with a version column on contacts.
Blob	Large binary data like files or images. Like one big sealed box holding a picture or file.	Store images in object storage, not as database blobs.

Git And Collaboration

Term	Easier definition	Prompt example
Git	Version control system.	Check git status before editing.
Repository	Project folder tracked by Git.	Inspect the repository before making changes.
Working tree	Current local files, including uncommitted changes.	Preserve the dirty working tree.
Dirty tree	Working tree has uncommitted changes.	The tree is dirty, so avoid touching unrelated files.
Commit	Saved snapshot of changes.	Make a commit only after tests pass.
Branch	Separate line of work.	Create a branch for this feature.
Main branch	Primary branch, often production source.	Do not push directly to main without approval.
Merge	Combine branch changes.	Merge after CI passes.
Rebase	Replay commits on top of another branch. Like redoing your work as if you’d started from the newest copy.	Rebase only if the branch history needs cleanup.
Conflict	Git cannot automatically combine changes.	Resolve the conflict without dropping user edits.
Diff	Difference between file versions.	Show the diff before finalizing.
Patch	A set of file changes.	Apply a narrow patch to the affected route.
Staging	Selecting changes for commit.	Stage only files related to this task.
Untracked file	File Git is not tracking yet.	Leave unrelated untracked files alone.
Blame	Shows who last changed each line.	Use blame to understand why this logic exists.
Bisect	Search commit history to find when a bug started. Like a guessing game: split the list in half to find where the bug started.	Use git bisect if the regression source is unclear.
Pull request	Proposed change for review.	Open a pull request with summary and test evidence.
Code review	Review for bugs, risks, and maintainability.	Do a code review stance on this diff.
Review comment	Feedback on a specific line or change.	Address each review comment with code or explanation.
Changelog	Human-readable list of changes.	Add a changelog note for the new export behavior.
Release notes	User-facing summary of a release.	Draft release notes for this deployment.
Semantic commit	Commit message with type like fix or feat.	Use a semantic commit message.
Conventional commits	Standard commit format like fix: repair progress route.	Use Conventional Commits for this change.
Clone	Copy a remote repository to your machine.	Clone the repo and run setup before editing.
Fork	Your own copy of someone else’s repository.	Fork the repo instead of pushing to upstream.
Remote	The hosted copy of the repo, like origin on GitHub.	Check which remote this branch tracks.
Push	Upload commits to the remote.	Push only after local checks pass.
Pull	Download and merge remote changes.	Pull latest main before starting.
Stash	Temporarily shelve uncommitted changes. Like sweeping your half-done work into a drawer for later.	Stash local edits before switching branches.
Cherry-pick	Copy one specific commit onto another branch. Like taking just one cookie from the batch.	Cherry-pick the fix onto the release branch.
Squash	Combine several commits into one. Like stacking several sticky notes into one.	Squash the WIP commits before merging.
Tag (git)	A named pointer to a specific commit, often a version.	Tag the release as v1.2.0.
HEAD	The commit you currently have checked out. Like a bookmark showing which page you’re currently on.	Confirm HEAD matches main before comparing diffs.
.gitignore	A file listing paths Git should never track.	Add .env.local to .gitignore before committing.

DevOps, Deployment, And Observability

Term	Easier definition	Prompt example
DevOps	Practices connecting development, deployment, and operations.	Handle this with DevOps discipline: build, deploy, smoke test, rollback note.
Deployment	Releasing code to an environment.	Deploy after verification passes.
Environment	Place code runs, like local, staging, or production.	Compare local and production environments.
Local	Your machine.	Verify locally first.
Staging	Test environment similar to production.	Deploy to staging before production if available.
Production	Live environment users rely on.	Do not mutate production data without approval.
Build	Create production-ready app files.	Run the build before deploy.
Artifact	Output from build or work, like a file or bundle.	Save the generated report artifact in docs.
Release	A version shipped to users.	Prepare this as a release with rollback notes.
Rollback	Revert to a previous working release.	Include rollback steps for the migration.
Canary release	Release to small group first. Like letting a few kids taste-test the new cookie first.	Use canary release if this affects many users.
Blue-green deploy	Switch traffic between two production versions. Like having two identical stages and flipping the spotlight to the ready one.	Consider blue-green deploy for zero downtime.
CI/CD	Automated test and deploy pipeline.	Add this check to CI/CD.
Infrastructure	Servers, databases, networks, and deployment config.	Inspect infrastructure before changing scheduled jobs.
Infrastructure as code	Infra defined in files.	Put infrastructure changes in code, not manual notes.
Container	Packaged app with its runtime. Like a lunchbox that carries the food and everything to eat it.	Containerize only if deployment needs it.
Docker	Common container tool.	Add Docker only if local setup requires it.
Server logs	Records from backend execution.	Check server logs for the 500 error.
Client logs	Browser-side logs.	Check client logs for hydration errors.
Observability	Ability to understand system behavior from logs, metrics, and traces. Like having a dashboard that shows what’s happening under the hood.	Add observability for the import pipeline.
Logging	Writing events for debugging and audit.	Add structured logging around failed CRM syncs.
Structured log	Log with fields, not just text.	Use structured logs with contact_id and job_id.
Metric	Numeric measurement over time.	Track a metric for sync success rate.
Trace	Timeline of one request across services. Like following one package’s whole journey through the mail system.	Add tracing if the request crosses multiple services.
Alert	Notification when something is wrong.	Add an alert for repeated job failures.
SLO	Service Level Objective, target reliability level. Like a goal: “the website should work 99 times out of 100.”	Define an SLO for daily sync completion.
SLA	Service Level Agreement, promised reliability to customers. Like a written promise to customers about how reliable it’ll be.	Do not mention SLA unless there is a client promise.
Uptime	Percent of time system is available.	Check uptime needs before adding live dependencies.
Latency	Time it takes to respond. Like how long after you ask before you get an answer.	Measure latency before optimizing.
Throughput	Amount processed per time period. Like how many cars a road can move per hour.	Estimate throughput for imports per minute.
Bottleneck	Slowest limiting part. Like the narrow neck of a bottle that slows everything down.	Find the bottleneck before optimizing the pipeline.
Profiling	Measuring where time or memory is spent. Like timing each part of a race to see what’s slowest.	Profile lesson rendering before changing architecture.
Rate limiting	Restricting request volume.	Add rate limiting to public endpoints.
Quota	Provider-imposed usage limit.	Check API quota before increasing retries.
Cold start	Delay when serverless function starts fresh. Like a car that’s slow to go the first time on a cold morning.	Consider cold start impact on this route.
Health check	Endpoint or command proving service is alive.	Add a health check for the worker.
Smoke check	Quick production check after deploy.	Run a smoke check after Vercel deploy.

Security, Privacy, And Auth

Term	Easier definition	Prompt example
Authentication	Proving who a user is.	Review authentication before changing login.
Authorization	Deciding what a user can access.	Add authorization checks to the export route.
AuthN	Short for authentication.	Separate AuthN from AuthZ in the design.
AuthZ	Short for authorization.	Add AuthZ tests for private progress data.
RBAC	Role-based access control. Like giving keys based on your job: teachers get more doors than students.	Use RBAC if admins and learners need different permissions.
Least privilege	Give only the access needed. Like only giving someone the one key they actually need.	Apply least privilege to API tokens.
Principle of least privilege	Same as least privilege.	Follow the principle of least privilege for service accounts.
Secret management	Safe storage and use of keys and tokens.	Improve secret management for Vercel env vars.
Encryption	Scrambling data so only authorized parties can read it. Like a secret code only the right key can unlock.	Encrypt sensitive tokens at rest.
Hashing	One-way transformation, often for passwords. Like a blender that turns a password into mush you can’t un-blend.	Hash passcodes rather than storing plaintext.
Salting	Adding random data before hashing passwords. Like adding a secret sprinkle before blending so two same passwords look different.	Use salting for password hashes.
TLS	Encryption for network traffic. Like a sealed envelope so no one reads your letter on the way.	Verify TLS on production URLs.
Input validation	Checking incoming data.	Add input validation to the webhook handler.
Output encoding	Making output safe for its context.	Use output encoding before rendering user text.
Threat model	Structured review of possible attacks. Like planning how a burglar might get in so you can lock those spots.	Create a threat model for the CRM integration.
Attack surface	Places an attacker can try to break in.	Reduce attack surface by removing unused public routes.
Vulnerability	Weakness that can be exploited.	Check whether this dependency vulnerability is reachable.
Exploit	A method of using a vulnerability.	Explain whether there is a practical exploit path.
Dependency audit	Scan packages for known vulnerabilities.	Run a dependency audit and summarize actionable findings.
Token	Secret or signed value used for access.	Do not log tokens.
API key	Secret used to call an API.	Store the API key in env vars.
Scope	Permission range for a token.	Use the narrowest OAuth scope.
PII handling	Safe treatment of personal data.	Add PII handling rules to this import workflow.
Data minimization	Store only what you need.	Apply data minimization to lead enrichment.
Consent	User permission to collect or use data.	Confirm consent before syncing contacts.
Audit trail	History of who did what.	Add an audit trail for admin exports.

CRM Implementation And Automation

Term	Easier definition	Prompt example
CRM	Customer Relationship Management system.	Design the CRM workflow for lead intake and follow-up.
Lead	A potential customer.	Import new leads from the spreadsheet.
Contact	A person record in the CRM.	Dedupe contacts by email and phone.
Account	A company or organization record.	Link contacts to accounts when company is known.
Opportunity	A potential deal being tracked.	Create an opportunity when a lead books a call.
Pipeline	Stages a deal moves through.	Map the sales pipeline stages before automation.
Stage	One step in a pipeline.	Move opportunity to Qualified after the form is complete.
Deal	Sales opportunity with value and status.	Add deal value to the opportunity record.
Task	CRM reminder or to-do.	Create a follow-up task for stale leads.
Activity	Logged call, email, SMS, meeting, or note.	Log an activity when the webhook sends an SMS.
Touchpoint	Any interaction with a lead or customer.	Find contacts with no touchpoint in 14 days.
Cadence	Planned sequence and timing of touches.	Build a follow-up cadence for new leads.
Sequence	Automated series of messages or tasks.	Put cold leads into a nurture sequence.
Nurture	Long-term follow-up to build interest.	Add a nurture path for leads not ready to buy.
Segmentation	Grouping contacts by traits or behavior.	Segment leads by source and urgency.
Lead source	Where a lead came from.	Preserve lead source during import.
Attribution	Linking outcomes to sources or campaigns.	Add attribution for booked calls by channel.
Lifecycle stage	Broad customer status like lead, prospect, customer.	Update lifecycle stage after conversion.
Qualification	Deciding if a lead is worth pursuing.	Add qualification rules before assigning sales tasks.
Lead scoring	Numeric rating of lead quality.	Create lead scoring based on intent and fit.
Routing	Sending leads to the right owner or workflow.	Add routing rules by location and budget.
Assignment	Giving ownership to a user or team.	Assign hot leads to the sales owner.
SLA	Required response timing promise.	Add an SLA for first response under 5 minutes.
Dedupe	Remove or merge duplicates.	Dedupe contacts before creating opportunities.
Merge	Combine duplicate records.	Merge duplicate contacts and preserve activity history.
Custom field	CRM-specific extra field.	Add a custom field for property address.
Field mapping	Matching source columns to CRM fields.	Create field mapping for the Google Sheet import.
Required field	Field that must be filled.	Validate required fields before CRM create.
Picklist	Fixed list of allowed values.	Map status values to the CRM picklist.
Tag	Label applied to records.	Add a tag for webinar leads.
List	Saved group of contacts.	Build a list of uncontacted leads.
Smart list	Dynamic list based on rules.	Create a smart list for leads due today.
Workflow automation	Rules that trigger CRM actions.	Build workflow automation for missed-call follow-up.
Trigger	Event that starts automation.	Use form submission as the trigger.
Condition	Rule that decides a path.	Add a condition for has phone number.
Branch	Split path in automation.	Branch by lead source.
Action	Step the automation performs.	Add an action to create a task.
Enrollment	Adding a contact to automation.	Prevent duplicate enrollment in the sequence.
Suppression list	Contacts excluded from messages.	Check suppression list before sending SMS.
DND	Do Not Disturb flag.	Respect DND before any outreach.
Opt-in	Permission to receive messages.	Require opt-in before SMS automation.
Opt-out	User asks to stop messages.	Honor opt-out immediately.
Deliverability	Likelihood messages reach inbox or phone.	Check deliverability before scaling outreach.
Bounce	Email that could not be delivered.	Suppress bounced emails.
Reply detection	Detecting inbound responses.	Add reply detection to pause the sequence.
Handoff	Passing from automation to a human.	Add human handoff when a lead asks pricing.
Call disposition	Outcome label for a call.	Log call disposition after the voice agent ends.
Pipeline hygiene	Keeping CRM data clean and useful.	Improve pipeline hygiene by closing stale opportunities.
Data enrichment	Adding missing info from external sources.	Enrich leads with company website and role.
Web form	Form that captures leads.	Connect the web form to CRM intake.
Intake	First capture of a lead or request.	Build intake validation before creating contacts.
Round robin	Assigning leads evenly across owners.	Use round robin for sales assignment.
Sales velocity	Speed deals move to revenue.	Track sales velocity by lead source.
Conversion rate	Percent moving from one stage to another.	Report conversion rate from lead to booked call.
Funnel	Stages from awareness to purchase.	Build a funnel report for the campaign.
Churn	Customers leaving.	Add churn-risk signals to CRM tasks.
Renewal	Existing customer buying again or extending.	Create renewal reminders 30 days before expiry.

AI, LLM, And Data Products

Term	Easier definition	Prompt example
AI agent	AI system that can use tools and pursue tasks.	Build this as an AI agent with clear tool boundaries.
LLM	Large language model.	Use an LLM for summarization, not source-of-truth storage.
Model	The AI system generating output.	Compare model choices for cost and reliability.
Inference	Running a model to get an output. Like the moment the AI actually thinks up an answer.	Estimate inference cost for this workflow.
Prompt	Instruction sent to a model.	Rewrite the prompt to reduce ambiguity.
Completion	Model’s generated response.	Validate the completion before saving it.
Token	Chunk of text processed by a model.	Reduce token usage by summarizing long transcripts.
Context	Information provided to the model.	Include only relevant context.
RAG	Retrieval Augmented Generation, answering with retrieved documents. Like an open-book test, the AI looks things up before answering.	Use RAG for lesson Q&A over local docs.
Retrieval	Finding relevant source chunks.	Improve retrieval for CRM policy docs.
Embedding	Numeric representation of text meaning. Like turning words into dots on a map so similar ones sit close together.	Generate embeddings for lesson search.
Vector database	Database optimized for embedding search. Like a library sorted by meaning, not by title.	Use a vector database only if keyword search is insufficient.
Chunking	Splitting documents into smaller pieces.	Improve chunking for long lesson files.
Reranking	Reordering retrieved results by relevance. Like reshuffling search results so the best one is on top.	Add reranking if retrieval returns weak chunks.
Tool calling	Model asks to run a defined tool.	Use tool calling for database lookup.
Function calling	Older or related term for tool calling.	Define function calling schema for contact lookup.
Structured output	Model output forced into JSON or schema.	Require structured output for extracted fields.
JSON schema	Rules for valid JSON shape.	Use JSON schema for the extraction response.
Eval	Test for AI output quality.	Add evals for lead summary quality.
Ground truth	Known correct answer for evaluation.	Create ground truth examples for extraction.
Prompt regression	Prompt quality gets worse after changes.	Add evals to catch prompt regression.
Temperature	Randomness setting for model output. Like a knob for how wild or safe the AI’s answers are.	Lower temperature for deterministic extraction.
Fine-tuning	Training a model on examples for a narrower task. Like extra coaching to make the AI good at one specific job.	Consider fine-tuning only after prompt and RAG fail.
Guardrail	Rule preventing unsafe or wrong AI behavior.	Add a guardrail against inventing lead details.
Moderation	Checking content for policy or safety issues.	Add moderation for user-submitted text.
AI hallucination	AI invents unsupported information.	Reduce hallucination by requiring citations from retrieved docs.
Agent loop	Repeated cycle of plan, act, observe.	Keep the agent loop bounded to avoid runaway actions.
Multi-agent	Multiple AI agents working on separate roles.	Use multi-agent review for architecture and QA.
Orchestration	Coordinating tools, models, and steps.	Design orchestration for scrape, enrich, score, and draft.
Human review	Person checks AI output before use.	Require human review before sending outbound messages.
Confidence score	Numeric estimate of certainty.	Add confidence score to extracted lead fields.
Streaming	Model output delivered token by token as it generates.	Stream the response so the UI feels responsive.
System / user / assistant roles	The three message types in a chat API conversation.	Put the formatting rules in the system role, not the user message.
Latency vs cost tradeoff	Bigger models are smarter but slower and pricier.	Use a small model for classification and a big one for drafting.

Engineering Slang

These are the culture terms engineers use as shorthand. Like “blast radius”, each one compresses a whole concept into two words.

Term	Easier definition	Prompt example
Footgun	A feature or API that makes it easy to hurt yourself. Like a tool so easy to misuse you can hurt yourself with it.	Flag any footguns in this API design before I ship it.
Yak shaving	A chain of side tasks that pulls you away from the real goal. Like having to find your shoes to find your keys to finally leave.	Stop the yak shaving; mock the dependency and move on.
Bikeshedding	Debating trivial details while ignoring the hard problem. Like arguing about paint colors instead of building the house.	No bikeshedding on button color; decide the data model first.
Rubber ducking	Explaining a problem step by step to find the answer yourself. Like explaining your problem to a toy until you spot the answer yourself.	Rubber duck this bug with me: walk through what each line does.
Spaghetti code	Tangled code with unclear flow. Like tangled headphone wires you can’t trace.	Untangle the spaghetti in this handler before adding features.
God object	One object or module that knows or does too much. Like one kid who insists on doing every job in the group project.	Split the god object into focused modules.
Shotgun surgery	One small change requiring edits in many scattered places. Like fixing one typo means editing fifty different pages.	This change smells like shotgun surgery; centralize the config first.
Greenfield	A new project with no legacy constraints. Like building on an empty lot with no old house in the way.	Treat this as greenfield and pick the simplest stack.
Brownfield	Working inside an existing legacy system. Like remodeling an old house you can’t tear down.	This is brownfield work; match the existing patterns.
Bus factor	How many people can disappear before critical knowledge is lost. Like how many teammates could be out sick before nobody knows how things work.	Document the deploy steps so the bus factor is not one.
Tribal knowledge	Important knowledge that lives only in people’s heads. Like a secret recipe only grandma remembers.	Turn the onboarding steps from tribal knowledge into a doc.
Dogfooding	Using your own product to find its problems. Like a chef eating their own cooking to spot problems.	Dogfood the CRM flow yourself before showing the client.
Vendor lock-in	Becoming dependent on one provider’s ecosystem. Like a game console that only plays one company’s games.	Note the vendor lock-in risk before going all in on this API.
Escape hatch	A built-in way to bypass an abstraction when it falls short. Like a secret exit when the normal door won’t work.	Add an escape hatch for raw SQL where the ORM cannot express the query.
Kill switch	A fast way to turn a feature off in production. Like a big red OFF button.	Add a kill switch for the auto-send feature.
Hotfix	An urgent fix shipped outside the normal process.	Ship a hotfix for the broken login, then do the proper fix.
Incident	An unplanned production problem being actively handled.	Treat the duplicate sends as an incident and trace the cause.
Postmortem	A blameless write-up after an incident: what broke and why.	Write a short postmortem for the failed deploy.
Heisenbug	A bug that disappears when you try to observe it. Like a bug that hides the moment you look for it.	This flake may be a heisenbug; add logging instead of breakpoints.
Works on my machine	A bug that only reproduces in some environments.	Do not accept works-on-my-machine; reproduce it in a clean environment.
Cargo culting	Copying patterns or config without understanding why. Like copying a dance move without knowing what it’s for.	Do not cargo cult the webpack config; justify each option.
Golden path	The officially supported, well-tested way to do something. Like the well-marked trail everyone’s meant to take.	Stay on the golden path of the framework unless there is a real reason.
Sane defaults	Default settings that work well without tweaking.	Give the CLI sane defaults so flags are rarely needed.
Batteries included	Tool ships with everything needed out of the box.	Prefer a batteries-included framework for this MVP.
Bleeding edge	The newest, least proven version of a technology. Like a brand-new toy that might still break.	Avoid bleeding-edge releases for the client project.
Battle-tested	Proven reliable through heavy real-world use. Like an old toy that’s survived years of rough play.	Pick the battle-tested library over the newer one.

Useful Prompt Verbs

These verbs are often enough to make the agent behave more precisely.

Verb	Easier definition	Prompt example
Inspect	Look at the real thing first.	Inspect the current route, tests, and browser behavior before editing.
Reproduce	Make the bug happen again.	Reproduce the failed save before patching.
Diagnose	Find what is wrong.	Diagnose why the webhook creates duplicate contacts.
Isolate	Separate the problem from unrelated parts.	Isolate whether this is frontend state or API persistence.
Patch	Make a focused fix.	Patch the validation bug with minimal blast radius.
Refactor	Improve structure without behavior change.	Refactor after the behavior test passes.
Harden	Make more reliable against failures.	Harden the import flow against malformed rows.
Instrument	Add logs, metrics, or traces.	Instrument the worker with structured logs.
Validate	Check data or assumptions.	Validate the incoming webhook body.
Normalize	Convert messy data into standard form.	Normalize phone numbers before lookup.
Dedupe	Remove duplicates.	Dedupe contacts before import.
Backfill	Fill missing historical data.	Backfill completed_at for old progress rows.
Migrate	Move data or schema safely.	Migrate the progress table without losing rows.
Smoke test	Quick real-world check.	Smoke test the changed flow in Browser.
Regression test	Add a test for a bug that was fixed.	Add a regression test for the stale route state.
Document	Write durable explanation.	Document the new workflow in docs.
Ship	Finish and deploy.	Ship after typecheck, lint, tests, build, and smoke pass.

Copy-Paste Prompt Templates

Narrow Bug Fix

Inspect the current implementation and reproduce the bug first. Then patch the smallest responsible area, keep the public API stable, add or update a regression test, and verify with the relevant repo commands. Report files changed, proof, and any residual risk.

UI Change

Make a focused UI change to [screen/component]. Preserve existing design patterns, check mobile and desktop, avoid layout shift, and verify in Browser. Do not touch unrelated state or API logic unless required.

CRM Automation

Map the CRM workflow first: trigger, conditions, branches, actions, suppression rules, and human handoff. Then build or document the automation with dry-run proof. Do not send live messages or mutate production records without explicit approval.

Refactor

Refactor [module] without changing behavior. Keep the external contract stable, reduce coupling or duplication, and prove equivalence with existing tests plus one targeted smoke check if UI behavior is involved.

Agent Handoff

Create a handoff for the next agent with current state, goal state, scope, non-goals, key files, commands to run, known blockers, and acceptance criteria. Keep it in Markdown and make it executable, not theoretical.