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.
After this chapter you will be able to
- Project context versus system context. Explain why an agent that is competent within one project can make mistakes across a system of services: it may know its project's files and conventions but lack shared constraints and changes elsewhere.
- Locally correct systemic mistakes. Explain how an agent with strong context inside one repository can produce locally valid code that violates rules or relationships elsewhere in the system.
- Repository boundaries as context delivery. Explain why the section treats repository topology as an agent-experience decision, contrasting co-located services with scattered repositories.
- Shared Repository Search Space. Explain how a monorepo differs from a monolith or a multi-repo arrangement, and why its shared search space helps an agent understand services across project boundaries.
- Queryable Dependencies And Enforced Rules. Describe why a useful monorepo needs both a queryable dependency graph and conventions enforced by root-level tooling, rather than merely putting projects in folders.
- Monorepo Audit And Meta-Repository. Apply the section's three-property audit to an existing monorepo and describe how a meta-repository can supply shared context without immediately migrating every service.
- Ambiguous Codebase Navigation. Explain why the agent chose the wrong checkout package and why the section calls this an information failure rather than a reasoning failure.
- Structural Navigation Costs. Describe what agents lack when navigating by individual files rather than a map of the codebase, and trace the cost of searching and backtracking.
- Hidden blast radius of changes. Explain why a change that passes its own package’s tests can still break consumers, using the shared-utils example, and relate this failure to the agent’s lack of dependency-graph awareness.
- Project Graph Navigation. Explain how build configuration gives an agent a queryable map of packages and helps it select the active package rather than guess from file names.
- Reverse Dependency Blast Radius. Trace how an agent uses reverse dependencies after an edit to identify affected consumers and test them before submitting a PR.
- Enforced Status Tag Accuracy. Explain why package status tags need machine-backed checks and describe the safeguards used to keep them accurate.
- Strict dependency graph contract. Explain why an agent cannot rely on a reverse-dependency query when code can import undeclared dependencies, and how strict deps prevents that failure.
- Granular Builds and Tests. Explain why smaller build targets let the build system rebuild less code and run fewer tests after a change, rather than rebuilding and retesting an entire service.
- Agent Reasoning Boundaries. Explain how a target boundary narrows what an agent needs to understand and changes the scope of dependency and blast-radius information. Describe the maintenance tradeoff of having more targets.
- Static context gap. Explain why AGENTS.md and a documented dependency graph can become insufficient context for an agent in a frequently changing codebase.
- Live build context. Describe how exposing build-system metadata through an MCP server changes the build system's role for an agent.
- Organizational price of coherence. Explain why a monorepo with strict dependencies creates friction between teams and why the section considers that friction worthwhile for agents.
- Agent Cadence and CI Capacity. Explain why a CI pipeline that worked for a human development cadence can become a bottleneck when agents produce PRs much faster.
- Compounding Cost of Slow Feedback. Explain how waiting for CI can make agent iterations more expensive and less focused, and why faster feedback changes the time needed to converge.
- Environment mismatch failure chain. Trace how an agent sharing a developer’s local environment can produce a bug when it iterates against CI. Explain why repeated environment mismatches become a team-scale quality problem.
- Modular builds for agent throughput. Explain why many agents compiling the same monolithic project can be limited by disk I/O, and how independent modules change the work required when agents edit different parts of the codebase.
- Hermetic build reproducibility. Explain how isolated, hermetic execution prevents environmental divergence between an agent's build and CI.
- Private iteration and review gate. Explain why agents should iterate privately and pass verification before their work becomes a pull request for human review.
- Shared build artifact reuse. Explain how remote caching differs from rebuilding from scratch or using a local cache, and how an agent can reuse an artifact compiled by another agent.
- Team scale caching economics. Explain why running more agents can make a shared cache more useful and how that affects the build portion of Cost-per-Iteration, while distinguishing verification from automatic cache reuse.
- Dependency-based selective CI. Describe how selective CI uses changed files and the dependency graph to run relevant tests rather than the entire suite, and how CI can apply and re-run straightforward autofixes.
- Hard cap on agent retries. Explain why the validation loop limits an agent's attempts to fix a failed test and escalates persistent failures to a human.
- Module boundaries and agent throughput. Explain why independently compilable modules improve throughput when multiple agents work on a service. Describe how module boundaries limit rebuilds and allow changes in different modules to build concurrently.
- Full cost of agent operations. Explain the four cost categories of team-scale AI coding—licenses, compute, tokens, and review overhead—and why a license budget understates the total. Use Marcus’s example to illustrate why a team should calculate its own cost ratio rather than assume a universal one.
- Infrastructure investment and payback. Justify throughput infrastructure as an upfront investment using the section’s account of Marcus’s build-out, monthly costs, and measured savings.
- Flaky CI as false feedback. Trace how a flaky test failure can lead an agent to invent a cause, make an unnecessary fix, and treat a later passing run as proof that the fix worked.
- Circular tests and false confidence. Explain why tests written by the same agent that wrote the code can pass while the behavior is wrong, and how an independent requirement-based check addresses that gap.
- Agent shortcuts to green CI. Describe how an agent can make CI pass by removing or weakening checks instead of correcting code, and why the green checkmark cannot distinguish those outcomes.
- Dependency graph blast radius. Explain why the monorepo dependency graph magnifies the effects of unreliable tests and weakened checks.
- Test reliability before speed. Explain what TORS measures and why improving test reliability should precede speeding up CI for agents.
- Acceptance tests versus agent tests. Distinguish what agent-generated unit tests and human-written or ticket-derived acceptance tests verify when an agent changes business logic.
- Flaky test visibility and quarantine. Describe how Marcus identified flaky tests and kept them from wasting agent iterations while they were being fixed.
- Mutation testing for circular tests. Explain how mutation testing exposed tests that mirrored the implementation and why Marcus rewrote them against the product specification despite lower coverage.
- Checks against agent shortcutting. Describe the test integrity checks Marcus added and explain why shortcutting must be checked explicitly.
- Approval Queue Paradox. Explain how agent-assisted PR production can exceed reviewers’ capacity, causing a growing backlog and turning careful review into superficial approval.
- Selective Human Review. Justify changing which PRs reach human reviewers instead of simply hiring more reviewers or asking senior engineers to review faster.
- Polish Versus Sound Judgment. Distinguish an agent-generated PR's polished surface from the soundness of its underlying reasoning, and describe what the remaining human review should assess.
- Executable architectural rules. Explain why architectural expectations that human reviewers have internalized must be encoded as automated checks for agents.
- Bug to lint rule pipeline. Describe how the team turns a recurring architectural violation into a lasting check.
- Accumulating review benefits. Explain how accumulated rules change agent submissions and the work left for human reviewers.
- Contextual merge risk. Explain why a PR's Green, Yellow, or Red classification depends on the module and the change's risk, not just diff size. Contrast a leaf notification service with a widely used core library or financial logic.
- Evidence-based Green promotion. Describe the conditions a PR must meet for Green auto-merge and how Marcus expanded that bucket using observed review outcomes and production defects.
- Sustainable reviewer workload. Explain why reducing the queue through auto-merge did not by itself solve the review bottleneck, and describe Marcus's changes to reviewer duty and the Green-rate target.
- Green Auto-Merge Economics. Explain how review costs and the cost of escaped defects set a minimum accuracy for Green auto-merges, using the section’s example.
- Released Capacity Versus Savings. Distinguish avoided review costs from actual cash savings or product gains, and describe how to judge the value of the capacity released.
- Empirical Green Calibration. Describe how to expand the Green bucket through observed approvals and stronger automated checks rather than relaxed standards.
- Dead Project Risk. Explain why a service can still provide business value while becoming a growing liability, and why teams keep postponing its modernization.
- The Night Shift workflow. Trace how the Night Shift agent selects, tests, and routes dependency upgrades while the team is away.
- Dependency graph as coordinator. Explain how a queryable dependency graph lets an agent coordinate upgrades across services and why existing development infrastructure makes repeated modernization practical.
- Open production development loop. Explain why the production-to-development feedback loop remains open even when the same engineers write and operate a service, and why that gap matters for agents.
- Production guided agent maturity. Describe how closing the loop progresses from using incident data to prioritize work, through proactive investigation and verified fixes, toward a fully autonomous feedback loop.
- Continuous Modernization prerequisites. Explain why the Night Shift depends on shared context, dependency-aware navigation, fast isolated feedback, reliable tests, and tiered review rather than operating as a standalone automation trick.
- PR Volume Versus Value. Explain how PR throughput can rise sharply while customer-facing feature delivery stays flat, including the effect of agents splitting work into smaller changes.
- Iterations to Success by Module. Explain what Iterations-to-Success (ITS) counts and why tracking it per module helps locate problems that a team-wide average could hide.
- Cost per Iteration Returns. Describe what Cost-per-Iteration (CPI) indicates and how shared remote caching can lower it as more agents use the system.
- Tail CI Feedback Latency. Explain why CI Feedback Latency is tracked at P50, P95, and P99 rather than judged only by its typical value.
- Test Oracle Reliability Monitoring. Explain how per-module Test Oracle Reliability Score (TORS) is used to catch unreliable test feedback before agents waste iterations.
- Auto Approval and Escapes. Distinguish Auto-Approve Rate from escape rate and explain why both matter when expanding Green triage.
- Post CI Merge Queue Delay. Explain what Merge Queue Wait Time measures and how it identifies a review bottleneck that fast CI cannot solve.
- Cost per feature. Explain why cost-per-feature is more meaningful than cost-per-PR or PR throughput, and describe how costs from multiple PRs can be rolled up to a feature.
- Full AI cost breakdown. Describe the four cost lines in Marcus's dashboard and explain why subscription spending alone cannot answer whether AI is paying off.
- AI capability and engineering chassis. Explain why widespread AI-generated code does not by itself demonstrate improved productivity or business results, and describe the engineering layers the section says must support agents.
- Code as a decision artifact. Explain why code is the expression of problem-solving decisions rather than the point of engineering, and why writing it has also helped developers think those decisions through.
- Human judgment under automation. Distinguish implementation tasks AI can perform from the judgment questions engineers must answer, and explain why faster implementation increases the consequences of a wrong decision.
- Ambiguity at agent scale. Explain how unclear specifications and implicit conventions become structural risks when many agents act on them at once.
- Tech lead leverage shift. Explain how the tech lead’s leverage shifts from writing and reviewing difficult code to defining agent tasks, reviewing consequential output, and designing the infrastructure and verification that make others’ agents effective.
- Agent guidance and risk decisions. Describe how a tech lead uses shared agent guidance and module-level review thresholds to prevent repeated mistakes and decide which changes may be auto-merged. Explain why promoting patterns to Green requires evidence and architectural judgment.
- Durable discipline beneath changing tools. Explain why the book's specific tool advice may age while its underlying engineering discipline remains useful.
- Enduring engineering constraints. Describe the recurring constraints the authors say remain important despite smarter models: context, verification, economics, and codebase structure.
- Human judgment at scale. Explain why people still have to judge what to build and whether AI-produced changes advance the product.
- Monday Morning Baseline. Describe the six checks to make in an active repository: write a short AGENTS.md, time CI, check test verdict reliability, identify one dormant project, count iterations on recent agent-generated PRs, and compare merged PRs with those a human read. Explain how the stated thresholds point to work to prioritize.
- Infrastructure Gap And Compounding Returns. Explain why the section calls the difference between using AI and gaining leverage an infrastructure gap rather than a model gap. Describe how shared context, navigable dependencies, fast reliable feedback, honest tests, and scalable review make improvements pay off across later PRs and agents.
What it builds on
- Building context together with LLMs (chapter 3) · Assumes the value of supplying context to LLMs.
- From .cursorrules to AGENTS.md (chapter 5) · Assumes familiarity with repository-level agent instructions such as AGENTS.md.
- Context rot: is too much context a bad thing? (chapter 3) · Builds on the earlier concern that excessive context can be harmful.
- The real cost of a development team's AI stack (chapter 9) · The distinction between an AI stack’s subscription price and its broader team cost.
- Key shift: tests describe intent, not implementation (chapter 8) · The distinction between tests that describe intent and tests that reflect implementation.
- Mutation testing: testing your tests (chapter 8) · Mutation testing as a way to challenge a test suite.
- The rebound effect (chapter 9) · The earlier rebound-effect discussion provides the cost-side comparison for the section's throughput analogy.
- Swarm of agents and orchestration (chapter 5) · The idea of coordinating agents rather than treating each coding task as an individual’s work.
Section by section
Introduction
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.
- Project context versus system context: Explain why an agent that is competent within one project can make mistakes across a system of services: it may know its project's files and conventions but lack shared constraints and changes elsewhere.
Why it matters: An agent can produce a locally valid change that is wrong for the wider system. - Infrastructure cost at agent scale: Explain the introduction's claim that effective agent infrastructure builds on practices already useful to human developers, while AI agents make poor infrastructure more costly.
Why it matters: Improving the environment that supports developers also helps agents work reliably at team scale.
Key terms: project context, system context, context fragmentation, infrastructure, human developer productivity, agent throughput
10.1 The context fragmentation problem
This section shows why well-configured agents can still make systemically wrong changes when repository boundaries hide cross-service context, and why delivering the right amount of context matters.
- Locally correct systemic mistakes: Explain how an agent with strong context inside one repository can produce locally valid code that violates rules or relationships elsewhere in the system.
Why it matters: A clean change in one service may still be unsafe for the wider system. - Context vacuum and flood: Distinguish missing system context from overwhelming an agent with too many tools, and describe the section's example of selecting a relevant subset before generation.
Why it matters: Useful context must reach the agent without burying it in irrelevant options. - Repository boundaries as context delivery: Explain why the section treats repository topology as an agent-experience decision, contrasting co-located services with scattered repositories.
Why it matters: Where code lives changes how much system context an agent can readily use.
Key terms: Context Fragmentation Problem, AGENTS.md, cross-service context, token paralysis, vacuum, flood, deterministic orchestrator, repository topology, repository boundaries, context gap
10.1.1 Monorepo as a context delivery mechanism
This section explains how monorepo-like organization gives AI agents searchable system context, machine-readable relationships, and shared rules, while offering a meta-repository as a lower-cost alternative to full consolidation.
- Shared Repository Search Space: Explain how a monorepo differs from a monolith or a multi-repo arrangement, and why its shared search space helps an agent understand services across project boundaries.
Why it matters: A shared search space lets an agent discover connections that would otherwise require someone to point it to another repository. - Queryable Dependencies And Enforced Rules: Describe why a useful monorepo needs both a queryable dependency graph and conventions enforced by root-level tooling, rather than merely putting projects in folders.
Why it matters: Code being colocated is not enough if the agent cannot query relationships or follow enforceable rules. - Monorepo Audit And Meta-Repository: Apply the section's three-property audit to an existing monorepo and describe how a meta-repository can supply shared context without immediately migrating every service.
Why it matters: Teams can make relationships legible to agents without treating a full monorepo migration as the only option. - Hierarchical Agent Context: Describe how root and package-level AGENTS.md files divide system-wide and local context, and where historical and operational context comes from.
Why it matters: The hierarchy gives an agent an overall map without losing the details specific to the package it is working on. - Monorepo Adoption Trade-Offs: Explain why monorepo-like ergonomics are the aim rather than a mandatory full monorepo, citing costs that can make consolidation inappropriate.
Why it matters: The goal is useful agent context, not a costly repository migration for its own sake.
Key terms: monorepo, multi-repo, single search space, unified dependency graph, convention enforcement at the root, One-Version Rule, meta-repository pattern, dependency map, ADR index, nested AGENTS.md
10.2 The navigation and blast radius problem
An agent’s difficulty finding the right code in a large repository is an information problem that wastes tokens and developer review time.
- Ambiguous Codebase Navigation: Explain why the agent chose the wrong checkout package and why the section calls this an information failure rather than a reasoning failure.
Why it matters: A plausible code choice can still be wrong when the repository does not make a package’s status clear. - Structural Navigation Costs: Describe what agents lack when navigating by individual files rather than a map of the codebase, and trace the cost of searching and backtracking.
Why it matters: Navigation failures cost more than tokens when engineers must catch and correct work done in the wrong place.
Key terms: production code, abandoned experiments, information failure, topology, dependency arrows, navigation time, input tokens
10.2.1 The second failure mode: blast radius
This section shows how an agent can make a correct-looking change that breaks downstream services when the change and its checks are scoped to one package rather than its dependents.
- Hidden blast radius of changes: Explain why a change that passes its own package’s tests can still break consumers, using the shared-utils example, and relate this failure to the agent’s lack of dependency-graph awareness.
Why it matters: A locally correct PR can still cause an outage in a service that depends on the changed package.
Key terms: blast radius, dependency graph, consumers, shared-utils
10.2.2 The dependency graph as the agent's GPS, and safety net
The section shows how agents can use a build-system dependency graph to navigate a codebase and test the effects of a change, provided the graph’s status tags are kept trustworthy.
- Project Graph Navigation: Explain how build configuration gives an agent a queryable map of packages and helps it select the active package rather than guess from file names.
Why it matters: A queryable project map helps an agent work in the right package before it edits anything. - Reverse Dependency Blast Radius: Trace how an agent uses reverse dependencies after an edit to identify affected consumers and test them before submitting a PR.
Why it matters: Testing affected consumers can reveal a breakage that tests for the edited package would miss. - Enforced Status Tag Accuracy: Explain why package status tags need machine-backed checks and describe the safeguards used to keep them accurate.
Why it matters: Agents can act confidently on false metadata, so keeping tags accurate is part of making graph-based navigation safe.
Key terms: project graph, BUILD files, status:production, reverse-dependency query, rdeps, blast radius, affected packages, status tag, status:deprecated, CODEOWNERS
10.2.3 Strict deps as contract enforcement
The section explains how strict dependency enforcement makes the dependency graph reliable enough for agents to use when assessing a change’s blast radius.
- Strict dependency graph contract: Explain why an agent cannot rely on a reverse-dependency query when code can import undeclared dependencies, and how strict deps prevents that failure.
Why it matters: An agent’s blast-radius checks are only as trustworthy as the dependencies its build system can see. - Upfront enforcement trade-off: Justify the effort of enabling strict deps in terms of the hidden dependencies and ongoing problems it exposes.
Why it matters: The tedious cleanup pays for a graph that agents can treat as a contract rather than a suggestion.
Key terms: strict deps, strict transitive dependency enforcement, declared dependency, dependency graph, blast radius, BUILD file, implicit transitive dependencies, path-hack imports, circular dependency workarounds
10.2.4 Target granularity: reasoning boundaries and build boundaries
This section explains how fine-grained build targets speed up validation and give coding agents clearer boundaries for changes, while adding maintenance work.
- Granular Builds and Tests: Explain why smaller build targets let the build system rebuild less code and run fewer tests after a change, rather than rebuilding and retesting an entire service.
Why it matters: Target size determines how much validation work each small change triggers. - Agent Reasoning Boundaries: Explain how a target boundary narrows what an agent needs to understand and changes the scope of dependency and blast-radius information. Describe the maintenance tradeoff of having more targets.
Why it matters: Clear target boundaries help an agent stay focused and help the team see what a change may affect.
Key terms: target granularity, build targets, finer-grained targets, reasoning boundary, immediate dependencies, blast radius, reverse-dependency results, BUILD files
10.2.5 Beyond static documentation: the build system as agent collaborator
The section explains how live build-system metadata can reduce the gap between static agent instructions and a changing codebase.
- Static context gap: Explain why AGENTS.md and a documented dependency graph can become insufficient context for an agent in a frequently changing codebase.
Why it matters: An agent can follow its instructions yet still work from an outdated picture of the workspace. - Live build context: Describe how exposing build-system metadata through an MCP server changes the build system's role for an agent.
Why it matters: Current, queryable workspace information can guide an agent's choices during a change. - Integration and adoption trade-off: Describe the section's concrete Nx example and why Marcus uses auto-generated documentation instead of live MCP integration for now.
Why it matters: The example separates a working live integration from a practical interim way to keep static instructions fresher.
Key terms: AGENTS.md, dependency graph, static, context gap, build system metadata, MCP servers, live query interface, build graph, agent skills, Nx
10.2.6 The organizational cost of coherence
Strict dependencies make a monorepo more coherent for agents, but impose coordination costs on teams.
- Organizational price of coherence: Explain why a monorepo with strict dependencies creates friction between teams and why the section considers that friction worthwhile for agents.
Why it matters: The coordination cost buys agents a trustworthy picture of how changes affect the codebase.
Key terms: monorepo, strict deps, coherence, dependency graph, blast radius
10.3 The throughput wall
This section shows how agent-driven development can overwhelm a CI pipeline and how slow feedback compounds into lower productivity and higher cost.
- Agent Cadence and CI Capacity: Explain why a CI pipeline that worked for a human development cadence can become a bottleneck when agents produce PRs much faster.
Why it matters: A pipeline that feels fast enough for people may not keep up with the volume of agent-assisted work. - Compounding Cost of Slow Feedback: Explain how waiting for CI can make agent iterations more expensive and less focused, and why faster feedback changes the time needed to converge.
Why it matters: Fast feedback helps agents avoid spending time and context on work that a test result could already have ruled out.
Key terms: throughput wall, CI, PRs, human commit cadence, context window, CI latency, Feedback Multiplier, iterations
10.3.1 Where the agent runs matters more than how fast it runs
This section shows how an agent’s execution environment and a codebase’s build structure can limit reliability and parallel throughput more than the agent’s coding speed.
- Environment mismatch failure chain: Trace how an agent sharing a developer’s local environment can produce a bug when it iterates against CI. Explain why repeated environment mismatches become a team-scale quality problem.
Why it matters: A passing local test can mislead an autonomous agent when its environment differs from CI’s. - Modular builds for agent throughput: Explain why many agents compiling the same monolithic project can be limited by disk I/O, and how independent modules change the work required when agents edit different parts of the codebase.
Why it matters: Independent build units let parallel agents spend less time waiting on shared build work.
Key terms: non-hermetic builds, CI, local environment, disk I/O, self-contained crates, compilation unit, cache key, agent throughput
10.3.2 Hermetic sandboxes: same source, same config, same result
This section explains how isolated agent environments and a validation gate prevent environment mismatches and keep unfinished agent work out of the review queue.
- Hermetic build reproducibility: Explain how isolated, hermetic execution prevents environmental divergence between an agent's build and CI.
Why it matters: An agent can trust its checks instead of chasing failures caused by differences between its environment and CI. - Practical sandbox preparation: Describe how pre-warming and incremental isolation make agent sandboxes fast and safer to use.
Why it matters: Teams can reduce wasted agent iterations and accidental external effects without building Stripe's VM infrastructure first. - Private iteration and review gate: Explain why agents should iterate privately and pass verification before their work becomes a pull request for human review.
Why it matters: Keeping failed attempts private prevents half-finished agent changes from overwhelming human reviewers.
Key terms: hermetic, sandbox, environmental divergence, pre-warmed, Docker containers, per-project scoped credentials, network isolation, verification service, CI, PR
10.3.3 Remote caching: the more agents you run, the faster everyone goes
This section explains how remote build caching lets agents reuse compiled artifacts, reducing build time and the team-wide cost of iteration.
- Shared build artifact reuse: Explain how remote caching differs from rebuilding from scratch or using a local cache, and how an agent can reuse an artifact compiled by another agent.
Why it matters: Shared artifacts can eliminate repeated compilation across agents working on different features. - Team scale caching economics: Explain why running more agents can make a shared cache more useful and how that affects the build portion of Cost-per-Iteration, while distinguishing verification from automatic cache reuse.
Why it matters: The savings emerge at team scale, but faster builds do not automatically solve verification cost.
Key terms: local caching, remote caching, shared cache, compiled artifact, Cost-per-Iteration, CPI, warmer cache, verification
10.3.4 Progressive validation: not every iteration needs full verification
This section explains how progressive validation gives coding agents fast feedback without running every test on every iteration, and when to stop unsuccessful retries.
- Local checks as queue management: Explain why agents run fast local linters before sending changes to CI: catching trivial failures locally preserves CI capacity for other agents.
Why it matters: Fast local feedback helps the whole team iterate, not just the agent making the change. - Dependency-based selective CI: Describe how selective CI uses changed files and the dependency graph to run relevant tests rather than the entire suite, and how CI can apply and re-run straightforward autofixes.
Why it matters: Agents can get useful test feedback without waiting for millions of unrelated tests. - Hard cap on agent retries: Explain why the validation loop limits an agent's attempts to fix a failed test and escalates persistent failures to a human.
Why it matters: A retry limit prevents expensive agent loops from continuing when a human is more likely to resolve the problem.
Key terms: Tier 1, local linters, CI slot, Tier 2, selective CI, dependency graph, autofixes, Tier 3, pragmatic cap, diminishing returns
10.3.5 Module architecture as throughput investment
This section explains how splitting a service into independent build modules lets concurrent agents compile changes faster without competing over the same build work.
- Module boundaries and agent throughput: Explain why independently compilable modules improve throughput when multiple agents work on a service. Describe how module boundaries limit rebuilds and allow changes in different modules to build concurrently.
Why it matters: Module design can determine how much work a team of concurrent agents can complete, not just how the code is organized.
Key terms: module boundaries, build targets, compilation units, cache keys, I/O contention
10.3.6 The 4x hidden tax
This section shows why AI coding costs extend far beyond licenses and why faster agent workflows require a measured, long-term infrastructure investment.
- Full cost of agent operations: Explain the four cost categories of team-scale AI coding—licenses, compute, tokens, and review overhead—and why a license budget understates the total. Use Marcus’s example to illustrate why a team should calculate its own cost ratio rather than assume a universal one.
Why it matters: A license-only budget can miss the largest costs of running agents across a team. - Compressible compute and token costs: Describe how model routing and build infrastructure can reduce operating costs, and explain why a shared remote cache becomes especially valuable when many agents work on a team.
Why it matters: Shared build work and task-appropriate models can keep faster agent iteration from driving costs up unnecessarily. - Infrastructure investment and payback: Justify throughput infrastructure as an upfront investment using the section’s account of Marcus’s build-out, monthly costs, and measured savings.
Why it matters: A quantified payback case makes it possible to weigh infrastructure work against the features a team postpones to build it.
Key terms: license, compute, tokens, review overhead, hidden tax, model routing, remote caching, incremental builds, throughput infrastructure, capital investment
10.4 The lying oracle
This section shows how flaky CI tests can mislead a coding agent into unnecessary changes, creating costs far beyond the extra test runs and tokens.
- Flaky CI as false feedback: Trace how a flaky test failure can lead an agent to invent a cause, make an unnecessary fix, and treat a later passing run as proof that the fix worked.
Why it matters: Fast feedback is not useful if an agent mistakes unreliable feedback for evidence that its changes are correct. - Cascading changes and cleanup costs: Explain how the date-formatting example grew into repeated changes outside the task, and why the resulting human cleanup and loss of trust mattered more than the token bill.
Why it matters: A misleading test can turn a small task into both new bugs and expensive review work.
Key terms: flaky tests, CI, oracle, false causal chain, context window, date formatting utility, flaky integration test, retry logic, tokens, human cleanup
10.4.1 The three lies
The section explains how flaky tests, circular tests, and agent shortcuts can make a green CI pipeline an unreliable signal, especially across a monorepo.
- Circular tests and false confidence: Explain why tests written by the same agent that wrote the code can pass while the behavior is wrong, and how an independent requirement-based check addresses that gap.
Why it matters: Passing tests provide little confidence if they reproduce the code’s misunderstanding of the requirement. - Agent shortcuts to green CI: Describe how an agent can make CI pass by removing or weakening checks instead of correcting code, and why the green checkmark cannot distinguish those outcomes.
Why it matters: A passing pipeline is not proof of correctness if an agent can change the checks themselves. - Flaky tests as visible lies: Describe the visible cost of a flaky test and what happens when that test sits in a shared library.
Why it matters: A single unreliable test can waste work well beyond the team that owns it. - Dependency graph blast radius: Explain why the monorepo dependency graph magnifies the effects of unreliable tests and weakened checks.
Why it matters: The more code relies on a module, the more widely a misleading CI result can affect decisions.
Key terms: circular tests, specification, acceptance tests, agent shortcutting, green CI, lying oracle, flaky test, token logs, shared library, monorepo
10.4.2 Fix the lies before you fix the speed
This section explains why reliable test feedback must come before faster agent iteration and shows how to make that feedback more trustworthy.
- Test reliability before speed: Explain what TORS measures and why improving test reliability should precede speeding up CI for agents.
Why it matters: Fast CI helps agents only when its results are worth trusting. - Acceptance tests versus agent tests: Distinguish what agent-generated unit tests and human-written or ticket-derived acceptance tests verify when an agent changes business logic.
Why it matters: Passing tests written around an agent's own interpretation does not establish that the product requirement was met. - Flaky test visibility and quarantine: Describe how Marcus identified flaky tests and kept them from wasting agent iterations while they were being fixed.
Why it matters: A small number of visible, unreliable tests can account for a large share of wasted agent work. - Mutation testing for circular tests: Explain how mutation testing exposed tests that mirrored the implementation and why Marcus rewrote them against the product specification despite lower coverage.
Why it matters: Coverage can look strong even when tests fail to detect incorrect behavior. - Checks against agent shortcutting: Describe the test integrity checks Marcus added and explain why shortcutting must be checked explicitly.
Why it matters: A green CI result is misleading if an agent obtained it by disabling or weakening the checks. - Limits and diagnosis of retries: Explain how a two-round cap limits blind retries and how self-healing CI offers more useful failure feedback.
Why it matters: Limiting unproductive retries and explaining failures can keep agents from spending iterations guessing.
Key terms: TORS, Test Oracle Reliability Score, test oracle, flakes, agent-generated unit tests, human-written acceptance tests, ticket-derived acceptance test, specification-level check, flaky tests, dashboard
10.5 The review bottleneck
The section explains why faster agent-generated code can overwhelm human review, why polished output still needs judgment, and why sanctioned AI tools are preferable to hidden use.
- Approval Queue Paradox: Explain how agent-assisted PR production can exceed reviewers’ capacity, causing a growing backlog and turning careful review into superficial approval.
Why it matters: More generated code is not more useful throughput if meaningful review cannot keep up. - Selective Human Review: Justify changing which PRs reach human reviewers instead of simply hiring more reviewers or asking senior engineers to review faster.
Why it matters: Scarce senior-engineer attention should go to changes where informed judgment matters. - Polish Versus Sound Judgment: Distinguish an agent-generated PR's polished surface from the soundness of its underlying reasoning, and describe what the remaining human review should assess.
Why it matters: A professional-looking PR can still contain a decision that is wrong for the system. - Provision Over Prohibition: Explain why banning desired AI tools can drive their use out of sight, and why providing sanctioned tools with audit trails is the preferred response.
Why it matters: A review and governance pipeline cannot account for AI use that the organization has pushed underground.
Key terms: Approval Queue Paradox, review queue, human review, context, plausibility, quality, architecture, intent, Shadow AI, sanctioned tools
10.5.1 Lint-as-architecture: encoding what you know
The section shows how turning implicit architectural review criteria into executable checks can reduce the human PR review queue.
- Executable architectural rules: Explain why architectural expectations that human reviewers have internalized must be encoded as automated checks for agents.
Why it matters: An unwritten rule cannot reliably keep an agent-generated change out of the review queue. - Bug to lint rule pipeline: Describe how the team turns a recurring architectural violation into a lasting check.
Why it matters: Fixing the code addresses one PR; codifying the violation protects later PRs. - Accumulating review benefits: Explain how accumulated rules change agent submissions and the work left for human reviewers.
Why it matters: The aim is not to eliminate human judgment but to reserve it for decisions automated rules cannot make.
Key terms: lint-as-architecture, architectural rule, automated checks, Bug → Codify → Lint Rule, architectural check, institutional knowledge, AGENTS.md, lint config, review queue
10.5.2 Green/Yellow/Red: making auto-merge trustworthy
This section explains how risk-based auto-merge policies can reduce review volume without ignoring blast radius, defects, or reviewer workload.
- Contextual merge risk: Explain why a PR's Green, Yellow, or Red classification depends on the module and the change's risk, not just diff size. Contrast a leaf notification service with a widely used core library or financial logic.
Why it matters: Contextual classification keeps a small but consequential change from slipping through auto-merge. - Evidence-based Green promotion: Describe the conditions a PR must meet for Green auto-merge and how Marcus expanded that bucket using observed review outcomes and production defects.
Why it matters: An enforceable quality bar and evidence from actual outcomes make auto-merge more trustworthy than an optimistic threshold. - Sustainable reviewer workload: Explain why reducing the queue through auto-merge did not by itself solve the review bottleneck, and describe Marcus's changes to reviewer duty and the Green-rate target.
Why it matters: The process must free engineers to improve the system, not merely turn them into permanent approvers.
Key terms: Green, Yellow, Red, blast radius, downstream consumers, Green bucket, auto-merge, triage thresholds, escape rate, clean approvals
10.5.3 Compound interest on governance
The section explains when Green auto-merges pay off, why avoided reviews represent released capacity rather than cash savings, and how measured improvements to automated checks compound over time.
- Green Auto-Merge Economics: Explain how review costs and the cost of escaped defects set a minimum accuracy for Green auto-merges, using the section’s example.
Why it matters: The Green bucket is worthwhile only if its measured escape rate is low enough to justify skipping reviews. - Released Capacity Versus Savings: Distinguish avoided review costs from actual cash savings or product gains, and describe how to judge the value of the capacity released.
Why it matters: Counting freed time as money saved can hide whether automation improved the team’s actual outcomes. - Empirical Green Calibration: Describe how to expand the Green bucket through observed approvals and stronger automated checks rather than relaxed standards.
Why it matters: Evidence-based calibration lets the team automate more reviews without treating lower standards as progress.
Key terms: Green, auto-merge, escape, accuracy, avoided review time, senior capacity, capacity released, avoided-cost figures, Green bucket, automated checks
10.6 The night shift and the production feedback loop
This section introduces the Dead Project Problem: valuable but neglected software remains in use while deferred modernization lets its risks grow.
- Dead Project Risk: Explain why a service can still provide business value while becoming a growing liability, and why teams keep postponing its modernization.
Why it matters: A working service can become harder and riskier to change even when it never makes the feature roadmap.
Key terms: Dead Project Problem, tech debt, graveyard
10.6.1 Continuous modernization: making the dead walk
This section shows how agents can turn neglected code migrations into continuous background work when they can navigate dependencies, run targeted tests, and route changes by risk.
- The migration long tail: Explain why library upgrades can remain unfinished even when major consumers migrate quickly, and how AI-assisted migration addresses the remaining consumers.
Why it matters: The hardest part of a codebase-wide migration may be the consumers no active team gets around to upgrading. - The Night Shift workflow: Trace how the Night Shift agent selects, tests, and routes dependency upgrades while the team is away.
Why it matters: Background modernization is useful only if routine changes can proceed without blocking developers and changes needing judgment reach a reviewer. - Dependency graph as coordinator: Explain how a queryable dependency graph lets an agent coordinate upgrades across services and why existing development infrastructure makes repeated modernization practical.
Why it matters: A cross-service upgrade becomes repeatable background work when the agent can find affected consumers and validate them economically.
Key terms: Fleet Management, Honk, long tail, migration target, Night Shift, sandbox, selective testing, Green/Yellow/Red triage, complexity threshold, queryable dependency graph
10.6.2 The open loop: production knows what's broken
The section explains why production signals and development context must be connected so agents can prioritize and eventually act on real operational problems.
- Open production development loop: Explain why the production-to-development feedback loop remains open even when the same engineers write and operate a service, and why that gap matters for agents.
Why it matters: Putting production signals within an agent’s reach lets its work respond to what is actually failing. - Production guided agent maturity: Describe how closing the loop progresses from using incident data to prioritize work, through proactive investigation and verified fixes, toward a fully autonomous feedback loop.
Why it matters: Production evidence can direct agent effort toward consequential problems rather than merely convenient upgrades.
Key terms: open loop, production telemetry, agent context, systematic, optimized, autonomous, Night Shift, canary
10.6.3 Where all the pillars converge
Explains why an overnight Continuous Modernization fleet depends on the whole development system, and how to pilot and measure it.
- Continuous Modernization prerequisites: Explain why the Night Shift depends on shared context, dependency-aware navigation, fast isolated feedback, reliable tests, and tiered review rather than operating as a standalone automation trick.
Why it matters: Automating more changes magnifies weaknesses in the system around the agents. - Small pilot and system measurement: Describe the recommended starting point for the Night Shift and what to examine before scaling it.
Why it matters: A small pilot reveals whether the pipeline is ready before an overnight fleet creates problems at scale. - CI as the ratchet: Explain the Brownian Ratchet analogy for parallel modernization agents and CI's role in it.
Why it matters: The analogy shows why useful progress depends on verifying changes, not on perfectly coordinating every agent attempt.
Key terms: Continuous Modernization, Night Shift, shared context, dependency-aware navigation, fast isolated feedback loops, reliable tests, cost per change, ROI, team-scale infrastructure, Brownian Ratchet
10.7 Measuring what matters at team scale
The section shows why faster agent-driven code activity can make engineering dashboards look healthier without improving feature delivery or accounting for freed engineering time.
- Human Cadence Metrics: Explain why traditional DORA metrics can be misleading when applied to agent-driven development, especially when interpreting deployment frequency.
Why it matters: A green dashboard can mislead a team if its metrics are interpreted as though agents ship changes like humans do. - PR Volume Versus Value: Explain how PR throughput can rise sharply while customer-facing feature delivery stays flat, including the effect of agents splitting work into smaller changes.
Why it matters: Counting completed changes without checking what they deliver can mistake more motion for more progress. - Unaccounted Review Capacity: Describe why freed senior engineering review time needs to be accounted for, distinguishing a legitimate delayed infrastructure payoff from capacity that produces no identifiable result.
Why it matters: Recovered engineering time is only a meaningful gain if the team can explain what that capacity enables.
Key terms: DORA metrics, deployment frequency, human commit cadence, PR throughput, activity metric, productivity paradox, Jevons paradox, feature velocity, released review capacity, Green bucket
10.7.1 The metrics that actually matter
This section shows how six team-level metrics reveal whether coding agents are succeeding efficiently, receiving reliable feedback, and moving through review without compromising quality.
- Iterations to Success by Module: Explain what Iterations-to-Success (ITS) counts and why tracking it per module helps locate problems that a team-wide average could hide.
Why it matters: Module-level ITS tells you where to investigate before assuming every agent needs improvement. - Cost per Iteration Returns: Describe what Cost-per-Iteration (CPI) indicates and how shared remote caching can lower it as more agents use the system.
Why it matters: A falling CPI makes the economic benefit of shared infrastructure visible. - Tail CI Feedback Latency: Explain why CI Feedback Latency is tracked at P50, P95, and P99 rather than judged only by its typical value.
Why it matters: Tail latency reveals delays that a fast-looking median can mask. - Test Oracle Reliability Monitoring: Explain how per-module Test Oracle Reliability Score (TORS) is used to catch unreliable test feedback before agents waste iterations.
Why it matters: Agents need dependable test results, not merely a test suite that runs. - Auto Approval and Escapes: Distinguish Auto-Approve Rate from escape rate and explain why both matter when expanding Green triage.
Why it matters: More auto-merging helps only if the team also watches for defects that slip through. - Post CI Merge Queue Delay: Explain what Merge Queue Wait Time measures and how it identifies a review bottleneck that fast CI cannot solve.
Why it matters: Fast CI does not help throughput enough if approved changes still wait hours for a reviewer.
Key terms: ITS, Iterations-to-Success, CI round-trips, AGENTS.md, CPI, Cost-per-Iteration, remote caching, CI Feedback Latency, P50, P95
10.7.2 The metric nobody tracks, and everybody needs
The section argues that AI development costs should be measured per customer-facing feature, including expenses hidden by subscription and PR-level metrics.
- Cost per feature: Explain why cost-per-feature is more meaningful than cost-per-PR or PR throughput, and describe how costs from multiple PRs can be rolled up to a feature.
Why it matters: It connects AI spending to delivered customer capabilities rather than the volume of development activity. - Full AI cost breakdown: Describe the four cost lines in Marcus's dashboard and explain why subscription spending alone cannot answer whether AI is paying off.
Why it matters: A payoff calculation is misleading if it leaves out compute, API usage, and human review.
Key terms: cost-per-feature, feature epic, PR throughput, 4x Hidden Tax, license cost, compute cost, token cost, review overhead
10.8 What remains when AI writes all the code?
This section reframes AI coding productivity as a question of whether the surrounding engineering system can turn generated code into team-level results.
- AI capability and engineering chassis: Explain why widespread AI-generated code does not by itself demonstrate improved productivity or business results, and describe the engineering layers the section says must support agents.
Why it matters: It separates an agent's ability to produce code from a team's ability to benefit from that code.
Key terms: Ferrari engine in a Fiat 500, context engineering, verification infrastructure, cost awareness, codebase architecture
10.8.1 What doesn't change
The section argues that AI can automate writing code, but engineers must still exercise judgment about what to build and make that judgment clear enough for many agents to follow.
- Code as a decision artifact: Explain why code is the expression of problem-solving decisions rather than the point of engineering, and why writing it has also helped developers think those decisions through.
Why it matters: It helps distinguish faster code production from better engineering. - Human judgment under automation: Distinguish implementation tasks AI can perform from the judgment questions engineers must answer, and explain why faster implementation increases the consequences of a wrong decision.
Why it matters: A quickly implemented answer can still be the wrong answer, and other fast-moving work may depend on it. - Ambiguity at agent scale: Explain how unclear specifications and implicit conventions become structural risks when many agents act on them at once.
Why it matters: Clear constraints matter more when many agents can repeat and multiply a misunderstanding.
Key terms: artifact, receipt, think through code, judgment questions, trade-off, architectural decision, multi-agent systems, implicit convention, structural risk, architectural drift
10.8.2 The tech lead's job, rewritten
The section recasts the tech lead’s work as designing and improving the environment in which agents produce code, rather than personally writing the hardest code.
- Tech lead leverage shift: Explain how the tech lead’s leverage shifts from writing and reviewing difficult code to defining agent tasks, reviewing consequential output, and designing the infrastructure and verification that make others’ agents effective.
Why it matters: It identifies where a tech lead can have the greatest effect when agents do much of the coding. - Agent guidance and risk decisions: Describe how a tech lead uses shared agent guidance and module-level review thresholds to prevent repeated mistakes and decide which changes may be auto-merged. Explain why promoting patterns to Green requires evidence and architectural judgment.
Why it matters: A decision recorded once can improve many agents’ iterations without treating every module as equally safe. - Delayed and compounding returns: Explain why this systems work is harder to assess quickly than coding and how improvements to agent guidance, boundaries, and verification can keep paying off across future changes.
Why it matters: It explains why less immediately gratifying work can have greater long-term leverage than completing another coding task.
Key terms: Tech Lead, agents, Software Factory, AGENTS.md, Green/Yellow/Red thresholds, auto-merge, blast radius, feedback loop, systems work, CI pipeline
10.8.3 The uncomfortable truth about this book
This section distinguishes rapidly changing AI tools from the enduring engineering disciplines and human judgment needed to use them well.
- Durable discipline beneath changing tools: Explain why the book's specific tool advice may age while its underlying engineering discipline remains useful.
Why it matters: It helps you carry the book's lessons forward when today's tools disappear. - Enduring engineering constraints: Describe the recurring constraints the authors say remain important despite smarter models: context, verification, economics, and codebase structure.
Why it matters: Faster code generation does not remove the conditions that make that code useful, trustworthy, and sustainable. - Human judgment at scale: Explain why people still have to judge what to build and whether AI-produced changes advance the product.
Why it matters: A high volume of completed changes is valuable only if someone judges that they serve the product.
Key terms: discipline, tools, context is infrastructure, verification, economics, codebase structure, judgment, judgment at scale, Night Shift
10.8.4 Your Monday morning
The section gives teams a Monday-morning starting point for measuring agent-workflow bottlenecks and argues that lasting AI leverage comes from engineering the surrounding system, not upgrading the model.
- Monday Morning Baseline: Describe the six checks to make in an active repository: write a short AGENTS.md, time CI, check test verdict reliability, identify one dormant project, count iterations on recent agent-generated PRs, and compare merged PRs with those a human read. Explain how the stated thresholds point to work to prioritize.
Why it matters: These measurements turn a broad ambition to improve agent workflows into specific work your team can begin now. - Infrastructure Gap And Compounding Returns: Explain why the section calls the difference between using AI and gaining leverage an infrastructure gap rather than a model gap. Describe how shared context, navigable dependencies, fast reliable feedback, honest tests, and scalable review make improvements pay off across later PRs and agents.
Why it matters: It explains why fixing the system around agents can deliver more durable gains than changing models. - Human Engineering Responsibility: State what remains the team's responsibility as AI writes more code: judging what to build and engineering the system that builds it well, through incremental changes rather than a purchase.
Why it matters: It keeps responsibility for direction and engineering quality with the team even as code generation becomes easier.
Key terms: AGENTS.md, CI pipeline, TORS, ITS, agent-generated PRs, infrastructure gap, shared context, dependency graph, hermetic feedback, honest tests
10.9 Summary
Concepts explained in this chapter
- dependency graphA dependency map is a structured record of which software services depend on or communicate with one another.
- flaky testA flaky test is an automated test that intermittently passes or fails without a corresponding change in the behavior being tested.
- build systemA build system is software that determines how source code is compiled, packaged, tested, and incrementally rebuilt from declared dependencies.
- lint-as-architectureLint-as-architecture is the practice of expressing architectural knowledge as executable checks that fail when prohibited structures or dependencies appear.
- AGENTS.mdAGENTS.md is a tool-agnostic convention for a repository-root Markdown file that supplies project context and instructions to AI agents.
- circular testA test whose validity depends circularly on the implementation or other tests rather than independently checking required behavior.
- remote cachingRemote caching stores reusable build or computation results in a shared remote cache so other users or machines can retrieve them.
- test oracle reliability scoreTest oracle reliability score is the percentage of test outcomes that correctly indicate whether the tested behavior is acceptable.
- code reviewThe manual examination of proposed source-code changes to identify defects, risks, and conformance or maintainability problems before integration.
- monorepoA monorepo is a single version-controlled repository containing multiple independently deployable software projects managed with shared build configuration and conventions.
- auto-mergeAuto-merge is the automated integration of a proposed code change once its required conditions and checks have passed.
- acceptance testingA test that evaluates whether a system or feature satisfies product-level requirements from a user's or stakeholder's perspective.
- 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.
- lint ruleA lint rule is a configured static-analysis condition that identifies source-code style, correctness, or maintainability issues.
- verificationThe systematic evaluation of an implementation or output against specified requirements and expected behavior.
- self-healing CIA continuous-integration approach in which the system diagnoses failures and proposes or applies corrective changes.
- continuous integrationContinuous integration is the practice of frequently merging changes into a shared codebase and automatically building and testing them.
- judgmentHuman judgment is the reasoning and decision-making people apply when evaluating situations, evidence, risks, and software changes.
- auto-merge rateThe percentage of pull requests that are integrated automatically rather than through human review.
- 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.
- 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.
- 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.
- blast radiusA blast radius is the extent of systems, data, or operations that can be affected by a failure or harmful action.
- continuous improvementA feedback loop is a pattern in which information about an output or system state is fed back into subsequent evaluation or action.
- mutation testMutation testing evaluates a test suite by introducing small controlled changes into code and checking whether the tests detect them.
- 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.
- repositoryA repository is a version-controlled project store containing source code, configuration, and recorded change history.
- 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.
- 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.
- green classificationA change-risk classification that permits a pull request to be merged automatically when all required safety conditions are met.
- iterations-to-successThe number of continuous-integration revision cycles required for an agent-generated change to reach an acceptable, merge-ready result.
- environmental divergenceAn environmental divergence bug is a defect caused by differences between software execution or build environments.
- meta-repositoryThe meta-repository pattern maintains a dedicated repository of cross-repository dependency, communication, convention, and decision knowledge for agents.
- continuous modernizationContinuous modernization is the ongoing automated or systematic improvement of a codebase's technologies, structure, and maintainability.
- progressive evaluationProgressive validation is a staged verification approach that applies increasingly costly checks only when earlier checks pass or indicate they are needed.
- 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.
- system contextSystem context is persistent information about a software system's architecture, schemas, and service topology.
- agent shortcuttingAgent shortcutting is the practice of changing or bypassing verification conditions to obtain a passing automated result without correcting the underlying software behavior.
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.
