BitDive Glossary
Key terms used across BitDive documentation. If you are new to runtime context, trace-based testing, or deterministic verification, start here.
A
AI Self-Verification
The process where an AI agent verifies its own code change using real runtime evidence. In BitDive, this means the agent works from Runtime Context, captures a new trace after the modification, compares before/after behavior across methods, SQL, contracts, and downstream calls, and then preserves the verified result with replay-based regression protection. Related: Autonomous Quality Loop for AI Agents
Autonomous Verification Layer (AVL)
A deterministic layer introduced by BitDive that captures real application behavior (traces, SQL, payloads) and converts it into verification artifacts. It resolves the Verification Gap by giving both human developers and AI agents a way to prove code correctness against actual execution data rather than synthetic assumptions or manual mocks. Related: Deterministic Verification
AI Code Verification
Older term for AI Self-Verification. Kept for compatibility with older pages and external references. Related: Autonomous Quality Loop for AI Agents
API Regression
A change in inter-service API behavior after a code modification that was not intended or expected. May include altered request payloads, missing headers, changed status codes, modified error responses, or different call sequences. BitDive detects API regressions by comparing real HTTP exchanges captured in traces before and after the change. Related: Before/After Trace Comparison
Auto-Mocking
BitDive automatically creates mock responses from captured runtime data. External dependencies (databases, APIs, message queues) are isolated using real recorded responses instead of manually written Mockito scripts.
Automated Quality Gate
An automated checkpoint in CI/CD that blocks a build when replay suites or runtime verification detect an unintended change. In BitDive, a quality gate can combine standard mvn test, trace comparison, and regression baselines built from real traces.
Automated Test Creation
The ability to create replay-based regression suites from captured runtime traces without hand-writing large mock scripts or fixture code. In BitDive, the output is standard JUnit tests and replay plans derived from real behavior.
Autonomous Quality Loop
A workflow where AI agents verify their own code changes using real runtime evidence. The operational form is usually four stages:
- Capture or inspect the current behavior
- Make one focused change using runtime context
- Compare before/after traces
- Refresh regression memory only after proof
Many teams expand this into six CI steps: runtime context, baseline test run, implementation, before/after comparison, global regression run, and reporting.
B
Before/After Trace Comparison
Comparing execution traces captured before and after a code change to detect behavioral differences. Unchanged methods should produce identical results. Changed methods show exactly what shifted. This is the core of deterministic verification. Older docs may call this semantic diffing or dual-trace inspection.
Behavioral Change Detection
Detecting unexpected changes in application behavior by comparing runtime traces captured before and after a code change. BitDive identifies these changes by triggering the same API call on the updated service, capturing a new trace, and comparing it against the recorded baseline. Older docs may call this semantic divergence or behavioral divergence.
Bytecode Instrumentation
The process of modifying Java class files at runtime to inject monitoring logic. BitDive uses a Java Agent to perform this with minimal overhead (0.5-5%), enabling deep observability without source code changes.
C
CI/CD Gate
A quality checkpoint in the delivery pipeline. BitDive blocks Pull Requests that fail behavioral verification against recorded production traces. Runs as part of standard mvn test in any CI environment.
Consumer-Driven Contracts (CDC)
A testing methodology where API consumers define expected provider behavior. BitDive is not a CDC tool, but it complements CDC by detecting runtime API drift after code changes through real HTTP trace comparison.
D
Deterministic Replay
The core mechanism where captured traces are replayed against code in a controlled test environment. External dependencies are satisfied from recorded behavior, giving stable regression checks without depending on live infrastructure.
Deterministic Verification
The broader process of proving code changes against real runtime behavior. In BitDive, this combines runtime context, before/after trace comparison, and replay-based regression protection built from verified traces. It forms the foundation of the Autonomous Verification Layer. See comparison: BitDive vs. Diffblue (Static Analysis) Deep Dive: How Deterministic Replay Works
Deterministic JUnit Replay Tests
JUnit tests generated by BitDive from real runtime executions. Unlike synthetic tests generated by AI from source code, these are built from actual application behavior and include automatically mocked dependencies, ensuring they are 100% deterministic and repeatable.
Distributed Tracing
Tracking a single request as it propagates through microservices. BitDive provides distributed tracing with deep, method-level visibility in each service, connecting service spans to actual Java code. Related: Distributed Tracing Guide
I
Integration Test
A test that boots the full Spring ApplicationContext. All internal beans, transactions, security filters, and validation are real. Only external dependencies (other microservices, 3rd-party APIs, databases in Replay mode) are stubbed or replayed from captured traces. Spring defines any test that loads an ApplicationContext as an integration test. BitDive supports two modes: Replay mode (all deps replayed, zero infrastructure) and Testcontainers mode (real DB via Testcontainers, external APIs replayed). Related: Integration Tests (Replay) | Testcontainers Integration Tests
J
Java Agent
A specialized tool that uses the Java Instrumentation API to modify bytecode. BitDive's Java Agent captures deep execution context with no manual code changes required. Setup: Infrastructure Deployment
M
MCP (Model Context Protocol)
An open standard that allows AI models to interact with external tools. BitDive uses MCP to provide AI agents (Cursor, Claude Code, Windsurf) with real runtime context from the JVM.
Regression Management
The operational process of deciding when to refresh a BitDive regression baseline, when to replace one specific entry, and when a failure should stay red because it reveals a real regression. This is the discipline that keeps replay-based suites trustworthy over time. Related: Regression Management in BitDive
Mockito Alternative (Mockless Testing)
BitDive serves as a modern alternative to manual mocking frameworks like Mockito. By replaying real dependency responses captured at runtime, it eliminates the maintenance burden of manually writing and updating mocks. See comparison: BitDive vs. WireMock (Manual Stubs) Related: Trace-Based Testing vs Mocking
N
N+1 Query Problem
A performance issue where an application makes multiple database queries instead of one. BitDive's SQL Inspection identifies these patterns automatically during trace analysis.
P
Performance Regression
A degradation in application response time, throughput, or resource usage caused by a recent code change. BitDive detects these automatically by comparing execution traces against baselines.
Production Traffic Capture
The process of recording real-world application behavior. The capture becomes a Runtime Snapshot that can be used for trace comparison, debugging, and replay-based regression tests. See comparison: BitDive vs. Speedscale & Keploy (Traffic Replay) Guide: Creating Unit Tests from Traffic
R
Real Runtime Data
Older phrase for the captured runtime evidence inside a Runtime Snapshot and the Runtime Context exposed during verification. Kept for compatibility with older articles and backlinks.
Replay-to-JUnit
The process of turning a captured runtime trace into standard JUnit replay assets. BitDive uses recorded behavior to create replay configurations that run with normal Java test tooling instead of hand-written mock-heavy suites.
Runtime API Contract
The actual HTTP behavior between services as captured in execution traces. Includes endpoint, HTTP method, headers, serialized request body, response status, response body, and error responses. Unlike a static OpenAPI specification, a runtime API contract reflects what the service actually sends and receives at runtime. BitDive uses before/after trace comparison to detect when a runtime API contract changes after a code modification. Related: API Regression, Before/After Trace Comparison
Runtime Snapshot
A captured record of one real execution. A runtime snapshot can include request payloads, method calls, SQL queries, downstream operations, timings, errors, and returned values. It is the recorded evidence BitDive later uses for debugging, trace comparison, and replay-based tests. Related: What BitDive Captures: Runtime Snapshot
Runtime Context
The execution data that gives developers and AI agents the real payloads, SQL, call paths, timings, and errors behind a behavior. In BitDive, runtime context is exposed through traces and MCP so fixes can be made against evidence instead of assumptions. Related: BitDive MCP Integration
Review Fatigue
A state where developers over-trust AI-generated code that appears syntactically correct, leading to logical errors. BitDive mitigates this by providing automated behavioral proof through trace comparison.
Root Cause Analysis (RCA)
Identifying the fundamental cause of failure. BitDive's deep traces and SQL inspection allow for instant RCA by showing exactly where the internal logic deviated.
Runtime Observability
A method-level view of real JVM behavior: traces, SQL, timings, parameters, downstream calls, and failures. In BitDive, runtime observability is useful on its own for debugging, but it also feeds deterministic verification and replay-based regression workflows. Related: Observability vs APM vs Testing Guide
S
Service Map
A visual representation of microservices interactions. BitDive creates these automatically based on real runtime traffic. Explore: Analyzing the Service Map
SQL Inspection
Deep analysis of database queries executed by the JVM. BitDive records query parameters, execution time, and results to verify data-layer interactions without a live database.
T
Test Flakiness
Tests that fail intermittently without code changes, often due to race conditions or external dependency latency. BitDive eliminates flakiness by replacing variable network responses with deterministic replay of captured data.
Testcontainers
The management of ephemeral container lifecycles for integration testing. Testcontainers provide realism by running real databases (PostgreSQL, MongoDB, Redis) in Docker. BitDive supports two modes: Replay mode replays all dependencies (including database responses) from captured traces, requiring no infrastructure. Testcontainers mode runs a real database via Testcontainers while replaying only external API calls from traces. Database is auto-seeded from captured production data. Related: Testcontainers Integration Tests | Replay Mode Integration Tests
Trace-Based Testing
A testing approach where tests are built from real execution traces captured from a running application. Instead of writing mock data manually or using AI to predict test cases from source code, trace-based testing records actual method calls, SQL queries, and API responses, then replays them as standard JUnit tests. This is a core capability of the Autonomous Verification Layer. Deep Dive: What Is Trace-Based Testing?
V
Verification Gap
The widening disparity between the speed of code creation and the speed of reliable code verification. While AI coding tools (Copilot, Cursor) have accelerated code generation, verifying that code still relies on manual PR reviews and brittle hand-written tests, creating a bottleneck in the software lifecycle.
Verification Crisis
An industry-wide trend where engineering teams experience significantly increased PR review times (up to +91%) and a surge in production incidents because traditional testing cannot keep up with the volume of AI-generated code.
Verification Bottleneck
A state in the development process where the verification phase (testing, review, debugging) consumes more resources and time than the actual coding phase. BitDive resolves this bottleneck through its Autonomous Verification Layer.