What you will learn in Vibe Engineering
Best practices, mistakes, and tradeoffs
Chapter by chapter
Chapter 1: Building on quicksand: the challenges of vibe engineering
The chapter introduction contrasts the real speed gains of AI-assisted development with the risks of unverified code and argues for an explicit engineering discipline.
What you learn in chapter 1 →Chapter 2: Building a legacy modernization framework powered by Vibe Engineering
The chapter introduces LLM-assisted legacy migration as a way to recover knowledge from unfamiliar code and make understandable, incremental changes.
What you learn in chapter 2 →Chapter 3: Context fabric: optimizing context for AI agents
The introduction explains why agents often fail because of the context they receive, distinguishes context engineering from prompt engineering, and defines a shared Context Fabric.
What you learn in chapter 3 →Chapter 4: LLM-driven data science
The introduction explains how LLMs can turn business questions into data-analysis notebooks while emphasizing that plausible-looking results still require human verification.
What you learn in chapter 4 →Chapter 5: From autocomplete to agent fleets: the road to Continuous AI
The chapter introduces AI coding tools as task-dependent forms of assistance moving toward Continuous AI, while arguing that greater autonomy requires accumulated operational maturity and guardrails.
What you learn in chapter 5 →Chapter 6: A scientific approach for validating LLM-based solutions
The chapter introduces a text-to-SQL service and explains why provider independence and measured accuracy matter when building an LLM-based solution.
What you learn in chapter 6 →Chapter 7: Vibe performance engineering: when assumptions mislead
The introduction identifies false traffic assumptions and missed hot-paths as two ways performance work can add complexity without delivering production benefits, including when LLMs assist.
What you learn in chapter 7 →Chapter 8: Evaluation is king: how to trust code you didn’t write
The introduction explains why AI-generated code creates a distinct trust problem and calls for confidence based on verified properties rather than an AI’s assurance.
What you learn in chapter 8 →Chapter 9: Economics of vibe engineering: cost optimization at scale
The introduction frames the move from AI prototype to production as a collision between model costs, unit economics, and the need to preserve quality.
What you learn in chapter 9 →Chapter 10: Your codebase is the bottleneck: code organization for the agent era
The introduction explains why AI agents that work well within individual projects can struggle at team scale when they lack system-wide context, and why existing engineering infrastructure matters more as agent use grows.
What you learn in chapter 10 →Concepts explained in this book
- context windowThe finite amount of input information a language model can consider during a single inference or conversation state.
- verificationThe systematic evaluation of an implementation or output against specified requirements and expected behavior.
- costThe total monetary, computational, operational, and human-review expense incurred in obtaining a system output.
- executable specificationA specification expressed in a form that can be executed or checked automatically to verify system behavior.
- vibe engineeringA disciplined approach to AI-assisted software development that emphasizes clear intent, clean abstractions, verification, testing, quality, and maintainable ownership.
- accuracyCorrectness is the degree to which software behavior satisfies its intended specification and real-world requirements.
- hot pathHot-path detection is the identification of frequently executed or resource-intensive code paths that substantially affect system performance.
- AI-generated pull requestSource code produced in whole or in part by an artificial-intelligence system.
- AGENTS.mdAGENTS.md is a tool-agnostic convention for a repository-root Markdown file that supplies project context and instructions to AI agents.
- context engineeringContext engineering is the discipline of designing, selecting, structuring, and maintaining the information supplied to an AI system so it can perform tasks effectively.
- promptA prompt is an input instruction or request supplied to an AI model to elicit a response or action.
- meanExpected value is the probability-weighted average outcome of a decision under uncertain possible results.
- AI agentAn AI agent is a software system that uses artificial intelligence to autonomously or semi-autonomously perform tasks on behalf of a user or application.
- language modelA language model is a machine-learning model that processes and generates text by predicting sequences of tokens.
- mental modelAn internal representation of how a system works that supports reasoning about its behavior and consequences.
- AI assistanceA software-development approach in which AI systems assist people with activities across the development lifecycle.
- MCPMCP is a protocol standard that lets AI agents discover and invoke external tools and services through a uniform interface.
- migrationSoftware migration is the process of moving an application or its code to a different platform, framework, architecture, dependency, or implementation while preserving required behavior.
- trust debtTrust debt is the accumulated cost of shipping AI-generated code without adequate verification.
- code ownershipThe assignment of responsibility and understanding for maintaining a body of source code.
- prompt engineeringPrompting is the practice of formulating and supplying instructions or context to an AI model to guide its output.
- autocompleteInline autocomplete is an editor feature that predicts and inserts code completions at the current cursor position.
- specification-driven developmentA development approach in which an authoritative specification drives implementation plans, tasks, tests, and delivery controls.
- information retrievalRetrieval is the process of selecting relevant information from an indexed or accessible knowledge source.
- performance optimizationPerformance optimization is the modification of software to improve responsiveness, throughput, or resource efficiency under a defined workload.
- own phaseThe lifecycle phase in which an engineering team understands, documents, maintains, and accepts accountability for the resulting code.
- deployment pipelineThe practice of continuously integrating code changes and continuously delivering or deploying validated software through automated pipelines.
- percentileA percentile is a distribution threshold below which a specified percentage of observed values falls.
- software testingAn executable procedure that evaluates software behavior against expected results or conditions.
- dependency graphA dependency map is a structured record of which software services depend on or communicate with one another.
- false positiveA false positive is a classification that incorrectly reports a positive or high-risk condition when it is absent.
- local-model inferenceDeveloper-local inference is the execution of an AI model on a developer's own workstation rather than on a remote serving system.
- compactionAutomatic context compaction is the automatic summarization of an AI conversation's accumulated history to reduce retained context.
- judgmentHuman judgment is the reasoning and decision-making people apply when evaluating situations, evidence, risks, and software changes.
- semantic verificationA verification assessment of whether a system satisfies the intended real-world business meaning and context.
- JMHJMH is a Java harness for constructing and running reliable microbenchmarks of Java code.
- code reviewThe manual examination of proposed source-code changes to identify defects, risks, and conformance or maintainability problems before integration.
- tradeoffA trade-off is a compromise in which improving one objective or property requires accepting a reduction in another.
- LLM-as-a-judgeLLM-as-a-Judge is an evaluation approach in which a large language model assesses or grades an artifact, change, or another model's output against specified criteria.
- agent orchestrationThe coordination of models, tools, data flows, and execution steps into a larger workflow.
- adversarial thinkingAdversarial verification is verification that deliberately probes software with hostile, unexpected, or broadly varied inputs to expose weaknesses.
- MCP serverAn MCP server is a service that exposes structured, executable tools and data-access capabilities through the Model Context Protocol.
- mutation testMutation testing evaluates a test suite by introducing small controlled changes into code and checking whether the tests detect them.
- measurementMeasurement is the systematic quantification of attributes or outcomes using defined observations or metrics.
- dump-and-review cultureDump-and-review culture is a development pattern in which AI generates a large code change and a reviewer is implicitly made responsible for verifying it.
- precisionPrecision is the proportion of predicted positive instances that are actually positive.
- flaky testA flaky test is an automated test that intermittently passes or fails without a corresponding change in the behavior being tested.
- performance testingA performance test measures whether a system meets responsiveness, throughput, or resource-efficiency requirements under workload.
- test-driven developmentA development practice in which automated tests are written before the production code that satisfies them.
- context rotContext rot is the degradation of an AI agent's performance as an overloaded or stale conversation context accumulates irrelevant or conflicting information.
- specification authoringThe process of defining a system's required behavior, constraints, and acceptance conditions.
- premature optimizationPremature optimization is modifying software for performance before reliable workload data or requirements justify the change.
- technical debtThe accumulated cost and risk created when expedient software decisions or deferred maintenance make future development and operation more difficult.
- cachingCaching is the storage of previously computed or retrieved results so that later equivalent requests can be served with less work or cost.
- Agent ModeAgent mode is an AI-assistance mode that can directly edit files and execute instructed changes within a codebase.
- edge caseAn edge case is an input or operating condition at the boundary or an unusual region of a system's expected domain.
- subagentA subagent is a specialized AI assistant that independently performs a delegated task with its own context, prompt, tools, and permissions.
- parallelismParallel execution is the concurrent performance of independent or separable computational tasks.
- thresholdA classification threshold is the score cutoff used to convert a model's continuous output into a discrete class decision.
- git hookA Git hook is a script automatically executed by Git in response to a repository event such as committing code.
- recallRecall is the proportion of actual positive cases that a classifier correctly identifies.
- continuous aiContinuous AI is a software-development approach in which AI agents are continuously integrated into task execution, validation, and review workflows.
- complexitySoftware complexity is the degree of difficulty involved in understanding, changing, operating, or coordinating a software system.
- custom benchmarking codeCustom benchmarking code is application-specific measurement logic written outside a dedicated benchmarking harness.
- instrumentationInstrumentation is the addition of telemetry-producing code or configuration that exposes a system's execution and operational state.
- sandboxingThe isolation of software execution within constrained resources and permissions to limit its impact on the surrounding system.
- property-based testingA testing technique that checks general properties or invariants across many generated or varied inputs rather than only fixed examples.
- overengineeringOver-engineering is the addition of unnecessary complexity, abstractions, or functionality beyond the actual requirements of a software system.
- static analysisThe automated examination of source code without executing it to identify defects, suspicious constructs, policy violations, or program properties.
- continuous integrationContinuous integration is the practice of frequently merging changes into a shared codebase and automatically building and testing them.
- Context FabricContext Fabric is a persistent layer of specifications, conventions, documentation, and structured knowledge surrounding a software project that supplies agents with project-specific working context.
- data analysisData analysis, or analytics, is the systematic inspection, transformation, and interpretation of data to discover patterns, derive insights, and support decisions.
- CLAUDE.mdCLAUDE.md is a Claude Code project instruction file containing persistent guidance that is loaded for agent sessions.
- hybrid migration approachA migration approach that combines in-place repository modification with work in a separate repository, retaining the legacy repository as a reference.
- Task/Verify gateThe Task/Verify gate is a workflow checkpoint that separates task execution from explicit verification.
- performancePerformance is a measure of a software system's resource efficiency and responsiveness under defined operating conditions.
- text-to-SQLText-to-SQL is the task of translating natural-language requests into executable SQL queries against a database.
- feature engineeringA feature engineering pipeline is a sequence of transformations that creates model inputs from raw data.
- retrieval-augmented generationRetrieval-augmented generation is a technique that retrieves relevant external information and supplies it as context for a language model's generated response.
- data leakageData contamination is the leakage of evaluation answers or related held-out information into model inputs or training-like context, invalidating an evaluation.
- tokenA unit of model input text counted when measuring the size and cost of a language-model request.
- AI-assisted code reviewAn AI review agent is an AI system that analyzes proposed software changes and reports violations, risks, or issues requiring human judgment.
- test suiteA collection of automated tests that evaluates software behavior against specified requirements.
- integration testAn integration test evaluates interactions between multiple software components or with external infrastructure rather than isolating a single unit.
- verify-then-mergeVerify-then-merge is a development pattern that requires generated code to be verified before it is integrated.
- build systemA build system is software that determines how source code is compiled, packaged, tested, and incrementally rebuilt from declared dependencies.
- test oracle reliability scoreTest oracle reliability score is the percentage of test outcomes that correctly indicate whether the tested behavior is acceptable.
- circular testA test whose validity depends circularly on the implementation or other tests rather than independently checking required behavior.
- prototypingAn iterative development technique for quickly exploring an idea and producing an initial working artifact.
- benchmarkA benchmark is a standardized evaluation procedure that measures a system against defined inputs and expected results.
- precision-recall curveA precision-recall curve plots a classifier's precision against its recall across different decision thresholds.
- SKILL.mdA skill file is a loadable instruction artifact that defines a reusable process or discipline for an AI agent to follow.
- diffusion of responsibilityDiffusion of responsibility is the reduction of individual accountability when responsibility is distributed across multiple people or agents.
- developer wait timeDeveloper wait time is the time developers spend unable to proceed while waiting for AI-assisted operations or results.
- model selectionModel selection is the choice of a particular AI model or service tier for a task based on capability, cost, and operational requirements.
- CursorCursor is an AI-powered code editor and development environment that assists users with generating, modifying, and understanding source code.
- multi-agent systemA multi-agent system is a software system in which multiple autonomous or semi-autonomous agents operate concurrently or collaboratively toward specified objectives.
- overfittingOverfitting is a modeling failure in which learned patterns fit training data too closely and generalize poorly to unseen data.
- acceptance testingA test that evaluates whether a system or feature satisfies product-level requirements from a user's or stakeholder's perspective.
- observabilityAutomated observability is the machine-driven collection and analysis of signals that make a system's behavior, failures, and quality degradation detectable.
- agent lifecycle hookAn agent lifecycle hook is a configured action that runs automatically at a defined point in an AI agent's execution lifecycle.
- hallucinationA hallucination is a language-model output that presents false, unsupported, or fabricated information as if it were true.
- mean absolute errorMean absolute error is a regression metric equal to the average absolute difference between predicted and actual values.
- mechanical verificationVerification performed by automated checkers against explicit artifacts such as types, tests, contracts, and schemas.
- first-attempt success rateFirst-attempt success is the rate at which an AI-assisted task is completed successfully without requiring a retry or correction.
- .cursorrules.cursorrules is a project configuration file containing persistent instructions for the Cursor AI coding environment.
- lint-as-architectureLint-as-architecture is the practice of expressing architectural knowledge as executable checks that fail when prohibited structures or dependencies appear.
- lintingA local linter is a tool run in a developer's environment that statically analyzes source code for style issues, likely errors, and convention violations.
- machine learningMachine learning is the field and set of computational methods in which models learn patterns from data to make predictions or decisions.
- memory boundA bottleneck is a limiting resource or constraint that restricts the progress or throughput of a system.
- diminishing returnsDiminishing returns is a pattern in which each additional increase in an input produces a smaller incremental improvement in outcome.
- tool descriptionA tool definition is a machine-readable description of an operation an AI agent can invoke, including its interface and capabilities.
- labelA label is the target value associated with an example that a supervised machine-learning model learns to predict or uses for evaluation.
- probabilistic systemA system whose outputs are determined by statistical likelihoods and may vary rather than being fixed for identical inputs.
- system contextSystem context is persistent information about a software system's architecture, schemas, and service topology.
- targeted test selectionSelective CI, or selective testing, is a continuous-integration approach that runs only tests determined to be relevant to a code or dependency change.
- lost in the middleLost in the middle is a long-context failure pattern in which a language model retrieves information near the beginning or end more reliably than information placed in the middle.
- remote cachingRemote caching stores reusable build or computation results in a shared remote cache so other users or machines can retrieve them.
- monorepoA monorepo is a single version-controlled repository containing multiple independently deployable software projects managed with shared build configuration and conventions.
- verification-firstA development pattern in which human-authored checks or specifications are established before AI-generated implementation code.
- parsingString parsing is the process of interpreting character sequences and extracting their structured components.
- context poisoningContext poisoning is the inclusion of misleading, outdated, unsafe, or otherwise harmful information in model context that biases an AI system toward incorrect output.
- f-scoreThe F1 score is the harmonic mean of precision and recall.
- cross-validationCross-validation is a model-evaluation technique that repeatedly trains and evaluates a model on different partitions of a dataset.
- guardrailA guardrail is a constraint or control that limits an AI system's actions to reduce unsafe, unauthorized, or unreliable outcomes.
- continuous improvementA feedback loop is a pattern in which information about an output or system state is fed back into subsequent evaluation or action.
- acceptance rateDeveloper acceptance rate is the proportion of AI-generated suggestions or outputs that developers accept for use.
- verification contractA contract expressed as testable expectations that an implementation must satisfy to be considered correct.
- GSDGSD is a spec-driven AI-agent development workflow that externalizes project information and coordinates task-oriented agents.
- meta-prompting frameworkA meta-prompting framework is a structured system that manages prompts, agent workflows, and persistent task information around an AI model.
- state externalizationState externalization is an agent-workflow pattern that persists project information outside ephemeral conversation sessions in durable artifacts such as files.
- subagent architectureSubagent orchestration is the coordination of specialized AI agents that independently perform parts of a larger workflow.
- SuperpowersSuperpowers is an AI-agent development framework that supplies selectively loaded skill files to enforce engineering processes.
- inline editInline edit is an AI-assisted editing interaction that applies a focused change directly at a selected location in source code.
- OllamaOllama is a software tool for downloading, running, and serving language models locally.
- governanceGovernance infrastructure is the collection of policies, controls, processes, roles, and supporting systems that direct and constrain system use.
- data cleaningData cleaning is the process of detecting, correcting, removing, or managing inaccurate, incomplete, inconsistent, or irrelevant data.
- invariantA software invariant is a property or condition that must remain true throughout specified program states or operations.
- context ballastContext ballast is irrelevant, redundant, or excessively broad information included in a model request that increases token use without helping the task.
- retry and failure costRetry and failure cost is the resource expense of unsuccessful AI attempts made before a task is completed.
- trust erosionQuality and trust erosion is the loss of confidence in an AI system when its outputs are insufficiently correct or useful.
- automation biasThe tendency to over-trust and uncritically accept information or decisions produced by automated systems.
- specificationA statement of required system behavior, constraints, or properties that defines what an implementation should satisfy.
- auto-mergeAuto-merge is the automated integration of a proposed code change once its required conditions and checks have passed.
- throughputThroughput is the rate at which a system produces outputs, measured here as generated tokens per second.
- code coverageCode coverage is a metric reporting the proportion of source-code lines, branches, or paths executed during testing.
- probabilistic modelA probabilistic model represents uncertainty by assigning probabilities to possible outputs or states.
- agent skillAn Agent Skill is a directory-based format for packaging procedural instructions and optional supporting resources as loadable context for an AI agent.
- software artifactAn artifact is a concrete output produced by a software or AI process that can be passed to or consumed by another process.
- evictionCache eviction is the removal of cached entries according to a policy, such as elapsed inactivity time, to limit retained data.
- quantizationQuantization is the representation of model parameters with fewer numerical bits to reduce model storage and memory requirements.
- self-healing CIA continuous-integration approach in which the system diagnoses failures and proposes or applies corrective changes.
- software engineeringThe systematic application of engineering practices, constraints, and verification to produce reliable and maintainable software.
- cost per iterationCost per iteration is a metric for the resources, including monetary cost, CI time, and developer attention, consumed by one agent development loop.
- software factoryA software factory is an autonomous software-production system in which agents execute the end-to-end code lifecycle while people operate and maintain the system.
- threat modelA structured representation of assets, threats, attackers, attack paths, and mitigations relevant to a system.
- root mean squared errorThe square root of the average squared difference between predicted and actual values, which penalizes larger errors more heavily.
- vendor lock-inVendor lock-in is dependency on a particular supplier that makes switching to an alternative costly or difficult.
- deep learningDeep learning is a machine-learning approach based on multilayer neural networks that learn hierarchical representations from data.
- approval queue paradoxThe approval queue paradox is the situation in which faster code generation increases the time required to deliver code because review and approval become the limiting process.
- context blindnessContext blindness is an AI-agent limitation caused by lacking relevant surrounding project information needed to perform a task correctly.
- cost optimizationThe systematic reduction of expenses required to operate a system while preserving required outcomes.
- audit trailAn audit trail is a chronological record of actions and changes that supports accountability and later inspection.
- parallel streamA Java parallel stream is a stream that processes pipeline elements concurrently using a parallel execution mechanism.
- quadratic time complexityQuadratic time complexity is an algorithmic growth rate in which running time increases proportionally to the square of input size.
- context failureA context problem is a deficiency or mismatch in the information supplied to an AI model for a task.
- regressionA regression is an unintended loss or degradation of previously correct software behavior.
- context anchoringA context-management pattern that preserves an AI agent's focus by maintaining stable objectives or task information.
- fuzzingFuzzing is an automated testing technique that supplies large numbers of generated, malformed, or unexpected inputs to discover failures and vulnerabilities.
- tacit knowledgeTacit knowledge is practical, often organization-specific understanding held by individuals or groups that is not explicitly documented or standardized.
- agent gateAn agent gate is a workflow control that invokes an AI agent to assess a proposed software change before it progresses through delivery.
- delegationDelegation is a workflow pattern in which a task is assigned to an autonomous agent that returns an artifact for human review.
- deterministic checkA deterministic check is an automated validation whose output is predictably determined by its inputs and explicit rules.
- routingModel routing is the selective assignment of requests to different AI models according to task requirements such as complexity, quality, and cost.
- shadow evaluationShadow evaluation is a technique that runs a reference evaluation alongside a production evaluation and compares their results without replacing the production path.
- creativityThe degree to which a generative model produces novel or less conventional outputs rather than likely familiar ones.
- safetySafety is the prevention of harm to people, systems, or the environment from a system's operation or failure.
- verifierA component or process that checks an artifact or action against specified rules and conditions.
- coefficient of determinationA regression metric, also called R-squared or R², measuring the proportion of target variance explained by a model.
- metricA metric is a quantitative measure used to assess a property or outcome of a software system or process.
- q4_K_M formatQ4_K_M is a model quantization configuration that stores weights at approximately four-bit precision using a specified K-family quantization variant.
- normalizationNormalization is the process of transforming data into a consistent representation or scale suitable for comparison and analysis.
- regular expressionA regular expression is a pattern notation for matching and extracting text according to specified character and sequence rules.
- evaluationThe assessment of an artifact or system to determine its quality, correctness, or fitness against relevant criteria.
- pull request throughputPull request throughput measures the rate at which pull requests are processed, merged, or otherwise completed.
- unit testA unit test evaluates an isolated software unit, such as a function or class, against expected behavior.
- false negativeA false negative is a classification that incorrectly reports a negative or low-risk condition when a positive or high-risk condition is present.
- validationThe process of checking that software behavior or output satisfies intended requirements and real-world constraints.
- MarkdownMarkdown is a lightweight markup language for formatting plain-text documents.
- signalA feature is an input variable or observed attribute supplied to a machine-learning model for making a prediction.
- high-risk categoryA classification label indicating that a medication or medication request is considered high risk and requires heightened scrutiny or review.
- human-in-the-loopThe monitoring and direction of an automated system by people who retain authority to identify errors and correct its course.
- securitySecurity is the protection of software, data, and operations against unauthorized access, misuse, disruption, or alteration.
- swarmA coordinated group of AI agents that divide or jointly execute parts of a larger workflow.
- documentation generationDocumentation generation is the automated creation or regeneration of software documentation from source code or related artifacts.
- model architectureA neural network architecture is the organization of computational layers and connections that transform inputs into outputs through learned parameters.
- runtime fallbackA runtime fallback is an operational pattern that redirects a failed request to an alternative service or provider while the system is running.
- test integrity checkA check that detects changes to tests, assertions, toolchain versions, or test dependencies that could weaken verification.
- test oracleA test oracle is a mechanism or specification that determines whether a program's output or behavior is correct for a test input.
- deploymentDeployment is the process of installing and configuring software so that it runs in a target environment.
- agentic sessionAn agent session is a bounded interaction in which an AI agent reads context, plans work, and performs potentially multi-step changes.
- Cloud RunGoogle Cloud Run is a managed platform for running containerized applications in a serverless execution environment.
- amnesiac coder issueThe amnesiac coder issue is an AI-agent failure mode in which the agent loses prior task decisions, interactions, and code context over a long task.
- to-do listA to-do list is an ordered collection of tasks, often annotated with completion status and priority.
- repositoryA repository is a version-controlled project store containing source code, configuration, and recorded change history.
- artifact-centric approachA workflow approach that treats produced work artifacts rather than agent conversations as the primary units of coordination and oversight.
- snapshot comparisonA golden file is an approved reference-output file against which subsequent program output is compared.
- memory usageMemory usage is the amount of computer memory consumed by a running application or its data.
- command-line interfaceA command-line interface is a text-based interface for invoking software operations by entering commands.
- headless modeHeadless agent execution is a noninteractive mode in which an AI agent runs without a graphical user interface or ongoing direct user input.
- ephemeral environmentAn ephemeral environment is a temporary, isolated computing environment created for a specific task or execution and discarded afterward.
- chain-of-thought promptingChain-of-thought prompting is a technique in which a language model generates intermediate reasoning steps before producing its final answer.
- memory pressureMemory pressure is a condition in which running software demands enough memory to constrain performance or force memory reclamation and swapping.
- night shiftNight Shift is an automated background workflow in which an AI agent upgrades dependencies, tests affected code, and routes changes for automatic merging or human review.
- real dataA real-world dataset is a collection of observations gathered from an actual domain or operational process rather than generated artificially.
- review queueAn ordered backlog of proposed code changes awaiting review and approval.
- shadow AIShadow AI is the unapproved use of AI tools or services outside an organization's governed and auditable processes.
- synthetic dataSynthetic data is data generated algorithmically rather than directly collected from the underlying real-world process.
- machine learning workflowA machine-learning pipeline is an ordered workflow that prepares data, trains a model, and produces or evaluates predictions.
- shell scriptA shell script is a text file containing commands interpreted and executed by an operating-system command shell.
- pluginAn agentic plugin is a versioned distributable package that bundles AI-agent skills with workflow integrations and configuration.
- progressive disclosureProgressive disclosure is a technique that reveals information in successive levels only when it becomes relevant or requested.
- lint ruleA lint rule is a configured static-analysis condition that identifies source-code style, correctness, or maintainability issues.
- mixture of expertsA mixture-of-experts model is a neural-network architecture that selectively activates a subset of specialized parameter groups for each input.
- slash commandA slash command is an explicitly invoked command entered with a slash-prefixed name in an interactive tool interface.
- AntigravityAntigravity is Google's agent-first development platform for spawning, orchestrating, and observing AI agents across development environments.
- documentationSoftware documentation is written reference material describing a software product's installation, interfaces, behavior, design, or usage.
- green classificationA change-risk classification that permits a pull request to be merged automatically when all required safety conditions are met.
- MapA map is an associative data structure that stores values indexed by unique keys.
- approval fatigueApproval fatigue is the degradation of meaningful human oversight caused by a decision frequency that exceeds a person's cognitive capacity for careful review.
- lazy initializationLazy loading is a technique that obtains or constructs data only when it is first requested rather than during initialization.
- iterations-to-successThe number of continuous-integration revision cycles required for an agent-generated change to reach an acceptable, merge-ready result.
- plan-act-observe loopA plan-act-observe loop is an iterative agent workflow that plans an action, executes it through tools, observes the result, and uses the observation to determine subsequent actions.
- auto-merge rateThe percentage of pull requests that are integrated automatically rather than through human review.
- indexingProject indexing is the process of analyzing and cataloging project files to support efficient code search and contextual retrieval.
- Jevons paradoxJevons paradox is the economic effect in which greater efficiency lowers unit cost but increases total resource consumption through expanded demand.
- slopsquattingAn attack in which an attacker registers package names that language models are likely to hallucinate so developers may install malicious software.
- Spring BootSpring Boot is a framework for building and configuring Spring-based applications with convention-over-configuration support.
- embeddingAn embedding is a numerical vector representation of data whose geometric relationships encode semantic similarity.
- evaluation datasetA held-out portion of data used to evaluate a trained machine-learning model on previously unseen inputs and targets.
- backward compatibilityBackward compatibility is the ability of a newer software version to preserve the behavior and interfaces expected by an older version's users or integrations.
- pull requestA proposed set of repository changes submitted for review and integration into a codebase.
- two-pass review architectureA first-pass filter is a preliminary low-cost evaluation that selects items requiring a more expensive subsequent evaluation.
- scalabilityScalability is the ability of a system, process, or organization to handle growth in workload, users, participants, or complexity while maintaining acceptable operation.
- blast radiusA blast radius is the extent of systems, data, or operations that can be affected by a failure or harmful action.
- GPU memoryVRAM is memory on a graphics-processing unit used to store graphics and compute workloads such as model parameters.
- unified memoryA unified memory architecture is a hardware design in which processing units such as CPUs and GPUs access a shared memory pool.
- token countToken consumption is the quantity of language-model input and output tokens used by an AI system or user over a defined period.
- thread poolA thread pool is a managed collection of reusable worker threads that execute submitted tasks.
- context fragmentationA failure mode in which relevant information is isolated across projects or services, leaving an AI agent without the system-wide context needed to make correct changes.
- contractAn API is a defined interface through which software systems communicate and invoke one another's capabilities.
- Gemini APIGemini Developer API is Google's developer-facing API backend for accessing Gemini models with an API key.
- Google Genai Java SDKGoogle Genai Java client SDK is a Java client library for communicating with Google's generative AI services.
- language model client interfaceA language model client interface is an abstraction that defines a common contract for invoking different language-model providers.
- vigilance decrementVigilance decrement is the decline in sustained attention that occurs during prolonged monitoring.
- meta-repositoryThe meta-repository pattern maintains a dedicated repository of cross-repository dependency, communication, convention, and decision knowledge for agents.
- AI productivity paradoxThe situation in which faster AI-generated code is offset or outweighed by the additional effort required to understand, review, and safely integrate it.
- development process validation systemAn engineered pipeline of controls and checks that validates AI-assisted software changes throughout development and release.
- local autonomous agentAn AI software-development system that selects work and delivers tested code changes with minimal human intervention.
- OpenAI APIThe OpenAI API is a public programming interface for accessing OpenAI-hosted artificial-intelligence models and services.
- network trafficExpected traffic is the anticipated volume of requests, users, or work that a software component must handle in operation.
- classificationClassification is a supervised machine-learning technique that assigns inputs to one of a defined set of classes.
- plan modePlan mode is an AI-assistance mode that outlines intended development steps before modifying code.
- cycle timeCycle time is the elapsed time required for work to progress from initiation to completion in a development process.
- developer satisfactionDeveloper satisfaction is a subjective measure of developers' perceived contentment with their work tools and environment.
- Google Code WikiGoogle Code Wiki is a Gemini-powered platform that monitors repositories and maintains generated, structured documentation about their codebases.
- Unix philosophyThe UNIX philosophy is a software design approach that composes small programs with focused responsibilities through text-based interfaces.
- deferred tool loadingDeferred tool loading is an approach that discovers and loads tool definitions only when an agent needs a capability.
- frequency and complexity heuristicA frequency and complexity heuristic is a decision method that chooses an interface based on how often it is invoked and how complex its inputs and outputs are.
- tool budgetA tool budget is a configured limit on the portion of a model context window allocated to tool definitions.
- test-driven promptingTest-Driven Prompting is an AI-assisted development technique that supplies behavioral tests as specifications for generating code.
- code qualityCode quality is the degree to which source code conforms to correctness, maintainability, architectural, and style expectations.
- redosA regular-expression denial-of-service vulnerability causes excessive regex matching time, often through catastrophic backtracking on attacker-controlled input.
- training datasetTraining data is the collection of examples used to fit or adapt a machine-learning model.
- multi-file taskMulti-file code generation is the generation or modification of coordinated source-code changes across multiple files.
- dependencyA software dependency is a component, package, library, or other resource that another component requires to function correctly.
- manual testingManual testing is the evaluation of software behavior by a human executing and inspecting test procedures rather than automated test code.
- one-hot encodingOne-hot encoding transforms a categorical value into a vector of binary indicator variables, with one indicator active for the selected category.
- random forestA random forest is an ensemble machine-learning model that combines predictions from many decision trees.
- git worktreeA Git feature that creates multiple working directories connected to one repository, allowing different branches to be checked out simultaneously.
- model scalingModel scaling is the practice of increasing model size, training-data volume, and compute to improve model capability.
- GatlingGatling is a load-testing tool for simulating high-volume application traffic and measuring performance.
- parserA program component that analyzes an input sequence according to a formal grammar and produces a structured representation.
- headless automationHeadless automation is automated software work performed without an interactive user interface or continuous human supervision.
- known-question analysisKnown-question analysis is a data-analysis approach in which predefined questions determine the computations and outputs to produce.
- progressive evaluationProgressive validation is a staged verification approach that applies increasingly costly checks only when earlier checks pass or indicate they are needed.
- language server protocolLanguage Server Protocol is a JSON-RPC-based standard through which editors and development tools obtain language-aware services from language servers.
- workflowAn AI workflow is a recurring work process in which an AI tool performs or assists one or more development tasks.
- rebound effectThe rebound effect is the increase in use of a service after efficiency reduces its per-use cost, offsetting part of the expected total savings.
- tokenmaxxingTokenmaxxing is the practice of maximizing AI token consumption and treating consumption volume as evidence of productivity.
- conflicting contextA conflicting signal is a context failure in which instructions or guidance are contradictory, ambiguous, or inconsistently presented.
- anomalyAn outlier is an observation that differs markedly from the distribution or expected pattern of the other observations.
- MongoDBA document-oriented database system that stores and queries data using BSON documents and provides distributed data-management capabilities.
- Spring Data MongoDBSpring Data MongoDB is a Spring Data module that provides repository and data-access abstractions for MongoDB.
- manufacturer analysisManufacturer analysis is the examination of medicine records to determine which manufacturers produce the most medicines.
- provenanceData lineage is provenance information describing the origin, movement, transformations, and approval history of data or other artifacts.
- refactoringRefactoring is the restructuring of existing code to improve its design or understandability without intentionally changing its externally observable behavior.
- Anthropic Batch APIA batch API accepts a collection of requests for asynchronous processing and makes their results available later.
- latency-cost-quality triangleA trade-off framework stating that AI-assisted development configurations cannot simultaneously maximize response speed, low expense, and output quality.
- break-even ruleA break-even rule is a heuristic for deciding whether the expected savings of an intervention exceed its expected costs.
- review overheadReview overhead is the engineering-time cost of manually evaluating generated code or other proposed changes.
- GRUA gated recurrent unit is a recurrent neural-network architecture that uses gating mechanisms to control information flow through a sequence.
- token economyToken economics is the analysis of costs and trade-offs associated with language-model input and output token consumption.
- key-value cacheA KV cache is a stored collection of transformer attention keys and values from previously processed tokens that accelerates subsequent generation.
- quality samplingQuality sampling is the periodic manual review of a random subset of output changes for qualitative defects that automated checks may miss.
- canary deploymentA canary deployment is a staged release method that exposes a new version to a limited production scope before broader promotion.
- commitA Git commit is an immutable recorded snapshot of repository changes with associated metadata and parent history.
- subscription-plus-overage modelSubscription pricing is a billing model that charges a recurring fixed fee for access subject to plan terms and usage limits.
- allowlistAn allowlist is an explicit list of approved entities, integrations, or actions that are permitted.
- ambiguityAmbiguity is a lack of sufficient clarity that permits multiple interpretations of a requirement, rule, or design choice.
- architectural decisionAn architectural decision is a choice about the structure, boundaries, interactions, or major technical direction of a software system.
- structural riskStructural risk is the possibility that a system's organization or constraints will cause persistent, widespread, or difficult-to-detect failures.
- moduleA module is a bounded software code unit that groups related declarations and can serve as an independently managed architectural component.
- many-shot promptingMultishot is a prompting technique that provides multiple examples of similar patterns so a language model can generalize from them.
- datasetA dataset is a structured collection of related data records or values used for analysis or machine learning.
- architectural ruleAn architectural rule is a constraint governing the allowed structure, dependencies, or interaction patterns of a software system.
- modularityModularization is the organization of software into separate, bounded components with defined interfaces and relatively independent builds.
- handoffA handoff protocol is a defined procedure for transferring task state, context, and responsibility between people, agents, or execution modes.
- security scannerSecurity scanning is the automated examination of software, dependencies, or configuration for vulnerabilities and other security weaknesses.
- tokenizationThe process of converting text into discrete tokens suitable for computational processing.
- precommit hookA pre-commit hook is an automated check that runs before a version-control commit is accepted.
- token limitA token budget is a configured target or limit for the number of language-model tokens a task may consume.
- triage thresholdA triage threshold is a configured criterion that assigns work or changes to review and automation risk levels.
- qualityQuality is the degree to which a system's outputs satisfy required correctness, usefulness, and user expectations.
- environmental divergenceAn environmental divergence bug is a defect caused by differences between software execution or build environments.
- proxy metricA proxy metric is an observable measure that indirectly indicates a value or outcome that cannot be measured directly.
- return on investmentReturn on investment is a measure comparing the value gained from an investment with the cost of making that investment.
- test coverage deltaTest coverage delta is the change in test coverage over a specified period or intervention.
- CLI-first approachA CLI-first approach gives an AI agent command-line interfaces for applicable operations instead of protocol-specific tool schemas.
- code executionCode execution is an approach in which an AI agent writes and runs a program against an API to perform multiple data operations in one execution.
- deterministic context assemblyDeterministic context assembly is the repeatable selection and preparation of task-relevant context before an AI agent begins work.
- dynamic tool discoveryOn-demand tool discovery is a method in which an agent searches for needed capabilities and receives only matching tool definitions in its context.
- full tool exposureFull tool exposure is an architecture in which every connected server advertises all of its tools on every agent request.
- MCP gatewayAn MCP gateway is a centralized control plane between AI agents and MCP servers that governs access and monitors requests.
- static application security testingStatic Application Security Testing is the analysis of source code or compiled code without executing the application to identify security vulnerabilities.
- tool explosionTool explosion is the excessive exposure of available tools that increases context size, selection difficulty, and agent confusion.
- rollbackRollback is the process of reverting a system or codebase to a previously known state after an unsuitable change or failure.
- formal methodFormal methods are mathematically rigorous techniques for specifying, modeling, analyzing, and verifying properties of software or hardware systems.
- eager cachingEager caching loads and retains cache contents before they are requested, commonly during application initialization.
- agentic searchAgentic search is an iterative search approach in which an AI agent uses tools to inspect live information, follow references, and refine its search based on observations.
- embedding-based retrievalEmbedding-based retrieval is retrieval that ranks indexed content by similarity between vector embeddings of the query and candidate content.
- similarity searchSimilarity search retrieves items whose vector representations are nearest to a query vector according to a similarity measure.
- prompt augmentationPrompt augmentation is the addition of retrieved or otherwise relevant information to an original model prompt.
- checklistA checklist is a structured list of specific items or conditions to inspect when evaluating an artifact or process.
- cross-model validationCross-model validation is the practice of having a model different from the generating model evaluate generated output.
- ci feedback latencyCI feedback latency is the elapsed time between submitting a code change to continuous integration and receiving its evaluation result.
- merge queue wait timeMerge queue wait time is the elapsed time a pull request waits after passing continuous integration before it is merged.
- project memory fileA memory file is a persistent project document that records information intended to be available across AI-agent sessions.
- continuous modernizationContinuous modernization is the ongoing automated or systematic improvement of a codebase's technologies, structure, and maintainability.
- agent shortcuttingAgent shortcutting is the practice of changing or bypassing verification conditions to obtain a passing automated result without correcting the underlying software behavior.
- developer productivityDeveloper productivity is the quantity, quality, or timeliness of software-development output produced by a developer or team.
- escape rateThe proportion of defects that reach production after passing an earlier quality-control process.
- ClineCline is an AI coding assistant that can support planning, code generation, and project changes.
- code incrementA code increment is a coherent set of changes that produces a stable intermediate version of a codebase.
- approval decisionAction approval is a human authorization step that must be granted before an automated system performs a requested operation.
- JUnitJUnit is a Java testing framework for defining and executing automated tests.
- reliabilityTest reliability is the consistency with which tests produce correct and repeatable results for the same software and conditions.
- 70% problemA framing that distinguishes readily automated software-production work from the context-sensitive judgment that remains for humans.
- architectural complianceThe consistency of software components with a system's intended architecture, conventions, and integration boundaries.
- comprehensive verificationVerification that evaluates software across functional, invariant, performance, mutation, and security concerns.
- edge-case cartographyThe systematic identification and reasoning about unusual, boundary, error, and unspecified operating conditions.
- conversational aiAn AI assistant is a software system that uses artificial intelligence to help a user perform tasks or generate information.
- formal verificationThe use of mathematical specifications and proofs to establish that software satisfies required properties for all permitted cases.
- autonomyAutonomy is the degree to which a software system can select and carry out actions without direct human intervention.
- production-ready softwareThe state in which software is adequately reliable, operable, secure, and resilient for real-world deployment.
- contract testingA testing technique in which a service consumer's expected requests and responses are checked against a service provider's actual behavior.
- characterization testingA testing technique that records existing software behavior and checks that later changes preserve it except for explicitly intended differences.
- to-do toolA to-do tool is an AI-agent tool that creates and updates a structured list of planned tasks and their statuses.
- artifact driftThe divergence of a recorded artifact from the current assumptions, implementation, or decisions it is meant to represent.
- verification theaterSuperficial validation that confirms an artifact exists or appears well formed without establishing that it fulfills its intended purpose.
- dependency boundaryA dependency boundary is an architectural separation that constrains how software components may depend on one another.
- block-level code suggestionAn AI coding assistance technique that proposes a multi-line block of source code for developer acceptance or editing.
- enforcement gateA rule-enforcing checkpoint that permits progression only when specified policy or risk conditions are satisfied.
- GPT-4oGPT-4o is a multimodal generative language model from OpenAI.
- monitoringMonitoring is the continuous collection and examination of system behavior and operational measurements.
- command-line toolA command-line tool is a software utility operated by entering commands in a terminal or shell.
- feature selectionFeature selection is the process of choosing a subset of input variables for use by a predictive model.
- top-n encodingTop-n encoding retains the most frequent categorical values as distinct groups while placing remaining values into an other category before encoding.
- compiler semantic modelA compiler semantic model is the compiler's resolved representation of program symbols, types, references, and language meaning.
- language serverA language server is a process that provides compiler- or language-aware editing, navigation, and analysis capabilities through the Language Server Protocol.
- MetalsMetals is a Language Server Protocol implementation for Scala that provides compiler-aware code analysis and development tooling.
- MCP integrationA pattern in which build-system information and capabilities are exposed to an AI agent through the Model Context Protocol.
- automatic reorderingThe arrangement of retrieved context so that information judged most relevant occupies more prominent positions in a model input.
- IDEAn integrated development environment is a software application that combines source editing, building, debugging, and related programming tools.
- trust deficitA trust deficit is the gap between the speed at which AI produces code and the ability to adequately verify that code.
- controllerA controller is an application component that receives requests, coordinates application behavior, and returns responses at an interface boundary.
- deliberative reasoningA reasoning approach in which a model explicitly considers intermediate steps, evidence, and alternatives before reaching an answer.
- chain-of-thoughtReasoning is the deliberate use of intermediate inference steps to analyze a problem and derive an answer.
- vector databaseA vector database is a database specialized for storing vector embeddings and retrieving them by similarity.
- merge conflictA merge conflict is an incompatibility between concurrent changes that must be resolved before they can be combined.
- quality gateA quality gate is a defined checkpoint that requires specified quality criteria to be satisfied before work can proceed.
- linear searchLinear search is a search algorithm that examines elements sequentially until a matching element is found or the collection is exhausted.
- software craftsmanshipSoftware Craftsmanship is a software-development movement emphasizing well-crafted code, individual responsibility, and mastery of programming practice.
- classifierA classification model is a machine-learning model that assigns inputs to one or more discrete categories.
- code generationThe automated production of source code from instructions, specifications, or other inputs.
- anomaly detectionAnomaly detection is the identification of unusual patterns or deviations from expected behavior in data or system operation.
- circuit breaker patternA circuit breaker is a resilience pattern that automatically stops or rejects operations when failure or degraded quality exceeds a threshold.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
