Concept

• Agentic Autonomy Telemetry - Three delivery indicators — autonomy rate, human touchpoints, and verification latency — that keep the volume of agent-generated code auditable by pairing it with specification-first governance.
• Agentic Linearism - Execute agentic code synthesis as an uninterrupted linear pass against a complete, frozen specification rather than human-style iterative micro-sprinting.
• AI Productivity Paradox - Responsible AI use costs verification time, but perceived productivity rewards skipping scrutiny — design harness gates that keep review mandatory.
• Ambiguity Amplification Hazard - Specification ambiguity causes non-linear increases in hallucination and error propagation that large context windows amplify rather than mitigate.
• Ambiguity Tax - The super-linear escalation of agent hallucination probability as specification clarity declines, identifying a 70% clarity threshold below which reliability collapses.
• BDUF in Agentic Engineering - Big Design Up Front returns as a technical prerequisite for agent-driven synthesis, because hours-long generation removes specification obsolescence while ambiguity is punished non-linearly.
• Bottleneck Inversion to Intent Clarity - Long-context coding agents move the binding constraint of software delivery from implementation labor to clarity of intent, relocating engineering discipline upstream into specification and gates.
• Coding as Terminal Rendering - In spec-driven agentic architectures, code synthesis is not an artisanal creative phase, but the automated terminal rendering of formal, machine-readable specifications.
• Cognitive Debt in Agent-Synthesized Code - Behaviorally correct agent-generated code that no human understands well enough to modify by hand, whose repair path runs through specification revision and re-synthesis rather than code archaeology.
• Cumulative Translation Tax - Serial human handoffs from stakeholder to implementer progressively degrade acceptance semantics; machine-readable specifications consumed by agents collapse that relay into one verifiable source of truth.
• Dependency-Graph-Guided Planning - Maintain a repository dependency graph to formulate coordinated multi-file edit plans across complex software projects.
• Downstream Dependent Blind Spot - Editing a function without knowing what else in the codebase depends on its current behavior can silently corrupt callers instead of only under-fixing.
• Entropy Garbage Collection - Agents copy existing patterns, bad ones included, so scheduled background agents should scan for drift from encoded "golden principles" and stale docs, then open small clean-up pull requests.
• GenAI Use Safety Modes - Rank GenAI collaboration from checking your work up through independent complex problem-solving — autonomy rises with risk and oracle demand.
• Grilling the Design Tree - A grilling skill interviews the user in rounds over a design tree, asking the whole frontier of currently answerable decisions with a recommended answer each, finding facts itself, and finishing only when the frontier is empty.
• Guided Code Transformations - Protect repository refactoring against silent semantic drift by capturing invariants in formal specifications and gating changes with regression suites.
• Idiomatic Minimal Patch Preference - Prefer the smallest framework hook that fixes the bug over reimplementing larger APIs — agents often localize correctly then over-build the edit.
• Intention-Implementation Consistency Checking - Deploy specialized agents to audit semantic alignment between documented developer intent and actual source code behavior during automated code review.
• Issue-Grounded Localization - Prefer searches that quote symbols and patterns from the issue text early — speculative filenames burn budget before the agent ever reaches the fix site.
• Maintenance Specification Contracts - Treat compatibility rules, dependency matrices, and verification commands as first-class specification artifacts to bound agent diff generation during repository migrations.
• Me-First Prompt Collaboration - Form your own answer before consulting the model, start with oversimplified prompts, and review outputs with distrust heuristics to avoid anchoring.
• Navigator-Driver Pair Programming - Structure collaborative coding agents into a navigator that explores plans and steers iteration and a driver that synthesizes code and tests locally.
• Out-of-Scope Records - A repository folder of short decision records for rejected feature requests, each with the decision, reason and prior requests, gives agents and triagers durable memory of what the project has deliberately declined.
• Patch Outcome Taxonomy - Classify an applied-but-unresolved code patch by which of the fail-to-pass and pass-to-pass test sets it satisfies — not every non-fix is the same failure.
• Phase Latency Compression - Agents keep the sequential phases and governance gates of the software lifecycle intact while collapsing elapsed time inside each phase, making it cheap to rerun upstream specification work.
• Rigidity–Flexibility Pendulum - Software methodology has swung between documentation fidelity and execution velocity, each pole rational for its era's bottleneck — and agentic synthesis swings it back toward formal specification.
• Scientific Debugging Loop - Structure automated program repair into explicit stages of hypothesis generation, targeted probe validation, conclusion making, and patching.
• Single-Site Edit Blind Spot - A fix that only patches the first matching occurrence of a duplicated pattern can pass the target test yet regress the sibling occurrences it never touched.
• Spec Architect Role - The human role in agentic delivery that captures, formalizes, and governs intent for synthesis agents, replacing manual code authorship with high-fidelity specification and adversarial reasoning.
• Spec Fidelity - The primary quality metric for agentic inputs, evaluating specification completeness, consistency, unambiguity, and verifiability.
• Spec Fidelity Gate - A triage gate between requirement formalization and agentic synthesis that halts execution if specification completeness or consistency falls below safety thresholds.
• Specification Mutation and Selection - Harden agent-generated specifications by applying mutation operators across boundary cases and filtering candidates with verifiable selection heuristics.
• Specification-Governed Operating Model - A gated target operating model that scales agentic throughput through specification quality and verification architecture rather than headcount, with each migration phase earned by measurable gates.
• Synthesis Efficiency Ratio - A steering metric for agentic delivery that measures how compactly a specification converts into working agent-generated code without regeneration loops, retries, or hallucinated scaffolding.
• Synthesis Provenance Tracking - Maintain an immutable audit trail linking synthesized code artifacts to exact specification versions, model routing choices, prompt templates, and verification gate outcomes.
• Tacit Knowledge Erosion Under AI-Assisted Work - Coding and operations agents accelerate the loss of institutional knowledge that engineers used to accumulate as a side effect of personally authoring, debugging, and reviewing their systems.
• Unverifiable Loops Rot - Unattended agent loops degrade a codebase when success cannot be verified, because passing tests does not prove sound architecture; humans belong at leverage points, though high-throughput teams argue for minimal gates.
• Zero-Shot Repository Synthesis - Generate complex, semantically consistent, cross-module feature branches end-to-end from detailed specifications in a single agentic invocation.