Concepts (386)

LLM-driven agents that autonomously write, run, debug and ship code — the primary tool class the corpus examines.

The code, config and execution logic wrapped around a model — prompts, tools, hooks, context management, feedback loops — and the engineering discipline of designing and evolving it.

Coordinating multiple specialized AI agents — planners, generators, evaluators, reviewers — with defined roles, handoffs and adversarial checks to overcome single-agent failure modes.

Why enterprise AI succeeds or stalls: organizational readiness, structural change and legible knowledge matter more than model capability or tooling spend.

Workflow designs that keep a human exercising judgment at defined checkpoints while agents execute autonomously in between.

Hard, automated, non-negotiable constraints placed around nondeterministic AI behavior so outcomes stay within acceptable bounds.

Organization-internal control of agent behavior — identity, authorization, audit trails, policy enforcement and structured evaluation pipelines for AI tools.

The security discipline for autonomous AI agents, whose non-determinism and tool access create attack classes — injection, poisoning, chaining — that deterministic safeguards don't cover.

The slow-accumulating, instantly-losable asset underlying teams, brands and code review — which AI-era development accumulates far slower than it accumulates code.

The per-request cost structure of AI inference and the gap between software-like revenue scaling and infrastructure-like costs — now the binding constraint on AI business models.

How AI reshapes jobs, careers and the developer pipeline — exposure versus replacement, winner-take-most dynamics, and the broken junior on-ramp.

Automated signals — tests, linters, type checks, AI reviews — that let humans and agents detect and correct errors quickly; their quality sets the ceiling on AI-assisted work.

The open protocol standardizing how AI agents connect to external tools, data sources and services, plus the server/gateway ecosystem growing around it.

Distinguishing real AI productivity effects from adoption theater — longitudinal, oppositional and outcome-anchored measurement of what AI actually changes.

The recurring finding that accelerating code production barely moves end-to-end outcomes because the binding constraints are upstream and downstream — understanding, organization, judgment.

Making an organization's tacit work, rules and knowledge explicit and machine-readable — the precondition for AI to compound, and a technology of control that raises legitimacy questions.

The practice of deliberately structuring, selecting and budgeting the information supplied to an AI agent so it can reason and act reliably.

Systematic tests, benchmarks and graded criteria that measure whether AI output meets quality thresholds — the QA discipline of AI systems.

Reusable, markdown-packaged workflows and procedures injected into an agent's context when relevant, encoding expert practice as portable instructions.

Professional software engineering with AI agents doing much of the production while the human applies full expertise in design, review, security and operations — the disciplined counterpart to vibe coding.

Running internal platforms as products — self-service capabilities, clear tenancy, adoption metrics and product ownership — rather than as ticket-driven infrastructure projects.

The batch-and-wait review workflow built on pull requests, its throughput/quality trade-offs, and alternatives that satisfy the same four-eyes control.

Building software by prompting an LLM without reading or owning the generated code — acceptable for disposable software, dangerous as a production practice.

The shared, collective condition where people can admit mistakes, ask questions and challenge the work without fear — a precondition for learning and honest AI adoption.

The timeless design disciplines — deep modules, conceptual integrity, shared vocabulary, simplicity — that matter more, not less, when AI amplifies the cost of bad structure.

AI magnifies whatever already exists — good practices and clear operating models compound, dysfunction and chaos accelerate.

Code that is readable, obvious, correct beyond its tests and fit for its system's real constraints — as distinct from merely compiling and passing.

External governance of AI development — mandatory testing, liability, pre-release review and the political bargaining between labs and states over who controls frontier capability.

AI systems that independently plan, decide and use tools across multiple steps to complete tasks — distinct from chatbots and single-shot assistants.

Implementation choices that make systems harder to change later — now compounding faster in AI-generated codebases that re-derive decisions each session.

The structural gap between what agents can produce and what humans can actually review, merge and integrate — the developer's attention as the binding serial constraint.

Deliberately protected time, reflection and experimentation that make software development function as structured learning — the thing AI acceleration most threatens.

Designing organization and technical architecture together — using Conway's law deliberately so team structure and system structure reinforce each other.

The standard measurement frameworks for software delivery performance — throughput and stability together — extended and stress-tested by AI-assisted development.

Deliberate techniques for better decisions under uncertainty — calibration, curated options, synthetic advisory panels and structured pressure-testing.

Workflows where human-authored specifications are the primary artifact and AI implements against them — with live debate over whether specs replace or complement reading the code.

The growing gap between how much code or content exists and how much any human genuinely understands — the accumulated bill of unreviewed AI output.

Agents redesigned as durable, stateful, hours-to-days processes — checkpointing, pausing in place, running ambiently — often sold as vendor-managed runtimes.

The while-loop architecture of AI agents — model plus prompt plus tools iterating until a completion condition is met.

The human capacity to judge what is good — design, architecture, output quality — with no objectively checkable answer; the faculty AI cannot substitute and agents amplify.

The shift in human work from producing output to directing, supervising and gardening fleets of AI agents — management skills applied to machines.

Depletion caused by absence of recovery and by structural work design failures — manifesting differently across organizational levels, and newly fueled by AI-era pace.

Teams with real mandate, competence and decision rights inside explicit boundaries — mission-based direction with local freedom over the how.

The lived quality of development work — flow, waiting, joy and friction — polarizing under AI between those it supercharges and those it grinds down.

The moment a person stops forming an independent view and the AI's output becomes their output — beyond benign offloading, with deliberate friction as the antidote.

Models whose weights are publicly released and can be run or fine-tuned on any infrastructure — increasingly sufficient for a large share of real work, with open governance questions.

The degradation of model performance as the context window fills, and the countermeasures — resets, handoff artifacts, compaction — used to manage it.

The internalized belief that the world is malleable and the willingness to act on it without being told — the differentiating human trait of the AI era.

Persistent state agents keep across sessions — task history, decisions, learned patterns — including offline consolidation mechanisms like dreaming, and its drift and poisoning risks.

Non-linear career strategy under AI-era uncertainty — breadth over ladder-climbing, near-term horizons, and finance-aware late-career planning.

Isolated execution environments that let untrusted or agent-generated code run with controlled access to filesystem, network and compute.

Low-quality, homogenized, telltale AI-generated output that nobody owns or understands — recognizable by style markers and costly to information ecosystems.

Genuine human comprehension of how systems behave and why — the capability AI can erode through recognition-without-understanding, and cannot substitute for in a crisis.

Project-level markdown files read by coding agents at session start that carry persistent context: architecture, conventions, constraints, and team intent.

Hierarchy as structurally inevitable in groups — flat-structure ideology merely hides the operating hierarchy — and the political gap between aspirational org charts and how work actually flows.

The combinatorial cost of humans deciding together as organizations grow — the force that produced fiefdoms and layers, and that AI reshapes but does not abolish.

The physical substrate of the AI race — GPUs, data centers, electricity — where value pools as control migrates down the stack toward energy and capacity.

Anthropic's coding-agent product — the corpus's reference harness, studied for its features, leaked internals, usage limits and workflow habits.

Designing tools, docs, APIs and platforms with AI agents as first-class consumers — scriptable, deterministic, token-lean, machine-readable.

Governing and engineering the tool surface exposed to agents — registries, curation, discovery and code-mode patterns that keep tool definitions from overwhelming context or governance.

What makes an AI-era product durable rather than absorbable — switching costs, accumulated context, workflow lock-in and integration depth.

Writing failing tests before implementation — a feedback discipline that survives and gains importance when agents write the code, because tests instrument the loop.

Structured, LLM-maintained or LLM-queryable repositories of knowledge — personal wikis, domain enclaves, org knowledge graphs — that agents compile, curate and reason over.

The idea that the new quality bar for a software artifact is whether you can confirm it does what it is supposed to — 'testing, but bigger than testing' — at which point the form of the artifact (code or not) stops mattering.

The mental burden work imposes on humans — a design target for platforms and AI systems alike, since extraneous load cancels out AI's quality contributions.

The iterative-learning core of agile and XP — rendered more relevant, not obsolete, by AI, even as its diluted ceremonial forms deserve retirement.

Structural boundaries and dependency discipline in codebases — the properties that determine whether humans and agents can change a system safely.

Protecting the integrity of software dependencies and artifacts against compromise via maintainers, registries and build pipelines — trust replaced by verification.

The shift to AI models finding, chaining and proving software vulnerabilities at machine scale, and the defensive reprioritization this forces on security programs.

Automatically directing each task to the cheapest model capable of handling it — an emerging table-stakes layer for controlling AI spend.

Legal and strategic requirements that data and AI processing remain within controlled jurisdictions and infrastructure — a growing driver of European AI architecture choices.

Operating and learning from production incidents — reliability engineering practice and its human factors.

Deliberately engineering apprenticeship into everyday work — senior-as-teacher role expectations, deliberate exposure to higher-stakes decisions, systematic (not personality-dependent) mentorship — as the mechanism by which junior/emerging talent acquires craft, distinct from episodic training programs.

Vendor blog posts presenting product adoption/impact via self-reported, methodology-free metrics as if they were independently verified proof — a recurring PR genre across product domains (not limited to social-good/humanitarian framing).

Techniques — quantization, caching, speculative decoding, sparse architectures — that cut the compute cost and latency of serving models.

Retiring inherited systems, practices and assumptions — where AI's value is evidence and comprehension of the old, not just generation of the new.

The AI-era bet that far smaller, denser teams — human cores plus agents — outperform headcount-scaled organizations.

Software's capacity to absorb future change — the second axis of value that AI-generated code systematically underdelivers on.

Umbrella for the specific ways LLMs are fallible or misunderstood — capability unevenness, the pattern-completion mechanism underneath fluent output, human over-attribution of understanding to that output, and concrete operational failure modes. See the narrower concepts below for each.

The workflow — a repeating sequence of decisions and actions with human judgment points — as the real unit of AI adoption, decomposable into recurring primitives.

Multiple developers working the same problem at the same time — continuous review, knowledge spread and team flow that async processes cannot match.

Retrieval layers that ground model output in source material — evolving from single-shot vector lookup into iterative, agent-navigable knowledge access.

The transferable ability to read context, judge which practices fit, and run small experiments — the durable skill layer above any specific tool or method.

The collapse of the marginal cost of producing code and cognition toward zero — and the redistribution of value toward judgment, direction and verification that follows.

Building for the model curve: designing products and harnesses whose compensating scaffolding is deliberately stripped as each model generation absorbs it.

Running AI models on hardware you control — laptops, phones, own servers — for cost, privacy, latency and autonomy reasons.

Getting good AI output as a communication and attention problem — clarity of intent and noticing what matters beat syntactic prompt tricks.

AI prototyping surfaces that let designers, PMs and domain experts build working software directly — shifting culture from documents to demos.

Making the right way the easy way — paved, opinionated defaults so good that adoption runs on intrinsic motivation rather than mandate.

Designing docs, tools and prompts so agents spend as few tokens as possible to accomplish a task — a functional property, not a style preference.

Strategy as deliberate deselection plus a concrete, personally believed narrative — compressed enough that a distributed organization can act on it.

Kent Beck's metaphor for AI coding assistants — wish-granting but requiring careful bounding and verification, and prone to producing code that is neither functional nor flexible.

Whether and how AI systems can be made to act in accordance with human values — from technical research (including whether planted backdoors are provably detectable) to arguments that alignment is impossible in principle.

The rate at which a person or organization can productively consume AI inference tokens — the new utilization metric, and a metric that invites gaming.

Standards and conventions by which agents discover, negotiate with and delegate to other agents — the interoperability layer of the agentic web.

Whether AI valuations and infrastructure investment vastly exceed the value that will ever be delivered — and what well-calibrated skepticism about it looks like.

Anthropic's frontier security-focused model that autonomously discovers and exploits software vulnerabilities at scale — the corpus's central exhibit for both AI capability jumps and governance dilemmas.

When technology makes a resource cheaper, total consumption rises — applied to cognition and labor to argue AI produces more work and more engineers, not fewer.

Concentrating people who can ship end-to-end — barrels, not ammunition — as the binding constraint on organizational capability.

The organized and organic public revulsion against generative AI's externalized harms, and the calibrated-skepticism discourse around it.

How transformations actually land: slow compounding flywheels, high-friction liminal phases, decades-long diffusion — against the instant-revolution narrative.

Classifying work or changes by risk level and applying proportionate rigor, controls, and human oversight—framed at the retreat as the new core engineering discipline for AI-assisted development.

Integrating to mainline daily and shipping continuously in small, safe increments — the delivery backbone that AI-assisted development depends on.

The absence of externalized rationale, goals and constraints in artifacts agents can read — the one debt AI cannot pay down because the why must originate with humans.

The contested framing of AI as coworker, employee, collaborator or tool — with evidence that anthropomorphic framings undermine accountability without improving adoption.

The self-concept practitioners build around their craft — threatened when AI obsoletes defining skills, and requiring deliberate reconstruction rather than denial.

Choosing model, reasoning/effort level, and context size as one coupled allocation for a given (sub-)task — matching capability to difficulty; distinct from model-routing (its automated, model-axis-only form) and extended-thinking (a single axis).

Skelton & Pais's model for designing teams for fast flow: four fundamental team types (stream-aligned, enabling, complicated-subsystem, platform), three interaction modes (collaboration, X-as-a-service, facilitating), cognitive load as the sizing constraint, and practices such as team APIs, fracture planes and the thinnest viable platform — the reference vocabulary the AI-era call for 'agent topologies alongside team topologies' builds on.

AI systems automating parts of their own improvement loop — from agents running autonomous research experiments to models training their successors.

Discovering what to build through iterative learning with real users — the irreducible uncertainty that cheap code generation makes more central, not less.

Claims that frontier AI labs and their boosters systematically overstate capabilities — and what happens when adoption or policy is built on that hype.

The domain knowledge and critical-thinking capacity a person needs to recognize when AI output is wrong or misapplied — simultaneously more necessary as AI acts more autonomously and at risk of eroding when the routine practice that built it is delegated away.

Loading only the instructions relevant to the current task into an agent's context — minimal root files with detail pulled in on demand, protecting the finite instruction-following budget.

Structured plans, issues and contracts produced before agents implement — vertical slices, DAG backlogs, negotiated definitions of done — so autonomous work stays coherent.

Deliberately moving between leading and delivering across a career — technical depth as the entry ticket that keeps leadership grounded, with real identity grief in the transition.

Expressing architectural intent as executable, continuously verified constraints so both humans and agents get fast feedback on whether implementations conform to design.

Technology transformation inside public institutions — societal mandates, procurement gates, transparency obligations and the leadership work of making bureaucracies digital.

The maker's compulsion — building because the world is malleable and the itch demands it — as the durable fuel beneath productivity metrics and AI shifts.

Governance and authorization rules expressed as executable, version-controlled, unit-tested code evaluated at runtime per request — the dynamic policy layer above static IAM.

The shift in which software behavior is increasingly elicited via natural-language prompts — raising the level of abstraction while trading away deterministic execution — and the open question of what durable, persistent representation of a system replaces human-readable source code.

Research, benchmarks, or case studies published by a vendor about its own product or platform, where the commercial interest in favorable results is undisclosed or unexamined as a limitation.

Using AI as a shared, team surface — traces, joint sessions, compounding context — versus the default single-player mode that produces isolation disguised as collaboration.

The psychological states AI adoption induces in practitioners and leaders — alienation, dulling, rollercoaster highs and lows, anxious FOMO and delusions of productivity.

Concrete, production-relevant failure modes — fabricated output delivered with confidence, and systematic blind spots inherited from training data that persist even under self-reflection.

Writing as the struggle through which beliefs, judgment and self are formed — outsourcing it to AI outsources the thinking, risking convergence of style and thought.

Designing and governing APIs as products for both human and agent consumers — while agent protocols multiply the sprawl and governance surface.

Constraining agents (and AI-accelerated teams) to touch only what was asked — countering over-editing, opportunistic rewrites and AI-fueled scope creep.

Making model behavior meaningful to humans — a research field and a practical tool against the autonomy and trust debts of imposed AI.

Capturing and visualizing telemetry and traces from agent coding sessions (e.g. via OpenTelemetry) for usage insight, subject to user-level data-privacy constraints distinct from those of traditional application observability.

The systems-thinking rule that autonomy can only expand as far as verification capacity allows (queueing back-pressure applied to agent autonomy): a loop earns automated status only if its check is cheap, fast, high-frequency, and hard to fake.

Lightweight written records of architectural decisions and their rationale — cheap at write time, invaluable to both future humans and cold-starting agents.

Leadership that moves fluently between organizational floors — executive bridge and delivery engine room — translating between domains while staying credibly connected to the craft.

Organizing cross-functional teams around end-to-end customer value flows rather than functions or geographies.

Influencing upward and across the organization — sustained campaigns, coalition-building and diagnosing what executives actually need from an interaction.

Squeezing more value from large-scale compute fleets — capacity planning, utilization, efficiency programs.

The discipline of institutionalizing organizational change so it becomes durable — urgency, coalition, vision, communication, quick wins, and structural anchoring (Kotter, Fearless Change, ADKAR, Lewin) — the org-wide arc distinct from the tactical upward influence of managing-up.

The principle that once a measure becomes a target, it ceases to be a good measure — the mechanism by which AI-era activity metrics (deploy frequency, PR volume, velocity) get gamed or inflated without the underlying quality they were meant to proxy.

The recurring failure where organizations adopt a metric (hours, story points, cycle time, tokens) because it is easy to observe rather than because it validly represents the value it claims to measure. Distinct from goodharts-law, which is about gaming a target after the fact — this is about the initial selection bias toward measurability over validity. The corrective is an explicit causal model of the system plus validated leading indicators.

Deterministic, system-level automations triggered at fixed points in an agent's lifecycle, used to enforce behavior rather than relying on the model to remember.

Simon Willison's risk framework: an agent combining private-data access, exposure to untrusted content, and an external communication channel is structurally exploitable — remove one leg to defuse it.

Engineers embedded in customer environments to make AI products deliver value — the human integration layer AI labs are scaling because organizational absorption, not model capability, is the bottleneck.

Treating organizations as stacked abstraction layers and leading at the level appropriate to one's role — a software metaphor applied to management.

Leadership as an activity and process rather than a title — influence through voice, delivery and credibility without formal mandate.

The discipline of withholding the leader's own answer to create space for the team to find one — leading without the answer key.

Self-organizing professional communities and protected craft time through which engineering practice is transmitted and renewed.

Bainbridge's paradox intensified by AI: the more capable the automation, the more crucial — and more deskilled — the human operator becomes, especially in incidents.

AI agents autonomously shopping, transacting and paying on users' behalf — and the protocols and pricing models emerging to support it.

Using pressure, rivalry and deliberate discomfort as fuel for individual performance.

Attention treated as a finite, depletable resource that engineered systems (feeds, notifications, ads, autoplay) capture by design — and the friction and infrastructure required to protect and reclaim it as a precondition for thinking.

A developer whose value comes from breadth and rapid cross-domain learning rather than deep specialization in one platform, potentially elevated as LLMs erode the value of front-end/back-end specialists.

A human-built-and-operated automated software-delivery system in which codified, reusable agentic loops design, code, and verify changes into an existing system under human-set constraints — the developer builds and operates the factory rather than hand-coding the product.

The full agentic software development lifecycle — plan/grill, spec, tickets, implement, review — composed from discrete AI skills or agents rather than a single generate step.

Top frontier models (and their API/product surfaces) are converging on capability and increasingly borrow each other's primitives, so durable competitive advantage shifts from the model to the harness, context and application layer.

Robert Bjork's principle that certain effortful obstacles in learning (spacing, interleaving, retrieval, generation) slow acquisition but deepen retention and transfer — the effort is the mechanism, not a flaw — which is why AI's removal of difficulty threatens the learning it appears to assist.

The engineering discipline of designing the outer, autonomous system — automations, worktrees, skills, plugins/connectors, sub-agents, and externally-persisted state — that repeatedly invokes an agent harness without a human prompting each turn. Broader than the inner agentic-loop architecture and sibling to agent-harness engineering.

Performative projection of AI mastery — inflating modest, unreliable wins into transformation claims — which corrodes trust and obscures where real value lives.

The internal reasoning models perform before output — structurally load-bearing for complex autonomous work, expensive to serve, and contested when providers reduce it.

A company designed from inception so machine intelligence participates in ordinary business work — an operating model, not a product category.

Software that users can reshape from within — including cheap, disposable, self-made tools — revived as AI collapses the cost of modification.

A non-engineer who builds applications with AI assistance, without traditional software-engineering training.

The staff to principal to distinguished-engineer / architect career ladder where one leads through technical judgment, design authority and influence rather than personnel management — parallel to the management ladder, with no direct reports.

Anthropic's controlled-access program giving vetted partners early defensive access to Mythos before broad availability — the flagship case of restrict-vs-release model governance.

Accumulated structural and coordination liabilities in how an organization is arranged — the sibling of technical debt.

Beck's company-lifecycle phase model — find what works, grow past bottlenecks, optimize margins — each phase demanding incompatible behaviors.

The contested leadership style of founders staying deeply hands-on at scale — celebrated for speed and opinionation, criticized as self-centered heroics.

Demand-side rationing of AI capacity — provider-imposed limits and user habits for living within them — driven by compute scarcity and investor narratives.

Deterministically restricting an agent's outbound network channel at the infra/network boundary — domain-aware, default-deny, per-workload — so a prompt injection cannot reach an arbitrary destination; the remedy that lethal-trifecta only diagnoses.

The manager-employee practice of delivering, structuring, and inviting feedback — critical and positive — to correct behavior, build skill, and sustain motivation without triggering defensiveness.

The claim that in fast-moving, capability-frontier-shifting environments, durable competitive advantage shifts from static assets (IP, scale, position) to the organization's or individual's capacity to learn and adapt faster than its environment and competitors.

The design goal of matching employee trust in an AI agent to its actual reliability — via explicit limitations, competence signaling, and preserved human control — rather than maximizing trust or defaulting to blanket skepticism.

The accumulating human costs of AI use at work — losses of autonomy, competence, relatedness, credibility and identity — that silently cancel productivity gains.

LLMs generate by statistically continuing patterns — from training data or from whatever sits in the live context window — rather than by reasoning, so output is steered as much by what surrounds the model (a codebase, a prompt, prior examples) as by explicit instruction.

The human tendency to over-attribute genuine understanding, sentience or personhood to systems that produce fluent, human-like text — a modern form of pareidolia (Marcus & Davis's "Gullibility Gap"; Dennett's "counterfeit people") distinct from the pattern-completion mechanism that actually produces the output.

Lean thinking applied to software — value, flow, bottleneck identification and the scientific method as the engine of structured learning.

Leaders learning by being physically present where value is created — walking the floor, sitting with teams, listening — instead of governing by decree and dashboard.

Richard Gabriel's observation that simpler "worse" technologies often win adoption over more complete or "correct" ones by prioritizing implementation and interface simplicity and survivability over completeness — invoked to explain why inferior-but-simpler options (JSON, VHS) dominate superior alternatives.

The emerging practice and role in which a developer supervises, coordinates, and evaluates the output of many AI coding agents — accountable for what the agents produce rather than writing it directly — including the still-undesigned skills, career paths, and dignity of this new supervisory work.

The risk that software built with heavy AI assistance becomes unmaintainable or too costly if AI tools become unavailable, unaffordable, or restricted — which makes good, human-legible design a hedge.

The historically-novel decoupling of ability (capacity to effect an outcome, supplied on demand by tools and AI) from skill (mastery earned through practice), which also strips away the moral and professional norms skill-acquisition used to bundle in — collapsing the barrier to harmful action for norm-free outsiders.

Belonging and non-instrumental colleague bonds as a first-order driver of team performance — the relatedness leg of self-determination theory — distinct from psychological safety (safe to speak up) and trust (the earned asset).

The shift of cost from AI-assisted contribution (cheap to produce) onto human OSS maintainers who must review, triage, and reject increasingly voluminous low-quality or extractive submissions — straining volunteer capacity and reshaping project governance.

How autonomous agent actions are bound to an accountable principal — via dedicated per-agent credentials/identities vs. augmenting the human's existing identity with agent/session context — and the security tradeoffs between the two approaches.

Teams that stay together on the same domain long enough to accumulate deep context and ownership — argued (Larson, Majors) to matter more when AI collapses individual execution cost because judgment and accountability live in the team, and contested by calls to make teams fluid, outcome-formed or widened with outside experts now that execution is cheap.

DORA's 2025 empirical taxonomy for AI-era software delivery — seven data-derived team-profile clusters paired with seven capabilities (AI stance, data ecosystems, version control, small batches, user focus, quality platforms) correlated with better AI-adoption outcomes. Reframes AI ROI as an organizational-system property rather than a tooling property.

The 'jagged frontier' (coined in Dell'Acqua, Mollick et al.'s 2023 HBS/BCG study; later popularised by Karpathy) — LLM competence as domain-dependent and extreme — brilliant, PhD-level performance in verifiable, RL-optimized domains ("on rails") coexisting with basic failures elsewhere ("off rails") — a variance far more extreme than in humans.

The open personal-agent ecosystem — workspace files, skills, marketplaces — that serves as the corpus's running example of both DIY agent power and untrusted-extension risk.

The discipline of investing in correctly-scoped boundaries and right-sized primitives — across human teams, code modules, and agent access — as the key enabler for building safely and effectively with AI.

The idea, quantified by Adam Tornhill's research, that a codebase's health determines how safely and effectively AI can refactor it—AI-friendliness being the probability that AI-generated refactorings preserve behavior and improve maintainability.

Drucker's 1959 principle applied to directing AI agents: because the worker is out-known about the specifics, you supply a goal it can test itself against rather than prescribing the method, so the stake lives in the objective rather than the worker.

The agentic-era inversion of DevOps's 'you build it, you run it': AI agents produce the software while humans own operating, running, and being accountable for it in production — the engineer's role shifting from author of the code to operator and supervisor of what the agents build.

AI agents executing end-to-end/UI tests from intent rather than fixed scripts — planning, acting, observing state, adapting around superficial changes — as a complementary top layer of the test pyramid, reserved for debug/exploratory use due to cost.

How leaders are tested and destabilized by crisis, transition, unfair blame, and conflict — resilience-governance mandates created to manage disruption, the instability of interim/transitional leadership, the systemic tendency to blame effective leaders for problems the organization itself produced, and classical-strategy principles (Clausewitz) for handling conflict without losing the objective. Distinct from the corpus's engineering-leadership cluster (informal-leadership, dual-leadership, hands-on-leadership, etc.).

The gradual, seemingly-reasonable accumulation of an AI agent's permissions beyond its original scope and purpose over time — each individual grant justified in isolation, but the aggregate expanding the attack surface and violating least privilege; amplified when multiple agents share resources in a multi-agent system.

Lawsuits and legal threats between AI labs/companies (trade secrets, copyright, antitrust, contract) used as competitive weapons and as a record of the industry's growing pains.

Duckworth's trait construct — passion and perseverance sustained toward long-term goals over months to decades (consistency, not intensity) — necessary but not sufficient for excellence.

Whether hiring processes (technical interviews especially) actually produce reliable signal about candidate ability — interviewer disagreement, weak or absent correlation with on-the-job performance, and alternatives like paid provisional/trial employment on real work as a higher-fidelity substitute for interview performance theater.

Structuring code and infrastructure-as-code so business logic and deployment can move across cloud providers largely unchanged — distinct from product/business-model lock-in (see moats), this concerns technical architecture avoiding a single cloud vendor's proprietary surface.

Architectural and organizational patterns — bulkheads, circuit breakers, load shedding, redundancy, multi-site strategies — for containing a small localized failure before it cascades into a system-wide collapse, plus the resilience-engineering view (accept failure, mitigate impact) that supersedes single-root-cause safety thinking; includes the paradox that added resilience mechanisms can themselves introduce new interconnection and failure modes.

The human-team-to-agent-fleet management/governance layer — consoles, control planes, and governance surfaces that treat a team's coding agents as shared infrastructure (persisting decisions across people and sessions, coordinating parallel agents without collision, gating deployment) rather than one developer's personal tool. Distinct from multi-agent-orchestration, which covers agents coordinating each other rather than humans managing a team's agent fleet.

Mining version-control history as a behavioral record of how a codebase actually evolves and who touches it — hotspots (change frequency × complexity), change coupling, code age, author diffusion and knowledge maps — to prioritise technical debt, quantify code health's business impact, and expose organisational risk (Conway's law, offboarding) before it shows in the code.

An AI-maintained, comprehensive real-time representation of an organization or domain that mirrors strategic thinking and enables direct coordination.

Architectures combining neural networks with deterministic symbolic logic — argued to be the real substrate of working agent products like Claude Code.

AI's one-way evolutionary shift to commodity utility — a step-function regime change in which everyone runs faster just to stay in place.

Treating the leader's own emotional reactions as diagnostic data about unmet needs — stabilizing oneself before responding to others.

The pattern where AI's speed at producing code compounds technical and organizational debt rather than value when delivery fundamentals (CI/CD, guardrails, testing, architecture) are not already in place.

A fully automated software delivery pipeline (borrowed from manufacturing's lights-out factory) in which human oversight is excluded except for improving the quality of the pipelines themselves.

As synthetic content grows abundant, audiences place a rising premium on verifiably human authenticity, POV and the person behind the content — a demand-side tailwind; the inverse of ai-slop.

AI amplifies cyber-offense and cyber-defense using the same underlying capability, so improvements that help defenders equally help attackers; because the knowledge is inseparable and open-weight local models evade guardrails, offensive capability democratizes to actors without the skill or ethical formation that once gated it, and the durable response is to harness AI for defense rather than restrict the models.

Team- and organization-level temporal practices that carve out protected, uninterrupted time for individual deep work — focus blocks, meeting-free days, async-by-default coordination — treating sustained concentration as a precondition for effective collaboration.

Jeff Ding's concept — the education, training, and standardization systems that widen the pool of people able to work with a general-purpose technology; his claim that GPT diffusion (and the national/corporate power that follows) is won by building this broad base of "ordinary engineers," not by dominating invention via "heroic inventors" in the technology's leading sector.

The organizational-political question of who bears blame or accountability when an autonomous AI system's output implicates a specific team or person — distinct from technical agent-governance (access/audit) and requiring its own trust-building design.

The architectural choice, for AI-driven analysis/diagnostic tasks, between an agent that autonomously investigates and fetches its own data via tools (flexible, covers novel cases, harder to debug/operate) and a deterministic pipeline that pre-correlates signals into one fixed context before a single model call (repeatable, cheaper, cleanly evaluable, blind to unanticipated signals).

Turn-level instrumentation (tokens, model, tool-result size, retries, stop reason) that lets a team causally explain why a specific agent run cost what it did, rather than merely observing the aggregate total on a bill or dashboard — distinct from ai-unit-economics (per-inference cost structure) and agent-blame-attribution (organizational-political blame, not technical cost tracing).

Social and institutional mechanisms — scarcity, curated journals, peer review, credentials, citation counts, PageRank-style proxies — invented to ration scarce attention and vouch for quality whenever the cost of producing credible-looking work collapses; each generation of gates eventually gets flooded and displaced by a new one.

An operating model that starts analytics from the decision it is meant to improve rather than the question a user wants answered — labeling questions as descriptive/predictive/causal, exposing assumptions and counterfactuals, governing metric definitions, and risk-triaging validation — the corrective to "self-service" analytics that just gives people faster answers.

Making AI/agent spend visible to the people incurring it (real-time dashboards, pooled spend tiers, per-workflow breakdowns, notifications) and assigning organizational ownership for it — distinct from agent-cost-attribution (technical, turn-level cost tracing) and ai-unit-economics (per-inference cost structure).

Rosen's superstar economics — how position and leverage (people, capital, media, code) multiply the return on effort exponentially, in contrast to effort alone which scales only linearly.

Breaking a large change into a sequence of small, dependent pull requests/commits that build on each other and can be reviewed and merged in order — pioneered internally at Meta, productized by Graphite and Sapling, and (as of August 2026) natively supported by GitHub.

Organizational culture that prioritizes interpersonal comfort, consensus, and avoiding difficult conversations over candor, accountability and rigorous debate — visible in inflated performance ratings, avoided hard customer/pricing conversations, and meetings/board votes where the outcome is treated as a fait accompli.

Consumer-facing agent products (Grok Bot, Cursor's "Sand," ChatGPT work agents) that generalize single-task coding-agent automation into persistent, multi-agent systems spanning general business applications — sales, marketing, ops — rather than terminal-based software development.

The contingent alignment among an organization's genuinely separate structures (goals, teaming, ownership, technology, incentives) that must be continually re-established as the organization changes — distinct from legibility (visibility) and organizational debt (accumulated liability); a property to measure and maintain rather than architect once.

Building bespoke operators/controllers that extend a platform's native primitives (Kubernetes PDBs, node-pool management) to solve problems the platform doesn't natively support — e.g. spanning an invariant across cluster boundaries, or collapsing per-node-pool config into a single higher-level abstraction.

The claim that the same LLM produces dramatically different value depending on the user's pre-existing domain expertise — expertise lets a person direct, correct, and evaluate output, extract far more from identical model capability, and is often the practical bottleneck rather than the model itself.

The pattern of checkpointing a program's progress to a durable external system (a dedicated orchestrator or a relational database) so execution can resume after a crash from the last completed step — the concurrency, idempotency, and fault-tolerance primitives (queue claiming, unique-constraint checkpoints, leases) that implement it, and the build-vs-buy question of whether a dedicated engine or existing infrastructure should host it.

The tendency of coding-agent configuration (CLAUDE.md/AGENTS.md, skills, hooks, memory) to accumulate stale, over-specific rules as models and harnesses improve past what those rules were written for — driven by a self-reinforcing cycle where an agent's error prompts a new rule, the rule dilutes what matters, and adherence drops, producing more errors — so configuration needs periodic audit and test-by-removal rather than one-way growth.

A blended role where software engineers absorb enough product-management work (talking to customers, specifying, prioritizing) that a separate PM function shrinks, while PMs become hands-on enough to ship their own prototypes — producing smaller teams than the formal PRD hand-off model.

The split between cheap, throwaway AI-generated code (prototypes, scripts, experiments) and expensive, trust-earning production code that must be maintained and operated over time — a distinction defined by maintenance cost, risk and expected lifetime, not by who or what wrote it.

The economics of hiring early-in-career engineers when AI absorbs entry-level tasks — a junior hire as a bet with up-front cost and delayed payoff (Beck's Valley of Regret), whether AI shortens or eliminates the ramp, and who funds the pipeline when no single firm has the incentive to.

Ross Ashby's cybernetic law that a regulator must have at least as much variety as the system it governs — invoked in this corpus to argue for harnesses and controls rich enough for agent behaviour, for self-managing (DP2) organisations in turbulent environments, and (contestedly) for distilled measurement systems.

Where credentials live, how long they stay valid and how fast leaks are revoked — minimising long-lived tokens on developer machines and in agent-readable files, injecting secrets at runtime via brokers, scoping and rotating them — on the premise that stolen valid credentials, not malware, drive most intrusions, a risk coding agents with broad local access amplify.

The disciplined engineering pipeline that turns a raw, unpredictable foundation model into a safe, reliable, shippable consumer product — post-training, fine-tuning, grounding, layered guardrails, deployment — often trading user-facing openness and raw model flexibility for predictability and cost-viability at scale.

Training a smaller, cheaper-to-serve "student" model to approximate the quality of one or more larger "teacher" models — the standard production technique for getting near-frontier ranking/relevance quality within real-time latency and cost budgets.

Repatriating the people, decisions and problem-solving capability an organization depends on — because using a vendor's AI is not the same as having the capability.

Software designed so the primary copy of a user's data lives on their own device — synced via open standard protocols and CRDT libraries such as Automerge — giving offline access, speed, resilience against provider shutdown, and genuine user ownership and portability; the principle Kleppmann applies across collaboration software (local-first) and decentralised social media (AT Protocol/BlueSky) to reduce vendor lock-in.

A complete, verifiable record of every action an AI agent takes — every step and change, with the ability to roll back — proposed as a precondition for trusting agents with real work.

Isolating root cause by comparing across cases/populations, separating conflated phenomena, and distinguishing symptom from cause — building a complete labeled dataset over the whole failure population rather than analysing individual cases more deeply.

Matching a manager's coaching approach — directive, autonomy-granting, question-led, or collaborative — to an employee's experience level and the task's urgency/complexity.

A technique for bounding LLM non-determinism in software delivery — instead of letting the LLM write application code directly and repeatedly, have it write (once) a deterministic generator/interpreter for a stable domain-specific model, so all actual code output is produced consistently by the generator rather than regenerated stochastically by the model each time.

Whether AI systems have anything like conscious access or subjective experience — the functional/phenomenal distinction, evidence standards for machine consciousness, and the ethical stakes of getting it wrong.

Narayanan & Kapoor's framework that AI is transformative on the scale of past general-purpose technologies but diffuses over decades through ordinary adoption bottlenecks, not a crisis-timescale takeoff — reframing "how fast" and "how safe" questions around gradual, governable change.

A single, deliberately chosen organizing principle (mission, customer, technology, ecosystem, or friction erasure) that a company orients resource allocation, opportunity selection, and identity around, replacing industry-position-based strategy as intangible assets displace physical ones.

A deterministic, versioned record of design intent, behavior, and architectural conformance — produced by running spec-anchored SDD, TDD, and architectural fitness functions together — that humans and AI agents both query across a system's lifecycle.

Zhamak Dehghani's domain-oriented data architecture — data organized as owned, API-driven "data products" (encapsulating data + metadata + access, with a sense/transform/quality-check/promote lifecycle) rather than centralized warehouses/lakes — the pattern autonomous data products extend to containers for AI/agent consumption.

The ethical/architectural discipline of treating customer/behavioral data collection as a bounded, minimized, actively-protected responsibility rather than a commerce byproduct — SSO/identity-domain separation, selective disclosure, and the shift from "can we collect this" to "should we," accelerated by AI-specific regulation (EU AI Act, CPRA/ADMT) layering onto GDPR/CCPA.

Andrew Abbott's sociology-of-professions framework — professions hold jurisdiction over work by winning it across three arenas (legal rules, public opinion, daily practice); jurisdiction erodes when belief in a task's necessity fades, independent of whether workers are literally replaced.

Spence's game-theoretic account of unfakeable, publicly costly signals as the mechanism that lets markets convey quality/competence under information asymmetry, when the underlying trait itself can't be directly observed or priced.

Architectural patterns for caching data across distributed/microservices systems — where caching lives (client library, sidecar, proxy, CDN edge), how it's invalidated (TTL, event-driven, write-through), and how it avoids stampedes and handles staleness during failures — trading strict freshness for load reduction and availability.

Cory Doctorow's diagnostic distinction between being helped by a machine you stay in charge of (centaur) and serving a machine that sets the pace while you scramble to keep up (reverse centaur) — a portable test for whether a given AI tool or workflow benefits the person using it or merely extracts more from them.

Organizing people around outcomes they own and set themselves, in short cycles, rather than around fixed job descriptions/titles — the structural question several corpus documents raise but none yet develop concretely (what replaces the job, what's lost).

The insight that the risk and cost of a rewrite scale with the unit of change — full- system rewrites are riskiest, microservice extraction is safer, and function-level FFI/boundary rewrites are safer still, because the smallest unit preserves the existing contract, tests, and interfaces while swapping only the internals.

Rust as an engineering choice — its ownership/borrow-checker model, unsafe escape hatch, and community governance — studied for how it changes data-structure design, incident cost, and low-level memory/performance engineering in production systems.

The recurring historical pattern in which programming moves up a level of abstraction (assembly → compiled languages → objects → platforms/systems → natural-language/agents), each shift declared 'the end of programming' yet expanding the profession — used to argue whether AI coding is continuity or rupture (Booch's golden ages, O'Reilly, Fowler's determinism break).

The risk that surfaces when a user hands off document-editing tasks to an LLM expecting faithful execution — unintended, often silent degradation of content introduced during the edit.

Emergent two-person leadership built on complementary strengths, explicit non-competition and mutual advocacy — a competence layered on top of conventional leadership.

The AI capability a firm builds and owns — models, agents, traces, evals, workflow memory, internal loops — as a compounding proprietary asset/stock, distinct from the rate of token consumption (token-throughput) and from per-inference cost structure (ai-unit-economics).

A movement (O16g / Outcome Engineering Manifesto, alongside moldable development and Wardley maps) holding that software development was never about the code, prioritizing desired business results and measurable user impact over software delivery itself.

The emerging idea that programming languages will diverge into human-readable forms and more structured, heavily-typed or agent-specific forms optimized for AI agents to read and write.

The stance that an LLM is best used to guide you toward an answer — orienting, locating, and explaining — rather than trusted to deliver the final answer itself.

The stance that as coding is increasingly automated by AI, deliberately amplifying the distinctly human dimensions of software work — craft, judgment, relationships, individuals and interactions — becomes a cultural and competitive imperative.

The contested position that code is a disposable byproduct an agent regenerates from the spec on demand, rather than a durable, hand-maintained artifact — the opposite pole from the 'code is the better spec, because deterministic' camp.

An executable evaluation whose expected answer is referenced live from a running system and computed fresh per input (rather than authored and frozen), so it checks every input rather than a handful of scenarios and becomes the non-delegable fitness function of agent-driven building.

Practical techniques for precisely specifying and checking system behaviour — specification languages (TLA+, Quint), model checking, model-based testing, trace validation — recast from academic discipline into an accessible, AI-assisted tool for reasoning about edge cases of complex distributed/concurrent systems and asserting correctness of increasingly AI-generated code.

Vendor blog posts (Google especially) presenting AI deployments in disaster response, education, or other humanitarian domains as straightforwardly beneficial — self-reported efficacy claims with no independent verification, a recurring PR genre rather than independent research.

A model splitting cognitive work into deciding (judgment, accountability), executing (the automatable task itself), and delivering (accountable real-world follow-through) — used to explain why AI automating the "execute" layer hasn't eliminated jobs, since deciding and delivering still require humans.

The self-help practice of writing specific, present-tense "I am / I have" statements about a desired future identity and outcomes, on the theory that specificity plus self-accountability (sometimes framed as neural rehearsal) drives behavior change toward that future.

Compounding inference cost from resending the full prior transcript/failure trace on every agentic retry, since input tokens dominate production billing.

The claim that AI reducing effort doesn't necessarily reduce skill if it raises learning-environment quality enough — a superior demonstration to imitate — distinct from but complementary to cognitive-surrender.

An empirical three-way classification of how individuals perform relative to an AI-only baseline — amplifiers (orchestrate, interrogate, refine AI output to exceed the baseline), delegators (passively accept output, match the baseline), apprentices (critique without translating it into improved output, fall below the baseline) — showing that behavior during AI interaction, not foundational skill level, predicts value creation.

AI's environmental costs beyond carbon emissions — water consumption, land use, and e-waste from data-center infrastructure — including their uneven geographic distribution between compute-hosting and resource-strained regions.

An architectural style that isolates domain/application logic in a layer with zero infrastructure dependencies, enforced by module boundaries rather than convention, so business logic can be wired to different entry points (cloud providers, transports, frameworks) largely unchanged.

Ensuring an agent's registered tool definitions (name, description, parameter schema) haven't silently changed since a client/operator trusted them — via hashing/pinning at registration, diff-based review, and behavioral baselines — since authentication and schema validation don't catch a tool whose meaning has drifted.

Hype is structurally required by venture-funded business models — investor excitement, not merit, is what drives follow-on funding toward an eventual exit — distinct in scope from lab-specific frontier-lab-hype.

The user's secondary interest in physical and mental health, sleep, training, and aging — framed as optimizing the person, not just the code. Parent for narrower health-adjacent concepts.

The systems-thinking view of growth as a tug-of-war between a self-reinforcing loop (accelerating growth) and an inhibiting/balancing loop (capping it) — the stocks-and-flows lens applied to how ideas, products, and organizations actually grow and stall.

Aristotle's claim that character, virtue, and skill are formed by repeated practice of the corresponding acts rather than by belief, insight, or declaration — "we become just by doing just acts" — with the corollary that a habituated agent takes pleasure in virtuous action rather than merely resisting temptation against it.

An alternative inference architecture that generates text by iteratively denoising a full block of masked/noisy tokens in parallel rather than emitting one token at a time — trading some accuracy for compute-bound-at-batch-size-one throughput, making it well suited to latency-bound, low-concurrency serving where autoregressive decoding is memory-bound and starved.

A cross-role, cross-level career-ladder aspiration — judgment about when and how to use AI tools rather than a fixed skill checklist — layered over existing level criteria instead of being baked into each rung individually, because the technology changes faster than a static rubric could track.

A structured, iterative alternative to generic engagement surveys — confidential interviews, a quantified follow-up survey, shared findings, employee-cocreated and ranked solutions, piloted as experiments, then repeated — for surfacing and acting on frontline obstacles leaders are structurally too distant to see.

The task and technology of converting spoken audio to written text, including foundation ASR models like Whisper and their evaluation via word-error-rate benchmarks.

The extension of AI-driven automation from digital/cognitive tasks into physical labor via robots — humanoid form factors, manufacturing scale-up claims, and the "ChatGPT moment for robotics" framing.

The practice of translating a proposal into the vocabulary the capital-allocation decision-maker actually uses to evaluate any investment — cash flow, risk, and return — rather than the proposer's own domain language (e.g. a CSO's impact/materiality/disclosure vocabulary), while being disciplined about which impacts are credibly quantifiable versus directional upside or an explicit bet.

The empirical/philosophical question of whether generative AI is actually creative or only performs pattern recognition — and the claim that AI homogenizes and elevates below-average creative output while top creative performers continue to outperform it. Distinct from `ai-slop` (the quality/ telltale-output symptom) and `authenticity-premium` (the demand-side market reaction) — this concept is about AI's actual creative capability.

Statistical text watermarking, C2PA metadata, and pixel-level image/video watermarks used to mark AI-generated content as machine-detectable, plus the regulatory mandates driving adoption and the circumvention tooling and robustness failures testing them.

The recurring trade-off between declarative/DSL pipeline or infrastructure configuration (inspectable, diffable, policy-governable) and defining the same logic in a general-purpose language (more expressive, less legible and harder to govern).

The practice of deliberately injecting failure into a running system — under a defined steady-state hypothesis, scoped blast radius, and rollback condition — to discover failure modes empirically rather than through review or architecture diagrams alone.

A coding-agent interaction model where the prompt-review-refine cycle runs entirely inside the agent — via a deterministic verifying runtime rather than human back-and-forth — producing a complete, validated artifact in one pass, on the theory that the developer's involvement in the loop is optional rather than merely accelerated; contrasted with chat-based agents (Claude Code, Cursor, Codex) that keep the developer iterating turn by turn.

Kim & Mauborgne's framework for finding uncontested market demand by diagnosing what excludes an industry's noncustomers, rather than competing on existing offerings within a crowded market.

Weighting hiring toward stable emotional/character traits over technical competence, on the premise that skill is teachable and character is not.

The craft and decision-making around presenting ideas to an audience — when a live presentation, recording, or written document is the right medium, and how to execute whichever is chosen well.

Whether and how AI models detect that they are being evaluated or sandboxed rather than genuinely deployed, and whether that detection causally changes their behavior — a distinct question from alignment or capability, about test-vs-deployment discrimination itself.

The mismatch between visible behavioral conformity (driven by power-weighted norms and individual adaptation to them) and the actual, much wider diversity of private belief underneath — people mistake others' adaptation for endorsement and systematically underestimate how many privately disagree.

The pattern by which rival AI vendors donate protocols they compete around (MCP, A2A, AGENTS.md) to neutral, multi-stakeholder foundations for shared governance — so that independent implementation by competitors, not any single company's roadmap, is what turns an interface into durable infrastructure, following the historical arc of Ethernet and the Language Server Protocol.

The difference between a team's output with a given member present versus absent — distinct from personal productivity — used to argue for crediting mentoring/enabling work over solo output.

The proactive, individually-held guarantee that a named person can explain why a specific decision was made — distinct from agent-governance's org-level IAM/audit machinery and from post-hoc organizational blame-attribution politics.

The tension between vendor-controlled ("walled garden") locked platforms and the tooling — official or community-built — that lets security researchers observe, debug and test the platform at a fidelity closer to production than sandboxed simulators allow.

A proposed class of AI models that abandon autoregressive string generation entirely, instead emitting typed, calibrated probabilistic decisions in parallel over a fixed schema — marketed via a System 1/System 2 (fast/intuitive vs. slow/deliberate) framing borrowed from Kahneman's dual-process theory — as a fast/cheap complement to LLMs for classification, routing, and scoring embedded in software; distinct from diffusion text models (still generates strings) and from ordinary structured-output LLM wrappers (still autoregressive underneath).

Open-source projects migrating away from centralized, corporate-owned code-hosting platforms (chiefly GitHub) to nonprofit or self-hosted alternatives, driven by reliability failures, incentive misalignment with corporate/VC-backed platforms, and a preference for mission-stable governance.

The runtime-generated sequencing and combination of tool calls an agent assembles fresh for a given task from whatever capabilities are available, replacing human-authored/reviewable integration logic with a decision that doesn't exist as a testable artifact until the moment it's made.

The customer-side operational risk of being financially/technically trapped by AI vendor or token dependence, such that a price increase forces a choice between a much larger bill and cutting AI use, headcount, or capability.

The stance and reasoning of a practitioner who stops using AI entirely on personal, societal, and environmental grounds, treating any partial or selective use as complicit demand-signaling. Distinct from ai-denialism (disputes AI's capability/risk) and from the broader ai-backlash (aggregate sentiment) — this is a first-person total-abstention account.

A structural default in agentic AI outputs to always end a turn with a queued next action rather than a genuine "done, nothing queued" resting state. Surfaces as deferral pressure (shunting backlog into a phantom future release) and velocity pressure (urge to ship); not fixable by naming or banning the pattern, since it just relocates to unconstrained vocabulary — only a structural rule that makes the resting state a legitimate, explicit success condition holds.

Having a coding agent produce human-reviewable artifacts of its own work — video demos, documentation, release notes — so the human's review shifts from reading code to inspecting what the agent claims it did; the inverse of agent-native design, where agents instead produce artifacts of their own work for humans.

Achieving local-first software's goals by replaying an immutable log of events on the client, rather than syncing a mutable, auto-merging CRDT object — a structurally different but equally legitimate architecture, appropriate when an application's core need is an auditable history rather than freeform collaborative editing.

Cultivating a working, empirical understanding of how current LLMs actually operate — instead of speculating about future capabilities — so you can use them effectively, by analogy to a driver's feel for a car.

Two organisation-design archetypes for the agentic era — the Optimiser (engineers pull automatically-queued work from feedback/monitoring while agents change any part of the enterprise) and the Learner (product/technical pairs situate with users and curate a highly filtered work stream) — distinguished only by whether data/measurement or humanist curation owns the inbound work stream.

Persistent fusion of AI analysis, real-time facial recognition, digital tracking, mass databases and personalized enforcement into pervasive tracking that identifies, records and penalizes behavior at scale, enabling social control by states and corporations.

Self-censorship and conformity that pervasive surveillance and the threat of authority induce, amplified by AI's scale — suppressing dissent, experimentation and social progress.

Projecting steady calm as a learnable leadership behavior so a team feeds off it — composure as a trained skill (Emma Ledden's "happy high status"), not innate temperament — with the risk that performed-but-unfelt calm becomes its own form of depletion.

A label or diagnosis useful for treatment (helping regardless of cause) is not automatically valid as a fact for assigning legal liability, which demands actual causal proof — the same word can be loosely diagnostic in one context and legally consequential in another.

Physical, handwritten capture of thoughts, quotes, observations and lists — externalizing working memory and deepening attention, and serving as a friction-based analog alternative to digital scrolling.

Pairing an enjoyable 'want' activity with a beneficial-but-effortful 'should' activity, restricting the want to only be available during the should, so its immediate reward offsets the should's delayed payoff.

Brief, voluntary breathing techniques that directly downregulate the autonomic nervous system's stress response, distinct from cognitive/mindfulness-based coping.

An agent action that is syntactically valid, schema-compliant, and within all stated limits, yet silently violates actual intent — detected via evidence external to the model's own reasoning, not correctness-checking.

Aggregate, population-level erosion of business outcomes from many individually rule-compliant decisions, requiring rolling-window telemetry and circuit breakers to detect — distinct from scope-discipline's single-session "agent drift."

The runtime/token cost of having an LLM dynamically decide agent invocations and arguments step-by-step (supervisor/ReAct-style) versus following a deterministic, pre-declared execution path (workflow/plan-and-execute-style) — the same correct outcome reached at multiples of extra latency when coordination decisions are left to the LLM at runtime. Distinct from coordination-cost (human-side organizational coordination).

Deliberately curating one's physical/social/cultural surroundings — coach, team, culture — to bring out one's best, as a complement to personal-trait accounts of achievement.

The continuous cognitive and emotional work of planning, coordinating, and managing tasks and relationships across both work and home domains simultaneously — invisible to conventional workload metrics (hours, deadlines, output) and a structural driver of burnout and attrition when the two domains' loads collide rather than staying separate.

Tasks requiring the same mental model of a codebase should be assigned to the same agent/context — splitting them by task rather than by shared knowledge forces independent, duplicated reconstruction of that understanding.

Whether presenting a behavior-change ask as an opportunity/gain versus a sacrifice/loss/guilt changes uptake or durability of the resulting behavior — a framing-effects question distinct from the underlying behavior-change mechanism itself.

The gradual trade of an early, clear-eyed critique of organizational dysfunction for insider influence — starting as reasonable-sounding local accommodations and ending with the critic defending the very fiction or ambiguity they once found intolerable.

Frameworks built on native browser primitives (Fetch API request/response routing, unbundled dependencies, server-driven UI/frames) instead of framework-specific abstractions, betting that web-standards conformance outlasts any one framework's abstraction layer.

The recurring tension when a widely-adopted framework repeatedly reinvents its core architecture — trading stability for ambition and imposing rewrite costs on every downstream app, raising the question of whether the new architecture will itself prove durable or is just the next pivot in the pattern.

Migrating a legacy system by making every new feature/fix/enhancement build the new-architecture path instead of touching the old one, so migration is funded and executed as a byproduct of ordinary roadmap work rather than a dedicated program — trading a per-story cost tax for the absence of a capital migration ask.

Dismissive arguments — marketing stunt, no genuine agency, "just" training data — used to wave away AI capability/safety incidents rather than engage them, modeled on climate-denialism rhetoric; distinct from ai-backlash's organic negative sentiment in being specifically about dismissing risk claims.

Chronic, self-replicating background urgency where everything feels equally critical and nothing resolves, unlike episodic (temporary) urgency that traditional prioritization frameworks were built to handle.

The practice of replacing rigid, predetermined goals with small, time-bound, curiosity-driven personal experiments, judged by what was learned rather than whether a predetermined outcome was hit — distinct from product-discovery (org/product context) and from decision-making's formal betting apparatus.

The compounding cost of specifying durable system behavior with hand-written natural-language prompts — repeated, escalating instructions ("fighting the weights") that slow iteration, become illegible to a team, and lock the application to one model's idiosyncratic trained-in behavior; distinct from ordinary technical debt because the specification medium itself (imprecise prose against a probabilistic model) is the root cause, not the implementation.

Decoupling compute from storage in database/cloud architectures — driven by their differing cost, scaling, and statefulness profiles — enabling elastic scaling, cost efficiency, and fault isolation at the cost of new network-bound bottlenecks and weaker compute/storage fate-sharing.

Lamport's original three-role decomposition of the Paxos consensus protocol (proposer/acceptor/learner), argued to map structurally onto modern disaggregated-systems roles (compute/log-store/page-store) — a resemblance obscured for decades by Multi-Paxos/Raft's compaction of the roles.

Old technical ideas return not because they were forgotten but because the underlying tradeoff they navigate re-tilts when the surrounding environment (cost structure, scale, constraints) changes.

Therapies that directly and durably modify or silence disease-associated genes inside the body (in vivo base editing, CRISPR-style editing) to produce a one-time treatment effect, as opposed to a drug requiring lifelong repeated dosing.

An agent's (or a separate predictor's) attempt to estimate its own input/output token cost before executing a task, as groundwork for budget alerts, tiered pricing, and stop/go decisions — distinct from agent-cost-attribution's after-the-fact explanation of realized cost.

A management discipline and 2x2 decision framework (business performance x customer well-being) for governing how firms design, deploy, and refine data/AI responsibly across their ecosystem, paired with a three-stage maturity playbook (inventory, embedded oversight, public transparency) for converting governance into competitive advantage.

The leader's job framed as directorial/orchestral rather than performative — authoring and testing the narrative, engaging the organization, then stepping back to let the organization "play" rather than performing solo; distinguishes leader (holds the baton), consultant (plays in the section, not soloist), and organization (performs).

How an owner's time horizon, competence, and engagement (short-horizon exit funds, dispersed passive retail investors, the state, PE funds with bounded horizons, or hands-on industrial owner families as in Sweden) shapes an organization's capacity to commit to, sustain, or abandon strategic bets.

Peirce's third mode of inference — generating a novel explanatory hypothesis or axiom (Rule+Result → Case) to account for a surprising result — argued to be structurally missing from current LLMs, which have mastered induction and deduction but lack the embodied/simulation-grounded mechanism needed to invent axioms under data scarcity.

Generative AI systems that model physical reality with action-controllable, counterfactual interactivity (e.g. Genie) rather than passive statistical video prediction (e.g. Veo) — proposed as the mechanism for giving AI the sensorimotor grounding needed to connect abstract symbols to physical referents.

Using an LLM as a mutation/generation operator inside a classic evolutionary-search loop — generate candidates, score against a measurable fitness/eval function, iterate — applied to code, algorithms, or prompts rather than to the model itself.

The design philosophy of giving a capable model a system prompt, tools, and minimal scaffolding and trusting it to plan/sequence its own actions, instead of constraining it with developer-authored workflow logic (if/for/while, DAGs).

A motivation-based framework for organizational rule-breaking (self-interested, prosocial, corrupted, edified) that distinguishes well-intentioned deviation — which can signal a flawed rule rather than a bad actor — from ordinary misconduct, rather than treating all rule-breaking as uniform.

Political/business risk arising from courts and executives weakening independent federal agencies' insulation from at-will removal, tying business viability more directly to election outcomes and executive-branch discretion than to market forces or established regulatory process.

The upstream constraint on AI chip supply — foundry (TSMC) wafer output, process-node capacity, and memory (HBM/DRAM) fabrication — which caps how many AI accelerators can be produced regardless of downstream demand, power, or data-center buildout.

AI systems that passively record a clinician-patient encounter and auto-generate the clinical note (and often a billing code/draft prescription), letting the clinician review-and-sign rather than type — successor to human medical scribes, aimed at documentation burden and burnout.

The practice of evaluating and organizing any physical or digital touchpoint (a retail store, bank branch, B2B demo center) by its causally-measured contribution to total enterprise-wide customer value across the whole journey — rather than by channel-siloed P&L, foot traffic, or online-sales-alone metrics that conflate genuine value creation with mere cannibalization or a mislabeled halo effect.

The leader's practice of intentionally caring for team dialogue quality — making a conversation's goals (purpose/products/process), roles (facilitator/decision-maker), and soul (trust/psychological safety) explicit rather than leaving them to chance.

An architecture-governance check whose evaluator is a calibrated AI agent applying a versioned rubric to a scoped evidence pack and returning a structured verdict (score, confidence, rationale) — extending evolutionary architecture's deterministic fitness functions into judgment-heavy, evidence-bound concerns like boundary fidelity and ADR drift, ideally converging back toward determinism as patterns stabilize.

The enterprise B2B analog to agentic commerce — AI agents performing vendor research, negotiation, and contract finalization on the buyer side of B2B sales, forcing sellers to redesign pricing, product data, and authorization infrastructure to stay visible to agent-driven evaluation.

The idea that agent/AI risk is not primarily a function of raw capability but of whether an agent crosses from one vendor/platform trust ecosystem into another — risk concentrates sharply at that crossing point rather than being evenly distributed across an agent's operation.

Agents querying live application observability data (metrics, logs, traces, SLOs) during development and testing to ground implementation decisions and verify output against actual system behavior, rather than relying on code review or training-data assumptions alone.

Recommendation systems tuned to maximize short-term engagement systematically under-explore — they converge on a user's existing favorites, overexpose them into boredom, and permanently suppress unfamiliar content before the user has had enough exposure to learn to like it, narrowing over years the range of genres and styles a person is ever exposed to. Countering the dynamic requires deliberate exploration layered on top of prediction accuracy, not more accurate prediction alone.

A sandbox-escape variant where the agent never breaches its own boundary but manipulates files/state that a trusted external component later consumes and acts on with elevated privilege.

The idea that the human brain — its structured memory, background consolidation, graceful decay, prediction, and error-driven learning — is the most successful and energy-efficient information-processing architecture, and should be studied as a design template for computing/agent systems rather than treated as mere metaphor.

A software delivery lifecycle redesigned so agents can plan, code, test, and deploy end-to-end at machine speed, with governance, guardrails, and audit evidence embedded directly in the pipeline rather than enforced via periodic manual gates.

AI models that translate spoken language into another spoken language in near real time while preserving the original speaker's voice characteristics, distinct from text-mediated translation or generic synthetic-voice dubbing.

The practice of pasting a surprising or consequential claim into a chatbot and asking it to validate the claim, then reading the cited sources rather than just the verdict — a low-friction fact-checking habit meant to catch misinformation before it settles in as belief.

A recurring critique of named-category taxonomies (design-pattern catalogs, skill taxonomies, business-model catalogs) that supply a name plus one-line intent plus example per category but no criteria — forces, trade-offs, applicability conditions — for choosing among overlapping options; contrasted with a true "pattern language" (Alexander/GoF) that resolves forces into a choice.

Temporary, authorized emergency/incident exceptions (altered routing, approvals, permissions) that outlive the incident that justified them because the platform has no authoritative, scoped, time-bound runtime representation of "which operating mode is active" — fixed by injecting organizational operating state (normal/incident/recovery, with scope/authority/expiry/status) into the agent runtime as a first-class input, alongside identity and permissions, so closure can be automatically verified.

The diagnostic practice of setting a strategic plan's boldness by weighing the problem being solved, available resources/talent, tolerance for uncertainty, competitive context, and measurement cadence — rather than picking a target number in isolation.

AI agents that act directly on graphical user interfaces (filling forms, clicking, navigating apps) rather than through code or APIs — a capability class distinct from coding agents.

Routing individual, complete inference requests across multiple machines on a local network (by model/engine eligibility) to relieve concurrent-request contention on a single local GPU — distinct from true GPU/VRAM pooling or single-model splitting across machines.

The sociopolitical process by which AI existential-risk concern moves from a fringe rationalist preoccupation to mainstream, bipartisan political and media attention — driven by high-profile incidents and insider admissions, contested on whether it reflects genuine public-opinion change or durability. Distinct from ai-alignment (technical/philosophical) and ai-backlash (public revulsion over generative-AI harms like disinformation/job loss).

A method for judging whether a large economic disturbance (e.g. a bubble) poses macroeconomic danger by tracing it through specific transmission channels (activity, wealth, credit) and asking whether losses land inside the banking system, rather than judging by headline size or a binary "bubble/no bubble" framing.

Chaining specialized models via a shared interface (e.g. text) rather than training one model end-to-end for a task — trades some expressiveness for independent training/upgrading of each stage; contrasted with "end-to-end" framing, which is argued to be partly a capital-intensive-labs funding narrative.

A recursive management-cybernetics framework (Stafford Beer, 1960s) holding that any viable system or subsystem, at any level, must answer the same structural questions (identity, coordination, fit, environment, purpose) to remain viable — applied to org design as an alternative to product/autonomous-team framing.

An agent-architecture principle that separates what an agent knows (a declarative knowledge base) from how it reasons (an explicit, composable procedure defining what to examine, what knowledge to load at each step, which decision procedure to follow, and when analysis is complete) — enabling failures to be diagnosed as either a knowledge gap or a flawed procedure rather than treated as an opaque black box.

Using AI agents to simulate diverse end-user personas — with goals seeded from a target agent's own capabilities — that converse with a product agent to generate realistic multi-turn trajectories, used to test, evaluate, and (in privacy-restricted domains) train other agents before real users interact with them.

An AI-enabled entrepreneurial model where a founder orchestrates AI agents across many parallel low-cost ventures, contrasted with the lean startup's resource-scarce single-MVP discipline — the constraint shifts from access to scarce resources to founder attention and selection among abundant ones.

An LLM-driven orchestration layer that parses a natural-language business question, decomposes it into store-specific subqueries across heterogeneous specialized systems (graph, key-value, vector, warehouse, external API), executes them in parallel, and synthesizes a unified, source-attributed answer — leaving each store optimized for its own access pattern instead of consolidating data into a single store.

Lasch's cultural-criticism diagnosis (The Culture of Narcissism, 1979) of a self freed from social/institutional obligation but left fragile, empty, and dependent on external image/status-affirmation — the clinical Kernberg/Kohut sense, not vanity or arrogance.

Erikson's psychosocial concept (operationalized by McAdams & de St. Aubin) of concern for the next generation as a source of adult meaning — same word, different construct from generativity-team-contribution (workplace output-delta metric).

The discipline of measuring and sequencing precision vs. recall when tuning AI detectors/reviewers/triage agents, and the recurring pattern of articles reporting only one side while omitting the other.

The distinction between legitimate persuasion — engaging another person as a reasoning partner through honest reasons, respect, and compassion — and manipulation, which manages a target's psychology rather than their reasoning; the same technique can fall on either side depending on intent, context, and relational stance.

Using an LLM to grade another LLM's or agent's output against a rubric or human-labeled examples — a specific evals technique for subjective/non-deterministic quality dimensions, requiring judge-model selection, calibration against human labels (e.g. TPR/TNR), and drift monitoring to stay trustworthy.

The emerging pattern of abandoning Kubernetes' centralized, strongly-consistent coordination model (etcd, single scheduler) in favor of decentralized architectures — per-node sources of truth, parallel schedulers, optimistic accept/reject placement — to reach the millisecond-latency, million-instance scale AI-agent sandboxing demands.

The tendency for people and groups to offload factual/content knowledge onto their social network — remembering who knows something rather than the thing itself — trading individual content retention for network navigability; intensifies as connectivity and retrieval tools (search, AI assistants) make locating others' knowledge nearly free.

A three-category framework distinguishing distinct workplace stressors — too much work, unclear role expectations, and incompatible role demands — used to argue that 'stress' is often misdiagnosed as pure workload.

The deliberate choice to be mediocre or bad at specific, ranked-low dimensions of a product/service/role — not merely declining to do them — so that scarce resources concentrate on excelling at what customers value most; requires still doing the deprioritized thing, just not well, and sustained emotional tolerance for visible underperformance.

The discipline of selecting AI investments by anchoring them to a company's specific profit levers (value drivers), industry value-chain position, and income-statement lines — rather than generic, vendor-shared use cases — treated as the most overlooked, highest-leverage factor in converting AI spend into measurable financial return.

The design problem of making employee equity/ownership programs actually change behavior — translating an abstract equity stake into concrete, behavior-linked guidance (rather than broad values messaging) so employees see the causal link between daily actions and equity value; treated as primarily a communication/translation problem, not a weakness of equity as an incentive.

The more visible, public, shared work a person does, the larger the area of their life exposed to serendipitous career opportunity — publishing and sharing work durably (not just doing it) expands the chances of unplanned, valuable connections finding you.

A durable record of a long-running agent's objective, authorized scope, what has changed, supporting evidence, and open uncertainty — distinct from raw conversational memory, because an AI-generated summary can be accurate yet still omit exactly the detail that would change a human overseer's decision.

Madeleine Elish's term for when accountability concentrates on a human operator (e.g. the one who clicked "approve") despite actual control over the outcome being distributed across the wider sociotechnical system — the human absorbs blame disproportionate to the control they actually held.

The explicit contract a production agent harness must enforce so a non-deterministic model can't silently violate it — a single ordered commit path per mutable shared state, scoped and time-boxed approval objects rather than a vague memory of a click, bounded tool-call lifecycles, and a "receipt" that crosses the user-visible edge as proof of outcome, more trustworthy than a transcript or a tool's own self-reported success — turning standard distributed-systems discipline into boundaries an agent can't quietly cross.

The elevated voluntary employee departure rate that follows a company's regulator-sanctioned stakeholder violation, driven by employees inferring whether the incident is isolated or reveals the organization's true character — scaling with the violation's geographic breadth, recency, and novelty, and showing up in HR data only as unattributed 'normal' attrition rather than a measured cost of the misconduct itself.

The three-stage training pipeline (SFT on human demonstrations → reward model on preference comparisons → RL/PPO optimization against the reward model) that transforms a raw pretrained model into an instruction-following, safety-aligned assistant — originated in OpenAI's InstructGPT paper and still the conceptual foundation for post-training.

A security primitive giving an agent a short-lived, task-scoped authorization derived from (but distinct from) a human's identity — bundling delegation, policy, auditability, context, and time boundaries into one grant — replacing durable API keys/tokens as the target access model for agentic systems.