323 terms · 2026
Look up the term.Paste the prompt.
For developers who ship with an agent and need the normal engineering word, not a longer prompt.
Start with the problem
- Tests pass individually but fail together
Test AI-generated code against the behavior you need. Work through a runnable failure and fix, then choose TDD, a reproduction, test doubles or test isolation.
- Retry creates duplicate records
Choose between idempotency, unique constraints, transactions, and request deduplication when retries or concurrent callers repeat work.
- Search results arrive out of order
Old results replace the current search? Separate debounce, cancellation, shared requests, and response ordering, with runnable examples and a live simulation.
term of the day ·
empty stateAn empty state explains why expected content is absent and what action is available.development workflow
Reproduce a bug, change the code, and verify the result.
- test-driven developmentLet one failing example drive the next implementation.
- refactoringChange internal structure while preserving observable behavior.
- minimal reproductionThe smallest repeatable case that still shows the bug.
- root cause analysisFind the mechanism that produces the failure.
- git worktreeA separate checkout and index sharing the same Git repository.
- verificationCheck the claimed result against fresh evidence.
- reverse engineeringRecover a behavioral specification from an existing system.
- characterization testRecord the behavior an existing implementation exhibits.
- spikeA short investigation answers one technical unknown.
- walking skeletonA minimal working path connects the application’s essential layers.
- vertical sliceImplement one usable behavior across the layers it requires.
- strangler figReplace an existing system incrementally by routing selected behavior to a new implementation.
- executable specificationAn executable specification makes requirements checkable.
- behaviour-driven developmentDescribe behavior through concrete examples shared by developers and domain experts.
- ubiquitous languageUse a shared domain vocabulary in requirements, code, and conversations.
- YAGNIAvoid implementing capabilities before a current requirement justifies them.
- contract-first designDefine an interface before implementing its producers and consumers.
- partial stagingPartial staging selects changes within a file for the next Git commit.
agents and AI
Give an agent useful context, bounded tools, and checks for its output.
- context engineeringSelect and maintain the information an agent needs for the current task.
- tool callingTool calling lets a model request a defined operation from an application.
- human in the loopA person reviews a decision at a defined point in an automated workflow.
- evalsAn evaluation measures an AI system on a defined set of tasks and criteria.
- guardrailsEnforce explicit limits around automated actions.
- diff reviewReview the changes introduced by a patch, including tests and configuration.
- few-shot promptingFew-shot prompting provides worked examples of the desired task behavior.
- structured outputConstrain model output to a defined structure and validate it at the boundary.
- MCPModel Context Protocol standardizes how applications expose tools and context to AI clients.
- sandboxA sandbox restricts the resources a process can access.
- embeddingAn embedding represents data as a numerical vector for a particular model and task.
- retrieval-augmented generationRetrieval-augmented generation supplies retrieved material to a model before it answers.
- holdout setA holdout set is reserved for evaluating behavior beyond the examples used for development.
- baselineA baseline is a credible comparison under the same evaluation conditions.
- quantizationQuantization represents model values with reduced numerical precision.
- repository instructionsRepository instructions document conventions and commands an agent should use.
code design
Choose boundaries that make code easier to change and test.
- deep moduleA small interface hides a substantial useful implementation.
- seamA place where behavior can be replaced without editing its consumer.
- compositionBuild a variation by assembling smaller parts.
- compound componentsRelated components cooperate through a shared parent.
- component variantsName the supported forms of a component explicitly.
- dependency injectionSupply a collaborator through a contract instead of constructing it inside.
- type-driven developmentType-driven development uses types to express a design before filling in its implementation.
- separation of concernsSeparate responsibilities that change for different reasons.
- leaky abstractionAn abstraction exposes details callers still need to understand.
- technical debtA design shortcut creates a continuing cost for future changes.
- semantic versioningSemantic versioning communicates compatibility of a declared public API.
- breaking changeA change requires an existing consumer to adapt.
- observabilityExpose evidence that helps explain a system’s behavior.
- architecture decision recordAn architecture decision record captures a consequential choice and its context.
- invariantA condition must remain true across permitted operations.
- strategy patternA strategy supplies interchangeable behavior behind a shared contract.
- adapter patternAn adapter translates an existing interface into the interface its caller expects.
- service layerAn application service coordinates a use case across entry points.
- repository patternA repository exposes persistence operations needed by the application.
- feature-based organizationFeature-based organization keeps related implementation close to the capability it serves.
- ownershipOwnership defines which part of a program controls a value’s lifetime.
- state machineA state machine describes states and permitted transitions driven by events.
frontend and browser state
Keep state consistent and remove unnecessary work.
- lifting stateMove shared state to the nearest owner that can coordinate its users.
- derived stateCalculate a value from state you already have.
- effect dependenciesThe reactive inputs that determine when an effect must resynchronize.
- functional state updateCompute the next state from the previous state supplied by the framework.
- request waterfallRequests form a sequence that adds their waiting times.
- request deduplicationShare equivalent requests within a defined scope.
- code splittingLoad a separate code bundle when a feature needs it.
- Suspense boundaryKeep a useful shell visible while supported child content is waiting.
- serializationEncode state so it can cross a storage or process boundary.
- schema evolutionChange a stored format while handling older data deliberately.
- subscription cleanupRelease listeners and subscriptions when their owner stops using them.
- optimistic UIShow an expected change before the server confirms it.
- rendering strategyRendering strategy determines when and where initial HTML is produced.
- hydrationHydration connects client-side behavior to server-rendered HTML.
- tree shakingTree shaking removes unused code that a bundler can prove is unnecessary.
- controlled inputA controlled input gets its current value from application state.
- progressive enhancementProvide a useful baseline and improve it when additional browser capabilities are available.
- focus managementMove and restore keyboard focus deliberately as interface context changes.
- client state vs server stateDistinguish a local interaction draft from cached data owned by a server.
- islands architectureIslands architecture adds interactive components to an otherwise server-rendered or static page.
- rules of hooksReact Hooks follow rules about where they can be called.
- list keyA list key identifies an item across renders.
- stale closureA callback retains values from the environment where it was created.
- CSS specificitySpecificity ranks competing selectors within the relevant cascade context.
- stacking contextA stacking context groups elements into a local stacking order.
- server componentsReact Server Components run outside the client bundle and can prepare UI close to server data.
- event delegationA parent listener handles suitable events from descendants.
- service workerA service worker can intercept requests and manage offline behavior.
- web storageBrowser storage APIs offer different persistence and access models.
- structural typingStructural typing compares the shape of types rather than only their declared names.
- shadow DOMShadow DOM provides a component subtree with scoped DOM and styling behavior.
- container queryA container query adapts styling to a containing context.
- headless UIHeadless UI separates reusable interaction behavior from a particular visual presentation.
- state colocationKeep state near the components that own its lifecycle.
- custom HookA React custom Hook extracts reusable stateful logic.
- reducerA reducer computes the next state from the current state and an action.
- composableA Vue composable encapsulates reusable stateful logic through the Composition API.
- scoped slotsA Vue scoped slot lets a child provide data to caller-supplied content.
- computed vs watchIn Vue, computed values derive data while watchers respond with side effects.
- query keysA query key identifies cached data and the inputs that distinguish it.
- freshness and cache retentionFreshness describes when cached data should be reconsidered; retention describes how long unused data remains available.
- mutation invalidationQuery invalidation marks affected cached reads stale after a change.
- route loader and query cacheA route loader prepares data for navigation.
- sticky positioningSticky positioning keeps an element in normal flow until it reaches an offset in its scrolling context.
- autosaveAutosave persists edits without an explicit save command.
- event handlerRun interaction-triggered work in the code that handles that event.
APIs and data
Define contracts, investigate slow queries, and protect stored data.
- query planThe operations a database chooses to answer a query.
- database indexA data structure that can make matching rows cheaper to find.
- composite indexOne index covers an ordered combination of columns.
- partial indexIndex only rows that satisfy a predicate.
- N+1 queryOne list query triggers another query for every result.
- keyset paginationContinue a list after the last returned sort key.
- connection poolReuse a bounded set of database connections.
- parameterized queryKeep SQL structure separate from input values.
- transactionCommit related database changes together or roll them back.
- deadlockOperations wait on resources held by one another.
- unique constraintThe database rejects duplicate values for a declared key.
- upsertInsert a row or update the row that conflicts with its key.
- database migrationA recorded transition from one database schema to another.
- row-level securityDatabase policies control which rows a role may access.
- least privilegeGive each runtime identity only the permissions its job needs.
- webhookA service sends an HTTP request when an event occurs.
- RESTREST is an architectural style for resource-oriented interactions through a uniform interface.
- rate limitLimit how often a caller can perform an operation.
- cache invalidationMark cached data stale, remove it, or refresh it when its assumptions change.
- job queueA queue separates accepting work from processing it.
- circuit breakerTemporarily stop calls to a failing dependency and probe for recovery.
- graceful shutdownStop accepting new work and finish or hand off existing work before exiting.
- minor unitsRepresent money using integer minor units or an appropriate decimal representation with an explicit currency.
- UTC vs local timeDistinguish an instant from a calendar date and a local scheduled time.
- optimistic concurrencyAccept an update only if the version being replaced still matches the version the caller read.
- partial updateA partial update changes only the fields identified by its contract.
- transaction isolationTransaction isolation defines how concurrent transactions may observe and affect one another.
- DTOA data transfer object defines the fields crossing an application boundary.
- WebSocketA WebSocket provides a persistent bidirectional connection.
- error as valueRepresent expected failures explicitly in a function’s result.
- option typeAn option type represents a value that may be absent.
- DataLoaderDataLoader batches related loads and can memoize results within a chosen scope.
- middleware orderMiddleware ordering determines which request and response processing runs before another step.
- data access layerA data access layer centralizes access rules and data retrieval at a boundary.
- server actionA server action exposes a framework-supported server operation to the client.
- ETL and ELTETL transforms extracted data before loading it; ELT loads data before transformation.
- table partitioningTable partitioning divides a logical table into physical parts.
- backfillA backfill populates or recomputes existing data after a rule or schema change.
- denormalizationDenormalization duplicates or precomputes data to serve a read pattern.
- batch vs streamBatch processing operates on bounded input; streaming processes ongoing input.
- runtime validationCheck untrusted values when the program receives them.
- physical row clusteringPlace related rows near each other to reduce scattered reads.
- normalizationStore facts according to their keys to reduce update anomalies.
- leader–follower replicationSend writes through a leader and replicate them to followers.
- multi-leader replicationAllow multiple write authorities with explicit conflict handling.
- BASEDesign for availability with temporary state and eventual convergence.
- ACIDSpecify atomicity, consistency, isolation, and durability for transactions.
- strong consistencyMake the exact freshness and ordering guarantee explicit.
- write-ahead logging (WAL)Persist the recovery log before the corresponding data pages.
- checkpointingRecord a recovery boundary after making the required state durable.
- storage compactionMerge storage runs and reclaim obsolete versions when safe.
- data localityPlace related data and computation close to reduce remote work.
- hot partitionOne partition receives more work than its capacity can handle.
- cachingReuse a stored result with explicit freshness and failure rules.
- materialized viewPersist a query result and define how it becomes current again.
- secondary indexProvide another access path besides the table’s primary organization.
- covering indexInclude the values a query needs so fewer table-row fetches may be necessary.
- Bloom filterReject definite misses cheaply while allowing possible false matches.
- LSM treeBuffer writes and organize persisted data as sorted runs.
- B-treeKeep keys ordered in a balanced tree for lookups and range scans.
- query plannerChoose an executable access path and join strategy for a query.
- cost-based optimizerChoose among query plans using estimated resource costs.
- data skewUneven values or partition sizes make some units of work much larger than others.
- change data capture (CDC)Publish source-data changes so downstream systems can follow them.
- logical replicationReplicate logical table changes rather than a physical copy of storage.
- physical replicationKeep a standby aligned with the primary’s physical database changes.
- query federationQuery independently managed data sources through a shared interface.
- data lakeRetain diverse data for later processing and analysis with governance.
- data warehouseIntegrate and model data for reliable analytical queries and reporting.
- columnar storageStore values by column to suit selective analytical scans.
- row-based storageKeep a row’s fields together for record-oriented access.
- time-series partitioningPartition timestamped records into explicit time intervals.
- hash partitioningUse a hash of the partition key to assign records to buckets.
- range partitioningAssign rows to partitions by ordered key intervals.
- consistent hashingLimit key reassignment when the set of storage nodes changes.
- data migrationMove or transform existing records with validation and a controlled cutover.
- schema registryVersion message schemas and enforce a chosen compatibility policy.
performance
Measure the slow or wasted work, then remove it. Includes timing for games and animation.
- memoizationReuse a computed result while its inputs are unchanged.
- layout thrashingAlternating DOM reads and writes forces the browser to recalculate layout repeatedly.
- critical rendering pathThe critical rendering path is the work needed before the browser can render content.
- tail latencyTail latency describes the slow end of a response-time distribution.
- cold startA cold start includes initialization work before a new instance can serve its first operation.
- list virtualizationRender a window of list items instead of every item at once.
- memory leakA memory leak retains memory beyond its useful lifetime.
- lock contentionLock contention occurs when operations wait to acquire the same synchronization boundary.
- game loopA game loop coordinates repeated input, simulation, and rendering.
- delta timeDelta time is elapsed time between updates.
- object poolAn object pool reuses instances instead of creating a new one for each use.
- frame budgetA frame budget allocates the time available for responsive rendering at a target cadence.
security
Check identity, permissions, and trust at the boundary where they matter.
- authentication and authorizationAuthentication establishes identity; authorization decides whether that identity may perform an operation.
- cross-site scriptingCross-site scripting lets untrusted content execute in another user’s browser.
- cross-site request forgeryCross-site request forgery induces an authenticated browser to send an unwanted request.
- server-side request forgeryServer-side request forgery causes a server to contact an unintended destination.
- insecure direct object referenceAn insecure direct object reference exposes an object without checking access to it.
- password hashingStore a salted password hash using a purpose-built password hashing function.
- OAuth and OpenID ConnectOAuth delegates access to resources; OpenID Connect adds identity information for login.
- content security policyContent Security Policy restricts resources and execution in the browser.
- CORSCross-Origin Resource Sharing controls which cross-origin responses browser scripts may read.
- threat modelIdentify assets, adversaries, entry points, and plausible failure paths.
- software supply-chain securitySoftware supply-chain security addresses risks in dependencies, build inputs, and distribution.
- session cookieA session cookie carries a session credential in browser requests.
- prompt injectionUntrusted content attempts to redirect an AI system’s instructions or actions.
testing
Test real outcomes with controlled state and reliable checks.
- end-to-end testCheck a user journey through the running application.
- test isolationEach test controls its own state and can run independently.
- test fixtureReusable setup gives a test a known starting state and owns cleanup.
- auto-waitingWait for an observable condition instead of a fixed delay.
- semantic locatorFind an element by its role, label, or other user-facing meaning.
- test doubleA controlled substitute makes a dependency predictable in a test.
- visual regression testCompare rendered output with an intentionally reviewed baseline.
- static analysisStatic analysis inspects code without exercising the application.
- snapshot testCompare serialized output with a reviewed expected snapshot.
- property-based testingGenerate inputs to test a general property rather than only handpicked examples.
- flaky testA test produces inconsistent outcomes without an intentional relevant change.
- network panelThe browser network panel shows requests and responses made by the page.
concurrency
Give concurrent work a lifetime, an owner, and a capacity limit.
- structured concurrencyChild tasks finish within the lifetime of their enclosing operation.
- cooperative cancellationWork must observe cancellation and stop safely.
- actor isolationAn actor protects its mutable state through an isolation boundary.
- actor reentrancyOther work can change actor state while an operation is suspended.
- debounceWait for a quiet interval before acting on repeated input.
- backpressureLet consumer capacity constrain how fast producers send work.
- race conditionAn outcome depends on the timing of concurrent operations.
- event loopAn event loop schedules work and callbacks around the runtime’s execution model.
- mutexA mutex provides mutually exclusive access to a protected critical section.
- async vs parallelAsynchronous work can yield while waiting; parallel work executes simultaneously.
- thread poolA thread pool reuses worker threads to execute submitted work.
- atomic operationAn atomic operation takes effect indivisibly with respect to the relevant observers.
- goroutineA goroutine is a lightweight unit of concurrent execution in Go.
- quorumRequire a defined set of replicas or voters before accepting an operation.
- consensusMake participating nodes agree on decisions despite specified failures.
- CAP theoremDuring a network partition, atomic consistency and availability cannot both be guaranteed.
- snapshot isolationRead a stable transaction snapshot while detecting conflicting writes.
- MVCCKeep multiple row versions so reads can use a consistent snapshot.
- two-phase commit (2PC)Coordinate prepare and commit decisions across transaction participants.
- three-phase commit (3PC)Add a pre-commit phase to reduce blocking under restricted failure assumptions.
- lock escalationReplace many fine-grained locks with a coarser lock in engines that support it.
- pessimistic lockingLock the protected rows before making a competing update.
- dirty readRead a value another transaction has written but not committed.
- phantom readRepeat a predicate query and observe a changed set of matching rows.
- read skewRead related facts from different committed moments and combine an inconsistent view.
- write skewConcurrent decisions update different rows and jointly violate an invariant.
- throttlingBound how often work runs while events continue arriving.
native apps
Handle app lifetimes, platform permissions, and persistent state.
- offline-firstDesign a useful local workflow that tolerates missing connectivity.
- deep linkA deep link addresses a particular location or action in an application.
- safe areaSafe-area insets describe regions where important content can remain unobscured by system UI or display features.
- navigation stackA navigation stack records a sequence of destinations.
- push notificationA push notification delivers an external event through a platform notification service.
- app lifecycleApplications move between active, inactive, background, and terminated states according to their platform.
- OS permissionOperating-system permissions mediate access to protected capabilities.
- OTA updateAn over-the-air update replaces supported application assets or code without a full binary install.
- main process vs rendererDesktop shells such as Electron separate privileged application work from the renderer.
- IPCInter-process communication exchanges data or requests between processes.
- context isolationElectron context isolation separates the page’s JavaScript environment from privileged preload code.
- single instanceSingle-instance behavior routes subsequent launches to an existing application instance.
- code signingCode signing binds an artifact to a signing identity and detects covered modifications.
- desktop auto-updateDesktop auto-update retrieves and installs a new application release through a defined trust and lifecycle process.
- app sandboxAn application sandbox restricts access to system resources.
- webviewA WebView embeds web content in a native application.
- secure storageUse the platform’s protected storage for suitable credentials or keys.
- app linkA verified app link associates an HTTPS domain with an application through platform verification.
- background executionBackground execution uses the operating system’s supported scheduling or execution model.
- adaptive layoutAn adaptive layout responds to available space and presentation context.
- in-app purchaseIn-app purchases exchange a store transaction for a defined entitlement.
- build variantA build variant selects a deliberate combination of configuration and packaging.
- dynamic typeDynamic Type adapts text to the user’s preferred size on Apple platforms.
- biometric authenticationBiometric authentication can authorize a local operation through the operating system.
- sync conflictA synchronization conflict occurs when changes cannot be combined safely under the chosen policy.
delivery and operations
Release changes, observe behavior, and recover when something fails.
- continuous integrationRun repeatable checks when code changes are integrated.
- request-scoped stateKeep user-specific mutable state within the request that owns it.
- streamingProcess or forward data incrementally as it arrives.
- idempotencyRepeating an operation has the same intended effect as doing it once.
- secret managementSupply credentials through an appropriate secret store or runtime configuration.
- feature flagA switch controls whether a behavior is enabled.
- rollbackReturn to an earlier working release or state after a failed change.
- load balancerA load balancer routes requests among service instances.
- horizontal scalingIncrease capacity by running more service instances.
- CDNA content delivery network serves content through distributed edge locations.
- read replicaA read replica serves a copy of database data.
- eventual consistencyReplicas or projections converge when updates stop and propagation succeeds.
- sagaA saga coordinates a multi-step operation through local commits and explicit recovery actions.
- transactional outboxA transactional outbox records an event alongside the business change in one database transaction.
- cache stampedeMany callers rebuild the same missing or expired cache entry at once.
- dead-letter queueA dead-letter destination retains work that exhausted normal processing or retry policy.
- liveness and readinessLiveness asks whether a process should be restarted; readiness asks whether it should receive work.
- canary deployA canary release exposes a new version to a limited portion of traffic first.
- failoverFailover transfers responsibility from an unavailable component to another.
- pub/subPublish/subscribe distributes events to interested subscribers.
- timeout budgetAn operation’s total deadline must account for downstream calls, retries, and cleanup.
- graceful degradationKeep essential behavior useful when an optional dependency or capability is unavailable.
- backend for frontendA backend for frontend adapts backend capabilities to a client’s needs.
- infrastructure as codeInfrastructure as code describes infrastructure in reviewable files.
- containerA container runs a process with a packaged filesystem and configured isolation.
- multi-tenancyA multi-tenant application serves distinct customers through shared infrastructure.
- object storageObject storage stores data as objects addressed by keys.
- blue-green deployBlue-green deployment keeps old and new environments available during a traffic switch.
- configuration driftConfiguration drift is a difference between intended and running configuration.
- TLSTLS protects communication and authenticates peers according to the configured trust model.
- HTTP cachingHTTP caching controls when clients and intermediaries can reuse a response.
- reverse proxyA reverse proxy accepts client traffic and forwards it to application services.
- port mappingPort mapping publishes a service port through another network boundary.
- bind mount vs volumeA bind mount exposes a host path to a container; a managed volume has a separate storage lifecycle.
- preview deploymentA preview deployment exposes a particular proposed revision for review.
- build IDA build ID identifies the artifact running in an environment.
- database clusteringCoordinate database nodes with explicit storage, replication, and routing roles.
- rebalancingMove existing partitions or replicas to improve their placement.
- reshardingChange the shard layout or assignment used to distribute data.
- split-brainCompeting nodes act as the same write authority after losing coordination.
- high availability (HA)Keep the service usable through specified failures and recovery procedures.
- vertical scalingGive one instance more CPU, memory, or I/O capacity.
- geo-replicationReplicate data across geographic regions with an explicit consistency policy.
web interface
Make navigation, motion, and loading behave predictably.
- URL statePut shareable navigation state in the URL.
- reduced motionRespect the user’s preference for less interface animation.
- layout shiftVisible content moves unexpectedly as the page loads or updates.
- accessibilityAccessibility makes an interface usable by people with varied abilities and assistive tools.
- empty stateAn empty state explains why expected content is absent and what action is available.
- progressive disclosureReveal secondary choices when they become relevant.
- destructive actionA destructive action removes or invalidates user value.
- undoUndo reverses a supported action according to a defined history and lifetime.
- skeleton screenA skeleton screen reserves the shape of content while it loads.
- error copyError copy explains a failure in terms useful to the user.
- design tokensDesign tokens name reusable visual decisions such as spacing and colors.
- split paneA split pane divides a workspace with an adjustable separator.
use in your agent
Put the glossary where you work. Add a pack to CLAUDE.md or AGENTS.md, install the skill, or let your agent look up terms over MCP.
Missing a word you needed? suggest a term.