Flux Glossary
AI is changing how software gets built, and it’s bringing a new vocabulary with it. Whether you’re an engineering leader trying to get your arms around AI-accelerated development, a security or compliance stakeholder evaluating risk, or just someone who wants to speak the same language as your engineering team, this glossary is for you.
These are the terms you’ll encounter most often in Flux content, in conversations about modern engineering, and in the AI-driven development landscape at large. We’ll keep this page updated as the language evolves.
A
Agentic development:A style of software development where AI agents independently plan, reason, and execute multi-step workflows (such as debugging a failing test or refactoring a module) using external tools like compilers, browsers, and terminals. Unlike copilots, which require line-by-line guidance, agentic systems start from high-level objectives and use autonomous reasoning loops to propose and execute changes that humans then review.
AI-accelerated development: Software development where AI tools significantly increase the speed, volume, and complexity of code being produced. AI-accelerated teams can ship more code faster, but often outpace the traditional review and risk management processes built for a human-speed world.
AI agent: An AI system that can plan and execute multi-step tasks using tools like compilers, documentation, and terminals, often in a loop that observes results and adjusts its actions. In engineering, AI agents can read, modify, and test code with human oversight rather than line-by-line instructions.
AI-assisted development: Software development where humans remain in the loop but use AI tools to generate, refactor, or explain code. AI-assisted workflows range from inline suggestions to fully agentic systems that propose multi-file changes.
AI-generated code: Code written by an AI tool, such as a coding copilot or autonomous agent, rather than directly by a human developer. AI-generated code can dramatically increase output but introduces new challenges around quality, security, and visibility.
AI hallucination: A phenomenon where a large language model (LLM) generates code or information that is syntactically correct but logically flawed, insecure, or refers to non‑existent libraries and APIs. In engineering, hallucinations can lead to broken builds or security vulnerabilities that look like valid code to the untrained eye.
AI visibility gap: The widening disconnect between how fast AI-accelerated teams produce code and how clearly engineering leaders can see, understand, and manage what’s actually changing in the codebase. As code volume and complexity increase, leaders relying on tickets and status reports are increasingly flying blind.
See also: ground-truth intelligence, shadow work.
B
Business intelligence (BI): The use of data, analytics, and reporting tools to support business decision-making. In engineering contexts, BI tools are sometimes used to track team output, but they typically rely on reported data rather than ground-truth signals from the code itself.
C
Codebase: The full collection of source code that makes up a software product or system across all repositories, services, and branches. Flux analyzes the entire codebase to surface what’s actually happening. Understanding the codebase is increasingly a challenge of context management, as AI tools often struggle to see beyond the immediate file being edited.
See also: estate.
Code churn: The rate at which code is written, rewritten, or deleted. High churn can signal instability, rework, or accumulating technical debt. It is often an early indicator of delivery risk.
See also: PR churn, technical debt.
Code-first: An approach to engineering intelligence that derives insights directly from the code itself (commits, pull requests, and repository activity) rather than from tickets, status updates, or self-reported metrics. Flux is a code-first platform.
Context window: The maximum amount of data, measured in tokens, an AI model can process at one time. For engineering tools, a larger context window allows the AI to understand broader relationships across multiple files.
Code review: The process of examining code changes before they are merged into the main codebase. Code review is a critical quality and security checkpoint, but as AI-generated code increases volume and complexity, traditional human-only review processes are struggling to keep pace. [Internal link: Flux survey report when available]
Code velocity: The speed at which code changes are being produced and merged. AI-accelerated development has dramatically increased code velocity for many teams, making it harder to maintain visibility and quality with legacy tools.
Commit: A saved change to a codebase, recorded in version control (such as GitHub). Commits are the fundamental unit of work Flux analyzes to build ground-truth intelligence about what engineering teams are actually doing.
D
Due diligence questionnaire (DDQ): A structured set of questions, typically around security, compliance, and data handling, that enterprise buyers use to evaluate vendors before purchasing.
Dependency: An external library, package, or service that a codebase relies on to function. Dependencies need to be actively managed: outdated or vulnerable dependencies are a common source of security risk, especially as AI-generated code can introduce new ones without explicit developer intent.
See also: software composition analysis, technical debt.
DORA metrics: A set of five industry-standard metrics used to measure software delivery performance. Throughput metrics measure how much gets through the system: deployment frequency, lead time for changes, and failed deployment recovery time (formerly mean time to recovery). Instability metrics measure how well deployments go: change failure rate and deployment rework rate (introduced in the 2024 DORA report). These metrics were originally defined by the DevOps Research and Assessment (DORA) research program, now part of Google. Flux standardizes on DORA metrics to give engineering leaders an objective, comparable view of delivery velocity. [SEE:DORA research program]
Developer experience (DX): The overall quality of the environment, tools, and processes that developers work within. A strong developer experience reduces friction, increases productivity, and supports team morale—all of which show up as signals in the codebase.
E
Engineering intelligence: Insights derived from engineering activity that help leaders understand what their teams are doing, how effectively they’re doing it, and where risks or opportunities exist. Traditional engineering intelligence platforms rely on tickets and reported activity. Flux delivers code-first engineering intelligence grounded in what’s actually happening in the codebase.
Estate: The full collection of repositories and codebases an engineering organization owns and maintains. Flux provides estate-wide visibility by analyzing all repositories, not just a subset.
See also: codebase.
End user license agreement (EULA): The legal agreement between a software provider and its users, outlining the terms of use, data handling, and rights. Flux’s EULA includes strong confidentiality commitments to protect customer source code.
F
Force multiplier: An engineer or practice that disproportionately elevates the output and effectiveness of those around them. Force multipliers are often invisible in ticket-based systems but show up clearly in collaboration patterns in the code through reviews, knowledge-sharing, and cross-team contributions. Flux helps leaders identify and amplify them.
G
Governance, risk, and compliance (GRC): The framework organizations use to align strategy with policy, manage risk, and meet regulatory requirements. As AI-generated code increases velocity and complexity, GRC teams are increasingly concerned about maintaining code quality, security, and auditability of what’s being shipped.
Ground-truth intelligence: Insights derived directly from the code itself, not from tickets, estimates, or human-reported activity. Ground-truth intelligence gives engineering leaders an unbiased, accurate view of what’s actually happening across their teams and codebases.
See also: code-first, AI visibility gap.
H
Hotspot: An area of the codebase where engineers spend disproportionate effort—often a signal of hidden complexity, architectural fragility, or accumulating technical debt. Flux surfaces hotspots automatically so leaders can intervene early.
K
Key performance indicator (KPI): A measurable value used to evaluate progress toward a goal. In engineering, common KPIs include deployment frequency, cycle time, and defect rates. Flux connects engineering KPIs to code-derived evidence rather than self-reported data.
See also: DORA metrics.
L
Large language model (LLM): A type of AI model trained on large amounts of text and code that can generate, summarize, explain, and transform language (including source code). LLMs power most AI coding tools in use today, from copilots to autonomous agents. Flux uses LLMs as part of how it analyzes and interprets your codebase, alongside static analysis and repository signals. [SEE: IBM overview of LLMs]
P
Pull request (PR): A proposed change to a codebase, submitted for review before being merged. Pull requests are a primary unit of work that Flux analyzes to understand what your team is building, how fast work is moving, and where risk may be accumulating. See also: code review, PR churn.
PR churn: Pull requests that are opened but then abandoned, significantly revised, or closed without merging. High PR churn often signals rework, unclear requirements, or friction in the development process and is increasingly common in AI-accelerated teams.
See also: code churn.
R
Retrieval-augmented generation (RAG): A technique that enhances LLM responses by retrieving relevant information from a specific knowledge source, such as your codebase or documentation, before generating an answer. Flux uses RAG-based approaches in features that answer questions about your actual code, grounding responses in your repositories instead of generic training data. [SEE:IBM overview of RAG]
Responsible AI (RAI): The practice of designing, deploying, and governing AI systems in ways that are safe, fair, transparent, and accountable. As AI-generated code becomes standard, responsible AI practices increasingly include how organizations manage the code AI produces, not just the AI models themselves.
Role-based access control (RBAC): A security model that restricts access to systems and data based on a user’s role within an organization. Flux implements RBAC within its platform to ensure the right people have access to the right information and no more.
S
Static application security testing (SAST): Automated analysis of source code to identify vulnerabilities. As AI-generated code increases in volume and complexity, many teams rely on SAST to catch security flaws that might otherwise slip through manual review, but traditional rule-based tools may still miss novel logic issues or hallucinated patterns that don’t match legacy rule-sets. [SEE:OWASP overview of source code analysis tools]
Software composition analysis (SCA): A security practice that identifies open-source components and third-party libraries in a codebase and flags known vulnerabilities or licensing risks. SCA is especially important in AI-accelerated development, where code generation tools may introduce dependencies that developers haven’t explicitly chosen.
See also: dependency.
Shadow work: Engineering effort that never gets captured in tickets or planning systems, such as refactoring, research spikes, configuration changes, and other work that happens in the code but doesn’t show up in Jira. Shadow work distorts capacity planning and hides where time is actually being spent. Flux surfaces it automatically from commit and PR data.
See also: AI visibility gap, work type classification.
T
Technical debt: The accumulated cost of shortcuts, deferred fixes, and suboptimal design decisions in a codebase. Technical debt slows future development, increases incident risk, and often grows invisibly, especially when AI-generated code is introduced without sufficient review. Flux helps leaders see where technical debt is accumulating.
See also: hotspot, code churn.
Time to value (TTV): The time it takes from when a customer starts using a product to when they realize meaningful benefit from it. Flux is designed for fast time to value, giving you ground‑truth insights as soon as repositories are connected.
Token: The fundamental unit of text or code that an AI model processes. A token can be a whole word, a part of a word, or a single character. In AI-driven development, token limits define how much of your codebase an AI can read at once, and token usage often dictates the cost and speed of AI agents.
V
Vibe coding: A style of AI-assisted development where engineers describe what they want in natural language and accept AI-generated code with minimal review, leaning into the speed of AI rather than scrutinizing every output. Effective for prototyping and experimentation, but introduces risk in production environments where code quality, security, and maintainability matter. Flux gives leaders visibility into how AI-accelerated workflows like vibe coding change what teams ship. [SEE: Vibe coding – Wikipedia]
Vulnerability density: The frequency of security flaws within a specific volume of code. Recent industry and academic studies suggest that AI-generated code is often more likely to contain security vulnerabilities than human-written code, making automated visibility and ground-truth oversight essential.
W
Work type classification: The categorization of engineering work into meaningful types, such as feature development, bug fixes, maintenance, and refactoring, based on actual code changes rather than ticket labels or estimates. Flux automatically classifies work by type from commits and pull requests, giving leaders an objective view of where engineering effort is going and helping them distinguish innovation from maintenance.
See also: shadow work, ground-truth intelligence.