Make the coding lingo click.

Observable conditions that define success.

Making software usable with different abilities and access methods.

An application programming interface defining how software pieces interact.

An ordered collection of values.

JavaScript syntax for writing promise-based asynchronous work in a sequential-looking form.

Work whose result arrives later, such as fetching data.

Establishing who a user or system is.

Deciding which actions and resources a caller may access.

Code checking behavior or properties.

Code handling server-side work and business rules.

Saving recoverable data copies and recovering from them.

A data type with two values: true and false.

A separate line of development.

Facilities such as localStorage and IndexedDB for data in a browser.

A difference between intended and actual behavior.

The process of preparing project files to run or distribute.

A stored copy used to avoid repeating expensive work.

Automated integration checks and delivery or deployment workflows.

A command-line interface operated through text commands.

A function together with access to variables in the surrounding scope where it was created.

A recorded snapshot of changes in Git.

A tool that translates code into another representation, such as machine code, bytecode, or another language. Compilation can happen ahead of time or while a program runs.

A reusable interface block, such as a button or product card.

A decision expressed in code, often using if and else.

Settings determining how software behaves.

A packaged process environment for running software with its dependencies.

Data a browser stores and sends with matching requests under cookie rules.

Browser rules for controlled access to responses across origins.

Create, read, update, and delete.

Rules controlling colors, spacing, typography, and layout.

The kind of value something holds, such as a number or string.

A system for storing and retrieving information.

Waiting for activity to pause before running an action.

Investigating why a problem occurs.

Code, a tool, a runtime, or a service that another part of a project relies on. A dependency can be local or supplied by another project.

Making an application version available in a target environment.

Shared interface components, styles, and usage rules.

A named design value, such as a color or spacing size.

A server used while building an application.

A comparison showing added, removed, and changed lines.

The system that resolves domain names into records used to locate services.

The document object model, the browser's representation of a page.

A human-readable name in the internet's naming system.

What appears when there is no content to show.

Protecting data through a transformation requiring a key to reverse.

A specific API address and operation.

A named setting supplied outside source code.

Feedback when an operation fails.

Code that runs after a click, keystroke, submission, or other event.

An exception signals an execution problem; its stack trace shows associated calls.

A setting that enables or disables a behavior.

A structure and set of conventions for building an application.

The application part users interact with.

Work spanning the front end and back end.

A reusable piece of code that performs a task.

A version-control system recording changes and supporting parallel development.

A query language and execution approach for APIs where clients request fields described by a schema.

A function that connects React components to features such as state or effects.

Providing the infrastructure that serves or runs an application.

Markup describing a web page's content and structure.

A protocol for web requests and responses.

HTTP carried over an encrypted TLS connection.

An integrated development environment for writing and inspecting code.

Repeating an operation has the same intended effect as doing it once.

Treating an existing value as unchanged and creating a new value when an update is needed.

Ways modules share and use code.

A database structure that speeds up certain lookups.

Checking incoming data against rules.

Software that executes source code or an intermediate representation.

A programming language used for web behavior and server applications.

A text format for structured data.

Granting only the access needed for a task.

Reusable code your application calls for a particular job.

Automated checks for suspicious patterns and style issues.

Feedback while work is in progress.

A special hostname that resolves to a loopback address in the current network environment. In a container or remote environment, it may refer to that environment rather than your physical computer.

A file recording resolved dependency versions.

Recording events to explain application behavior.

Code that repeats an operation.

Combining changes from different development histories.

A situation Git cannot combine automatically.

A recorded change to database structure or data.

Invented data used for development or demonstration.

A unit of code with a defined boundary for what it exposes.

A minimum viable product that tests a useful product assumption.

A framework built around React with application and server features.

A JavaScript runtime used outside the browser.

A JavaScript package manager and package ecosystem.

In JavaScript, null commonly marks an intentional absence; undefined commonly means a value has not been supplied or assigned.

A value grouping related properties, and sometimes behavior.

Showing an anticipated change before the server confirms it.

A distributable bundle of code, often a library or tool.

A tool that installs and manages packages.

A file describing a project's package metadata, scripts, and dependencies.

Loading or displaying a collection in smaller portions.

A parameter names a function input; an argument is the value supplied.

A numbered network destination for a service on a host.

A primary key uniquely identifies a row using one or more non-null columns. A foreign key enforces references to valid keys in the same or another table, subject to the database’s null and update/delete rules.

The environment serving real users or real work.

A system for expressing instructions, such as Python or JavaScript.

Revealing less common controls when needed.

A JavaScript object representing an eventual completion value or failure reason. It can be pending, fulfilled, or rejected; a rejection reason does not have to be an Error object.

Inputs passed into a component.

An early implementation used to explore an idea.

A proposal to merge changes, often abbreviated PR.

A request to retrieve or manipulate stored data.

A bug where the result depends on the timing of operations.

Restricting how frequently an operation can occur.

A JavaScript library for building interfaces from components.

Changing code structure while preserving intended behavior.

A new problem in behavior that previously worked.

A project's files and version history, often called a repo.

Layout behavior that adapts to screen sizes.

An architectural style for networked systems organized around resources and a consistent interface.

The result a function sends back to its caller.

Returning to an earlier application or configuration version.

A mapping from a URL or path to a page or handler.

The environment that executes your code.

Sanitization removes unwanted content; encoding represents text safely for an output context.

The structure and rules governing data.

The part of a program where a particular name can be accessed.

A software development kit containing tools and libraries for a platform.

A secret is sensitive information such as a private credential. An API key identifies or authorizes API use; some providers offer publishable keys as well as secret keys. Follow the provider’s rules for each key type.

Using HTML elements that express the purpose and structure of content.

Software, or its computer, that responds to requests.

A hosting model where a provider manages server execution infrastructure.

A way to maintain continuity across requests, often for a signed-in user.

An observable change beyond returning a value, such as writing a record, changing shared state, or sending a request.

Human-readable instructions that make software work.

A language for querying and modifying relational databases.

A pre-release environment used for checking changes.

Information the application currently remembers.

A CSS framework that provides utility classes for styling.

Accumulated design or implementation shortcomings that make future changes harder or more costly. The extra effort is often described as interest on the debt.

A terminal displays a command session; a shell interprets commands.

A group of database operations treated as a unit.

JavaScript with a type system that catches certain development mistakes.

Tests of a small unit, cooperating pieces, and an overall user journey.

A resource address that can include a scheme, host, path, and query.

The sequence a person follows to complete a task.

A short description of a user need and its purpose.

A name associated with a value.

A weakness that can be exploited to compromise security.

A request a service sends when an event occurs.

A rough layout showing structure before detailed styling.

A routing channel that groups audio signals for shared level control and processing.

A server that decides the accepted outcome of relevant multiplayer rules rather than trusting a client's claim.

Whether the game page or interaction surface currently receives the relevant input and attention.

A planned limit for the assets and preparation required before useful browser gameplay begins.

The platform and configuration for which a game is prepared and packaged.

A browser game that draws part or all of its presentation into an HTML canvas.

Locally anticipating the result of a player's input before the authoritative result arrives.

Determining when shapes touch, overlap, or intersect, often as part of a physics or gameplay system.

A platform's review process for checking release requirements and expected system integration behavior.

Development hardware or a platform-provided environment used to build, inspect, and test games for a console.

A planned allocation of frame time, memory, and other resources for the targeted console configuration.

A layout region used to keep important game interface content within supported display and platform constraints.

A situation where multiple valid versions of a player's progress need an explicit resolution policy.

The platform-level user identity associated with a player, services, and potentially that player's saved data.

The behavior shown when a game loses a controller or another required input device.

The elapsed or scheduled time interval supplied to an update, used to express rates independently of update count.

A multiplayer approach that advances simulations from coordinated inputs under an expectation of matching results.

A region intended for important interface content around display cutouts, rounded edges, and system-controlled areas.

A request for the graphics system to render a group of geometry using specified rendering state.

An architecture that represents entities through sets of data components and processes matching data through systems.

The number of rendered game images produced each second, commonly expressed as frames per second or FPS.

The time required or observed for an individual frame, usually measured in milliseconds.

Combining animation poses or transitions to produce a controlled visual result as game conditions change.

The process that turns source art, audio, and design data into resources a game can load and use.

The system that defines the player's view of the game world, including position, orientation, and projection.

The reference system used to interpret a position or direction, such as local, world, or screen coordinates.

A development display of measurements or state that helps explain what a game is doing.

A collection of tools and runtime systems for building and running games, often covering scenes, rendering, physics, audio, and input.

The repeating cycle that gathers input, advances game behavior, and prepares the next displayed result.

A rendering configuration that connects a shader with its parameters, textures, and other appearance settings.

A boundary that separates shared gameplay from platform-specific services and behavior.

A tool for measuring where a running game's time and other resources are spent.

A persistent representation of selected progress that can reconstruct the intended game state after the process ends.

A structured collection of game objects and their relationships, often saved as a reusable unit or playable area.

A model that describes allowed states and transitions for a character, interface, or whole game.

Temporarily stopping active execution and later reestablishing a valid playable state.

Encoding texture data in formats that reduce storage or graphics-memory costs, with quality and compatibility tradeoffs.

A region near an analog stick's neutral position where small movement is ignored or adjusted.

A named collection of rendering settings intended to provide a practical quality and performance tradeoff.

Tactile feedback produced by a device, such as a brief vibration associated with an in-game event.

A deliberate set of hardware, operating-system, display, and input combinations used to guide PC testing.

A canvas whose drawing-buffer size is managed separately from its displayed size for dense-pixel screens.

Gameplay shapes used to decide where an attack can connect and where a target can receive it.

A layer that maps physical inputs to named game actions such as move, jump, interact, and pause.

A technique that accounts for communication delay when evaluating time-sensitive multiplayer interactions.

Using different representations of an object or effect according to its importance, distance, or other criteria.

Selecting compatible players or groups for a multiplayer session according to defined criteria.

Managing when rendered frames are delivered so motion feels consistently timed on mobile displays.

The transitions a game experiences as it gains focus, loses focus, moves to the background, resumes, or terminates.

A planned limit for memory use across textures, audio, scenes, scripts, and temporary allocations on target devices.

A mode where a game receives relative mouse movement and controls how the pointer is confined or hidden.

The lifecycle of a shared game instance, including joining, playing, leaving, disconnection, and completion.

Following multiple simultaneous contact points using their individual identifiers and lifecycles.

A representation of traversable space used by navigation systems to plan movement through an environment.

The frequency of a defined networked update or server simulation step, whose exact meaning must be specified.

Reusing a managed collection of objects instead of repeatedly creating and discarding them during play.

Avoiding rendering work for objects hidden behind other geometry when the renderer can establish that they are not visible.

The platform-appropriate location and ownership model used to store a desktop game's progress and configuration.

A platform-recognized accomplishment awarded when a game's defined conditions are satisfied.

A browser capability that lets an application receive relative pointer movement while locking the pointer to a target.

An initial value that helps determine a reproducible pseudorandom sequence under a defined algorithm and call order.

A browser scheduling API that requests a callback around a future rendering opportunity.

Rendering a game at a resolution different from the final display output, then mapping it to the displayed image.

Configuration that controls how a source asset becomes a runtime resource for a game.

A saved reusable arrangement of game objects and configuration that can be instantiated repeatedly.

Correcting a client's predicted state using acknowledged authoritative state and the relevant pending inputs.

A program executed as part of a graphics pipeline to determine operations such as vertex transformation or pixel appearance.

A visible hitch caused when work to prepare a shader or graphics pipeline occurs during an interactive moment.

The amount of simulated time advanced by one update of game rules or physics, often kept fixed.

Rendering remote game objects using buffered state samples to smooth their apparent movement.

Audio whose presentation varies with a source's location and the listener's position or orientation.

A larger texture that packs multiple smaller sprite images together with metadata describing each region.

Communicating selected game-state changes so remote participants can maintain useful local representations.

A device reducing operating performance to manage heat, which can affect a game's sustained behavior.

A grid or structured arrangement of reusable tiles used to build game levels and related data.

The screen area that accepts a tap or gesture for a mobile game control.

A touch interface that translates finger position or movement into a directional control value.

Synchronizing presentation with the display's refresh timing to help avoid visible tearing.

A user-initiated step that allows a browser game to start or resume its audio processing under applicable browser policy.

Fetching, decoding, and preparing assets before or during a browser game's execution.

Storing selected browser-game progress so the intended data survives reloads or later visits.

A browser graphics interface used to draw hardware-accelerated scenes through a canvas.

A documented structure for failures, including machine-readable categories and useful user-facing context.

Changing an API’s data shape or rules while accounting for clients using earlier behavior.

A server layer shaped around the needs of a particular interface or client.

A mechanism that records work for workers to execute outside the immediate request.

A browser-controlled decision about a site’s use of a protected capability.

A managed set of reusable connections to a database or other service.

An interface input whose displayed value is coordinated with application state.

The way an element occupies space through its content, padding, border, and margin.

A layout system that arranges items along a main axis and a cross axis.

A layout system that places elements into rows and columns with explicit or automatically created tracks.

An agreed structure and meaning for values crossing a boundary between software parts.

The path a value takes from input through processing and storage back to its visible result.

An HTTP validator identifying a particular representation version for conditional requests.

Handling events on a stable ancestor instead of attaching a separate listener to each child.

Deciding where keyboard focus moves as an interface opens, closes, or changes.

The process of choosing a suitable representation using request information and server capabilities.

The part of an HTTP request that expresses the operation’s intended semantics, such as reading or submitting data.

Connecting client-side application behavior to markup that was initially rendered elsewhere, commonly on a server.

Code that participates in a request pipeline before or after the main handler.

A web application that uses relevant browser capabilities to offer a more app-like experience.

Metadata sent with a request, separate from its address and body.

The sequence of processing a request from arrival through parsing, checks, business work, and the response.

The form in which a resource is delivered, such as JSON, HTML, or a particular language.

A browser security boundary that restricts certain interactions between documents and resources from different origins.

Producing page markup on the server before sending it to the browser.

Checking incoming values in the trusted processing environment before applying an operation.

A browser-managed worker that can handle specified events and participate in requests within its scope.

A representation of the product concepts and rules used across relevant parts of an application.

A metadata file describing aspects of a web application’s presentation and identity to supporting browsers.

JavaScript execution in a worker context separate from a page’s main execution context.

An Android application component associated with a user interaction entry point and system-managed lifecycle.

A system configuration transition, such as a size or orientation change, that can affect app resources and component instances.

A message describing an operation or interaction between Android components.

An app configuration file declaring information about components and supported platform interactions.

A lifecycle-aware holder for screen-related state and logic that can outlive certain UI recreation events.

Declared capabilities associated with a signed app and its permitted system integrations.

A shared interface that hides appropriate differences between operating-system implementations.

A check for whether the current environment supports the operation the app wants to offer.

An instance of an app’s user interface with lifecycle events that the app must handle.

A system facility for storing small sensitive items such as credentials using platform access controls.

Layout guides that help position content relative to system interface and display features.

Android’s declarative interface toolkit for expressing UI from state.

An application layer that coordinates data sources and provides a consistent data interface to other layers.

Reconstructing a useful user interface after component recreation or a later app launch.

A controlled boundary through which shared application code invokes platform-specific functionality.

Designing critical behavior to remain useful with local data when a reliable network is unavailable.

Registering work with an appropriate platform facility so execution can be managed across relevant app lifecycle changes.

A message-based route between a framework layer and platform-specific code.

The degree to which supported platforms deliver equivalent intended capabilities.

Product rules reused across mobile targets while interface and system integration may remain different.

Apple’s declarative interface framework for expressing views in terms of data and state.

A disagreement between versions of data changed in different places.

Apple’s interface framework providing objects and infrastructure for event-driven app interfaces.

An arrangement where state drives the interface and user events request state changes through a defined path.

Preparing an application and its deployment metadata or assets in a form suitable for installation or distribution.

A named command-line option that changes behavior or supplies a setting.

Applying a cryptographic signature that lets a platform or recipient check a publisher identity and package integrity under its trust rules.

A value supplied to a command-line program as part of its invocation.

Separating a desktop web interface’s JavaScript context from privileged preload or internal framework context.

A file address handled with the conventions of its target operating system rather than assumed string formatting.

The privileged application process that coordinates windows and operating-system integration in architectures such as Electron.

Code used to prepare a renderer’s environment and carefully expose supported application capabilities before page code runs.

A process responsible for rendering a web-based application interface in a multi-process desktop architecture.

The creation, activation, minimization, closing, and cleanup of an application window.

An application organized around opening, editing, saving, and closing user documents.

A mode that reports intended effects without applying the changes it represents.

A process result code that a calling shell or program can inspect.

An operating-system relationship that lets an app participate in opening a supported file type.

An interface layout that remains readable and correctly sized when display scaling or pixel density changes.

Messages exchanged between separate processes through defined communication mechanisms.

A conventional output stream for diagnostics, separate from normal result output.

Conventional streams used to receive input and produce program output.

A table-like data structure whose columns can hold different kinds of values.

The relationship between the number of matching records on each side of a join.

A subdivision of a dataset, often based on a date or other commonly filtered value.

An explicit agreement about a dataset's fields, meaning, quality expectations, and change process.

A record of where data came from and which transformations produced it.

A managed set of connections reused across requests or jobs.

A rule enforced by the database to restrict which records are valid.

Organizing relational data to reduce avoidable duplication and inconsistent updates.

Two pipeline patterns: extract-transform-load performs transformation before loading, while extract-load-transform transforms after loading.

Computing summaries separately for records sharing one or more values.

A pipeline that processes new or changed data instead of rebuilding every result from scratch.

Values that are absent, unknown, invalid, or not collected.

The database's chosen sequence of operations for producing a query result.

Managing changes to the shape and meaning of data over time.

Rules determining how concurrent transactions observe and interfere with one another's changes.

Defined application behavior when a model, retrieval step, or tool cannot provide a usable result.

A table counting how predicted classes compare with actual classes.

Information crossing an evaluation boundary in a way that would not be available during real use.

A simple reference method measured on the same examples as a proposed model or prompt.

An optimization approach that updates model parameters in a direction intended to reduce a loss.

An input variable or representation used by a machine-learning model.

Using a trained model to produce a prediction or other output for new input.

Learning details of the training examples that do not transfer well to new examples.

Precision asks how many predicted positives are correct; recall asks how many actual positives were found.

How closely predicted probabilities correspond to observed frequencies over comparable cases.

A bounded piece of source material indexed or supplied for retrieval-based answering.

Reordering an initial set of retrieved candidates using a second relevance assessment.

Delivering output in pieces as it becomes available instead of waiting for the complete response.

A machine-readable description of the arguments a callable operation accepts.

Separating examples for fitting a model, choosing its configuration, and assessing the final approach.

A destination for work items that cannot be processed successfully under the normal retry policy.

A mode that reports intended changes while avoiding the corresponding mutation.

A pattern that selects paths by matching parts of their names.

A collection of work items waiting for workers to process them.

A numeric result returned when a process finishes, conventionally zero for success and nonzero for failure.

Increasing or otherwise controlling the delay between repeated attempts after a failure.

The named time zone used to interpret a recurring job's wall-clock schedule.

Three conventional process streams for receiving input, returning output, and reporting diagnostics.

A durable marker of successfully completed work used to resume a multi-step process.

The directory against which a process resolves relative paths unless code specifies another base.

Rules governing how compiled components exchange calls and data at the binary level.

An operation that appears indivisible with respect to the relevant concurrent observers.

A mechanism that limits incoming work when downstream processing cannot keep up.

Access to a value whose lifetime remains controlled by another owner.

The order in which the bytes of a multi-byte value are represented.

A state where work cannot proceed because participants wait for resources or actions that depend on one another.

A boundary allowing code written for different language environments to call each other.

A model for deciding which part of a program is responsible for a value and its lifetime.

Converting application values into an agreed representation for storage or transmission.

A mutual-exclusion mechanism used to protect a critical section from simultaneous access.

Two common memory-management concepts: stack storage follows call-related lifetimes, while heap allocations can have more flexible lifetimes.

A reliable, ordered byte-stream transport between endpoints while the connection is operating.

An execution path within a process that can run concurrently with other threads.

The total time allowed for an operation, divided across connection, request, processing, and retry stages.

A message-oriented transport unit that can arrive without a delivery or ordering guarantee from UDP itself.

Adjusting resource capacity according to a defined signal and policy.

A policy that temporarily stops or limits calls to a repeatedly failing dependency and probes for recovery.

A packaged filesystem and metadata used to create a container instance.

A configured boundary on resources a container may consume, with enforcement behavior depending on the resource and platform.

Storage mounted into a container with a lifecycle distinct from its writable container layer.

Repeatedly comparing an intended configuration with the observed system and acting to reduce the difference.

A representation of related operations across components for one request or workflow.

The amount of unreliability allowed by a service objective over its measurement window.

A reusable filesystem change in a layered container image.

Representing infrastructure configuration in versioned, machine-readable files.

A component that distributes incoming work across multiple service instances.

Checks used to distinguish whether an instance should receive traffic and whether it needs recovery by restart.

Provider-defined locations and subdivisions used to organize infrastructure and failure boundaries.

A measured signal representing some aspect of service behavior.

A target for a defined service level indicator over a stated period.

A hash computed from an artifact's contents that can identify an exact byte sequence.

Information connecting an artifact with its source and build process.

A risk where a browser is induced to send an unintended authenticated request to another site.

A vulnerability where untrusted content is interpreted as executable browser code in an application context.

A published description of a known security issue affecting identified software versions or conditions.

An authentication process using more than one distinct category of factor.

A framework through which a client obtains bounded access to protected resources through an authorization server.

An identity layer built on OAuth 2.0 that communicates information about an authenticated end user.

A query that supplies values separately from the SQL statement's structure.

A credential used by a client to request a new access token under the provider's rules.

Replacing a credential and updating its legitimate consumers while retiring the previous value.

An identity intended for software or an automated workload rather than an individual person.

An inventory of software components included in a product or artifact.

A structured account of valuable assets, relevant actors, entry points, and plausible failure scenarios.

A point where data or control crosses between different levels of authority or trust.

Hardware that samples an analog signal and represents it as a discrete digital value.

A reference system used to express positions, orientations, and directions.

Establishing a device's identity, credentials, configuration, and authorized relationship to a service.

A stored representation of device-related state that can be read even when the physical device is offline.

Measurements or events reported by a device about its operation or environment.

Device-resident software that controls hardware or provides a device's built-in behavior, typically stored in flash, ROM, or other non-volatile memory.

General-purpose input/output pins that software configures to read or drive digital signals.

Code invoked in response to a hardware or software event through an interrupt mechanism.

A messaging pattern where clients publish messages to named topics and subscribe to topics of interest through a broker.

An estimate of motion or pose derived from motion-related measurements.

A process that transfers a firmware change to a device through a network connection.

A control approach combining proportional, integral, and derivative terms based on an error signal.

A signal technique that varies the portion of each cycle spent in one state.

A component that performs a focused computation or device-facing responsibility within a robotics software graph.

A named publish/subscribe interface for a stream of typed messages in systems such as ROS.

Rules that allow compatible array shapes to participate in element-wise operations without manually repeating every value.

Expressing operations over collections through array-oriented functions rather than explicit high-level loops.

Checking calculations by tracking the physical dimensions and units of quantities.

Representing a continuous quantity or equation using finite points, intervals, or elements.

A finite-precision representation and calculation system for approximating real-number values.

Verification checks that code implements the intended model; validation checks whether the model is adequate for its intended use.

Estimating outcomes by repeatedly sampling from specified random input distributions.

How sensitive a mathematical problem's output is to changes in its input.

An input used to initialize a pseudorandom generator's reproducible state.

The interval by which a numerical simulation advances its represented time.

An explicit rule for when a system should report insufficient evidence, ask for needed information, or decline to assign a result.

A system that can use tools and take multiple steps toward a goal.

The surrounding software that runs an agent loop and manages its tools, execution environment, and working context.

Software development in which AI helps with tasks such as implementation, explanation, investigation, or review while people remain responsible for the resulting system.

Keeping an embedded phrase’s writing direction from unexpectedly changing surrounding mixed-direction text.

A review request limited to specified criteria, evidence, scope, and a stopping condition.

Information available to the model for the current response.

Replacing older or lengthy interaction details with a shorter representation so work can continue within context limits.

Selecting, structuring, and maintaining the information and tool access an AI system receives for a task.

Starting a fresh agent context and supplying a deliberate handoff, rather than continuing the entire existing conversation.

The finite amount of material a model can handle in one interaction, subject to model and tool limits.

Similar task inputs paired with different correct outputs to reveal where a decision should change.

A marker separating sections, such as headings or code fences.

A numerical representation used to compare items by similarity.

A repeatable assessment against defined examples and criteria.

A range boundary that excludes the last item already returned.

A project list of observable capabilities, with a recorded status and evidence for each.

A request containing a small set of input and desired-output examples.

Additional training that adapts model behavior using examples.

A short-lived record of player intent that can be consumed once when a gameplay action becomes legal.

Connecting an answer to relevant supplied or retrieved evidence.

Plausible output that is unsupported or incorrect.

A compact account of the goal, current state, decisions, and next steps.

Testing a selected prompt on cases reserved from the prompt-editing process.

A request identity used by a service to recognize retries under its documented rules.

The time between starting an operation and receiving a relevant result.

A large language model that generates outputs from supplied context and learned patterns.

Model Context Protocol, a standard for connecting AI applications with tools and context providers.

The underlying AI system producing a response.

Loading relevant context in stages as the task reveals which evidence is needed.

The instructions and information you send for a task.

An experiment that removes one prompt component while holding the comparison setup stable.

Designing and evaluating instructions to improve results.

Untrusted content that tries to redirect an assistant's instructions or actions.

A task-specific agreement about what an output means, including fields, evidence, missing values, and invalid-input behavior.

An identifiable revision of the instructions and templates used to construct a model request.

Retrieval augmented generation, where retrieved material is included as context for generation.

Matching accepted simulation results when a stated initial state and input history are replayed under controlled conditions.

Finding relevant material before generating an answer.

An informal name for the attention and time available to inspect generated changes and verify their effects.

A focus-management strategy that keeps one intended item of a composite control in the tab sequence.

A concrete example of an output and its assigned rubric outcome that helps reviewers interpret a criterion consistently.

Checking the meaning and relationships of generated values after their representation has been parsed.

An output constrained to a specified shape, sometimes enforced through a schema.

Application-level directions whose handling depends on the provider and product.

Known data or setup used to put a test into a controlled starting state.

The amount of work a system completes in a period of time.

A unit used to represent text or other input and output; a word can span several tokens.

The actual capabilities and permissions available in a session.

A structured request to run an available operation.

A named position for partial rollback within an active database transaction.

A defined transformation for comparing particular Unicode-equivalent representations.

The request or information supplied by the person using the assistant.

An informal term for directing an AI to build software through natural-language feedback; its original, narrower use emphasizes accepting generated code without closely reviewing it.

A request without worked examples.