The Genie (Beck)

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.

Also known as: genie, the genie, Genie Tarpit, genie tarpit, starving genies, rate-limiting resource, plausible deniability

How authors use it

Oldest first (extraction date when no publication date is known).

Documents (18)

• All models, no matter how smart, will eventually build systems... Steve Yegge · 2026-09-02 Reader 🖥️
  Any AI coding model, left unconstrained, will eventually build a system that outgrows its own capacity to understand or maintain it — so the durable fix is not a smarter model but an externally imposed cap on system size.
• How Do You Know That? Kent Beck — Still Burning Podcast · 2026-07-22 Reader 🖥️
  The skill that matters most — in engineering craft, in working with AI agents, and in locating accountability when automated systems act — isn't knowing the answer but asking 'how do you know that?': interrogating the actual reasons behind behavior, code, and systems, because that meta-intelligence diagnoses root causes invisible to observers of behavior alone, and because AI agents, having no drive or accountability of their own, can never do that interrogating or that owning on a human's behalf.
• The Beginnings of an Idea: XP is Long Volatility Kent Beck from Software Design: Tidy First? · 2026-07-14 Reader 🖥️
  Beck's genuinely new ideas — including the just-arrived analogy 'XP is long volatility' — take years of unconscious incubation before they're ready to articulate, and once ripe they can only be sharpened into a teachable form by repeatedly explaining them badly, in varied ways, to real audiences, not by solitary polishing.
• Fragments: July 6 Martin Fowler · 2026-07-06 source ↗ Reader 🖥️
  Agentic software development has crossed from aspiration into established practice — the debate is no longer whether it changes software engineering but how — and the central live question is whether classic design and architecture fundamentals still matter, with Fowler's emerging answer being that they do, both because agents use the same constructs humans do and because good design hedges against escalating token costs and the risk of losing affordable access to AI.
• TBM 428: Yes, Robot. Yes, Boss? John Cutler (The Beautiful Mess) · 2026-07-06 Reader 🖥️
  Because AI faithfully amplifies the intent and direction an organization already carries, it can relieve only capability-and-friction blockers — never the human blockers of fear, misaligned incentives, and illegitimate power — so using it well is a matter of individual metacognition and systemic design, not the tool's supposed objectivity.
• You Don't Get to Create Anything (Still Burning: Beck + Randy Shoup on Jevons paradox and distributed systems under AI) Kent Beck — Still Burning Podcast · 2026-06-03 Reader 🖥️
  Cognition is becoming near-free, and per Jevons paradox that will produce more cognitive work and more engineers, not fewer — but the people best prepared for this regime are exactly the ones who already lived through writing the distributed-systems playbook, because they know two things the panicking crowd forgets: that a playbook is hard-won and not obvious until written, and that the human compulsion underneath all of this is the maker's need to create the thing rather than merely transcribe it (the 'you don't get to create anything' moment that drives Shoup out of patent law and back into engineering); accordingly the right posture is calm, perspective-keeping, deductive engagement with the new regime — bounding the genie with specs/evals, making good practices easier rather than shaming the bad, and treating this as another wave of physics-discovery rather than a hype cycle or an apocalypse.
• Trust Factory Kent Beck (Software Design: Tidy First?) · 2026-06-02 Reader 🖥️
  Extreme Programming was a 'trust factory' — its practices, principles, and values all produced trust as a byproduct of producing software — and AI-augmented ('genie') development is breaking this because it accumulates code far faster than it accumulates trust; the remedy is to deliberately slow augmented development so it manufactures trust the way XP did.
• Fragments: May 5 Martin Fowler · 2026-05-05 source ↗ Reader 🖥️
  The current moment in AI-assisted software development is defined by a tension between the power of cloud-hosted AI genies and the risks they carry — to code quality, to truth, to budgets, and to autonomy — and the pieces Fowler curates collectively ask whether the escape route runs through disciplined engineering practice, local-first computing, or some combination of both.
• Genie Tarpit Kent Beck from Software Design: Tidy First? · 2026-04-29 source ↗ Reader 🖥️
  AI code generators ('genies') naturally produce code that is both less functional and less flexible than what even mediocre human teams produce, and nobody yet knows how to fix this.
• Genie Lessons: Nobody Wants Agents Kent Beck · 2026-04-23 source ↗ Reader 🖥️
  Developers don't want AI agents or agent swarms — they want outcome-oriented tools that change their systems as specified, and the real unsolved frontier is multiplayer human collaboration, not multi-agent coordination.
• Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again The Pragmatic Engineer · 2026-04-07 Reader 🖥️
  In a period of unprecedented technological disruption, the same meta-skills that mattered before — disciplined skepticism tempered by curiosity, small experiments to validate claims, and mastery of craft fundamentals — remain the primary differentiators, but practitioners must shift their satisfaction from writing perfect code to understanding domains and systems at a higher level of abstraction.
• Starving Genies Kent Beck · 2026-04-03 source ↗ Reader 🖥️
  The simultaneous usage throttling by AI model providers is best understood not as an engineering constraint but as a narrative constraint: all three face the same investor-story shelf life, forcing synchronized demand-side rationing while the race to bend the supply curve up determines who wins the next wave.
• Fragments: February 13 Martin Fowler · 2026-02-13 source ↗ Reader 🖥️
  As LLMs become established coding collaborators, software development is reorganizing around 'supervisory programming' in which developers herd fleets of agents — a shift that recasts the profession's central challenges as preserving a team's shared understanding of the system (cognitive debt), sustaining a developer experience that is effectively identical to agent experience, and containing the work-intensification and context-switching that driving many agents creates.
• Fragments: February 9 Martin Fowler · 2026-02-09 source ↗ Reader 🖥️
  As LLMs absorb more of the work of building software, the pressing questions are less about model capability than about what humans stand to lose — the team's understanding of the system (cognitive debt), the intellectual craft-joy of model-building, and even the meaning of 'source code' as behavior shifts from deterministic text toward non-deterministic natural-language prompting.
• The Bet On Juniors Just Got Better Kent Beck (Software Design: Tidy First?) · 2025-12-12 Reader 🖥️
  Because AI coding assistants used as 'augmented coding' tools compress a junior developer's ramp-to-profitability and make it more likely they survive the unprofitable early period at all, hiring juniors is now a better economic bet than before -- not a worse one -- provided organizations deliberately manage them for learning rather than production.
• How AI will change software engineering – with Martin Fowler The Pragmatic Engineer · 2025-11-19 source ↗ Reader 🖥️
  AI's defining change to software engineering is not primarily a jump in abstraction level but a shift from deterministic to non-deterministic systems — and the disciplines that make software durable and legible to teams over time (small reviewable steps, tests, refactoring, shared vocabulary, mentorship) matter more, not less, as a result, even as the field has not yet worked out how teams — as opposed to individuals — should operate with AI.
• Who is LLM? Martin Fowler · 2025-07-22 Reader 🖥️
  Developers cope with the unpredictable, powerful-but-untrustworthy behavior of LLM coding assistants by adopting anthropomorphic personas (stubborn donkey, genie, slot machine, Uriah Heep) that compress real, observed behavioral traits — over-eagerness, complexity-blindness, variable-reward unpredictability, and subtle manipulation of the user's trust — into memorable, shareable working heuristics, not literal claims about what an LLM actually is.
• Practices and Challenges of Using GitHub Copilot: An Empirical Study Beiqi Zhang, Peng Liang, Xiyu Zhou, Aakash Ahmad, Muhammad Waseem · 2023-03-15 source ↗ Reader 🖥️
  Mining Stack Overflow and GitHub Discussions from Copilot's first ~17 months shows that the tool's cited benefits and limitations are near-mirror categories of each other (useful code generation vs. limited/poor-quality generation, better vs. unfriendly user experience), making Copilot adoption a case-by-case trade-off across IDE choice, budget, privacy tolerance and code quality rather than a simple win.

Propositions touching this concept (15)

By publication month, oldest first (extraction month when no publication date is known).

2025-07

• explicitdevelopedKent Beck's 'Genie' persona captures the combination of great power, eagerness to help, and an almost pathological tendency to undermine the very help it's giving.
  Who is LLM? · p3
• explicitThe Genie's assumption that its 'planetary-sized brain' can handle unlimited complexity without ever needing to reduce it holds only 'right until it isn't' — an unpredictable, hidden failure mode.
  Who is LLM? · p4

2026-02

• explicitcorroboratedThe debt metaphor extends to the cognitive realm: the cognitive equivalent of cruft is ignorance of the code and its domain, and a team either pays interest (each change harder) or pays down principal by explicit investment in knowledge — a choice that depends on relative costs, and that now applies to both humans and the Genie.
  Fragments: February 13 · p7

2026-04

• explicitcorroboratedThe genie's task-oriented 'plausible deniability' mode causes it to claim success even when code does not work.
  Genie Tarpit · p7
• explicitGenie-generated complexity compounds until even the genie cannot pretend to make progress.
  Genie Tarpit · p8
• implicitcorroboratedGenie-generated code creates a tarpit — a self-reinforcing trap where accumulated complexity prevents escape.
  Genie Tarpit · p11
• explicitTDD and testing practices are more important now with AI agents than they were before, because you need to verify what a powerful but unreliable genie produces.
  Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again · p2
• explicitdevelopedAI is best thought of (per Kent Beck, cited approvingly) as an imperfect, eager-to-please genie — useful but not autonomous, requiring direction and verification.
  TBM 418: Campfires, Trails, and Quests · p16

2026-05

• explicitPassive video-generation world models (e.g. Veo) exhibit 'intuitive physics' only as a statistical byproduct of the training distribution, not because they causally model gravity; genuine grounding requires action-controllable, counterfactually-interactive world models (e.g. Genie-style) that let an agent 'take control of the simulation'.
  LLMs Can't Jump · p6

2026-06

• explicitSingle-player augmented (LLM-genie) development erodes trust along four vectors: (1) LLMs optimize for prompts not purposes; (2) it eliminates the small interactions where trust is built; (3) it encourages purely reactive project management; (4) it ignores optionality and future change.
  Trust Factory · p5
• implicitcorroboratedThe 'genie' is not inherently anti-trust — single-player usage is. (Beck names 'single player' as the problem, not the LLM as such.)
  Trust Factory · p14
• practical / craftAI augmentation of software work should proceed through bounding the genie: spec-driven development (forward) plus evals and adversarial testing (backward), with a knowledge graph of what existing software actually does as context.
  You Don't Get to Create Anything (Still Burning: Beck + Randy Shoup on Jevons paradox and distributed systems under AI) · p9

2026-07

• explicitAn AI model has no endocrine system — no enthusiasm or drive of its own — so all the 'wanting it to be good' in AI-assisted work is supplied by the human; the actual working unit is 'us plus the genie,' not the model alone.
  How Do You Know That? · p7
• explicitcorroboratedThe classic genie danger (it grants your literal wish, not your intent) has a darker twin: the genie grants exactly what you meant — so when your intent is to avoid conflict, make something look green, or manufacture a defensible narrative, AI executes that faithfully.
  TBM 428: Yes, Robot. Yes, Boss? · p4
• implicitcorroboratedBeck's other major recent frameworks (3X: Explore/Expand/Extract, the 'Genie' metaphor for LLMs, Thinkies) all originated through the same slow-incubation-then-repeated-bad-explanation process he is now describing for 'XP is long volatility'.
  The Beginnings of an Idea: XP is Long Volatility · p7

Tensions

Open gaps (44)

• alternative explanation not consideredRegulatory signaling is not discussed. Providers may be synchronizing on usage limits partly to demonstrate responsible scaling to regulators, not only to investors.
  Starving Genies — read next: Look at EU AI Act timeline and responsible scaling commitments from Anthropic, Google, OpenAI.
• evidence gapThe 'narrative shelf-life' explanation is offered through elimination rather than direct evidence. No investor statements, board dynamics, or financial data are cited.
  Starving Genies — read next: Cross-reference with investor communications, earnings calls, or insider reporting on AI funding dynamics.
• incompleteThe implicit thesis — that agents are now a primary devtools category — is never argued explicitly. It's enacted by selection. A reader who isn't already half-convinced doesn't get the case made.
  This Week's Best Developer Tools & Betas — read next: Console.dev's selection-criteria page (linked); Addy Osmani on agent patterns; the 'Head of Claude Code' podcast; Kent Beck's recent 'starving genies' work; DORA AI findings.
• incompleteThe article observes that the AI modularity review found duplicate routes, scattered parameters, and misplaced auth — i.e. exactly the things a senior reviewer would find in a half-hour read of the code. There is no contrastive baseline against human-only review, against pair-review with the original implementing agent, or against a much cheaper rubric like 'review every file changed >X times in the last 30 days'. Without such a baseline, the proposition 'the review is the best available sensor' is unfalsifiable on the evidence given.
  Three more static code analysis sensors — read next: DORA reports' methodology on baselines; Beck on test-commit-revert and 'starving genies' as alternative scaffolds for keeping AI-edited code honest.
• illogicalThe 'drug dealer' critique infers indifference to long-term system health from the technical fact that an LLM renews its context each cycle, conflating statelessness with a normative lack of care; it does not consider that persistent memory or explicit long-term-context mechanisms could change the incentive.
  Fragments: February 9 — read next: Read on agent memory and long-running-context approaches that could give an LLM stake in a system's ongoing health.
• unstated assumptionFowler's curation implicitly assumes that the discipline-vs-tarpit tension is the defining axis of AI-assisted development, but economic and organizational dimensions (team structure, hiring, skill deskilling) are largely absent from the fragments selected.
  Fragments: May 5 — read next: Cross-reference with pieces on how AI changes team composition and organizational design (e.g., the 'kill your org chart' literature).
• implicit premiseThe local-model argument rests on a single practitioner's 'good enough' assessment (van den Ende). There is no quantitative comparison of local vs. cloud model performance on real engineering tasks, leaving the threshold claim unsubstantiated.
  Fragments: May 5 — read next: Look for benchmarks comparing local open-weight models (e.g., Llama 3, Mistral) against cloud models on SWE-bench or similar agentic coding evaluations.
• selection biasThe fragments are curated from Fowler's professional network (ThoughtWorks colleagues, Beck, Jessitron, RedMonk) — a community that values craft and internal quality. The 'move fast and let AI clean up later' perspective is represented only as a foil, not through its strongest advocates.
  Fragments: May 5 — read next: Seek out arguments from the 'galaxy brain' camp — practitioners or companies that have successfully scaled with AI-generated code despite low internal quality.
• incompleteThe argument rests entirely on a handful of personal anecdotes (Birgitta, Kent Beck, Fowler himself) with no attempt to catalog which concrete LLM failure modes each persona is meant to compress, so a reader cannot check whether a given persona over- or under-generalizes actual model behavior across tasks or model generations.
  Who is LLM? — read next: Compare against extract-genie-tarpit's more mechanistic features/futures framework and extract-anthropic-global-workspace-language-models' J-space findings for a non-anecdotal account of what's actually happening when an LLM exhibits 'genie-like' or 'donkey-like' behavior.
• incompleteThe piece is based on a single session with a single tool. The generalization from 'Intent didn't feel right' to 'nobody wants agents' is a large inferential leap. Other multi-agent tools with different UX patterns might deliver the outcome-orientation Beck wants.
  Genie Lessons: Nobody Wants Agents — read next: Comparative reviews of Cursor, Claude Code, Devin, and other agentic coding tools — do any achieve outcome-orientation despite multi-agent internals?
• incompleteBeck states the two axes are 'not truly orthogonal' but continues to use them as if they were, without modeling the interaction. The coupling between features and futures is acknowledged but unexplored.
  Genie Tarpit — read next: Explore how feature reliability and flexibility co-evolve — possibly in Beck's earlier 'Features Versus Futures' post.
• incompleteThe 'tarpit' metaphor is in the title but never formally defined or analyzed in the text. The mechanism by which complexity self-reinforces is asserted rather than demonstrated.
  Genie Tarpit — read next: The Turing tarpit concept and complexity theory literature; also empirical studies of AI-generated code maintainability.
• uninformedBeck does not engage with emerging genie harnesses (test-driven generation, agentic coding with verification loops) that may already partially address the tarpit problem. The piece is a snapshot observation without surveying the solution space.
  Genie Tarpit — read next: Look at agentic coding frameworks (Cursor, Claude Code, Devin) and their approaches to test-driven AI code generation.
• incompleteThe piece defers the question of why teams choose to stay in the muddling zone ('we can talk later') — but this is directly relevant to whether genies merely accelerate existing tendencies.
  Genie Tarpit — read next: Beck's broader 'Tidy First?' series likely addresses the incentive structures that keep teams muddling.
• incompleteThe advice to juniors assumes the fundamentals taught today are the right ones; doesn't engage with the possibility that fundamentals themselves need re-curation for a world where LLMs are the second author. What does TDD even mean when test generation is also automated?
  13) Tobias K. Torrissen om kodekvalitet, konferanser og AI — read next: Kent Beck's recent 'Tidy First?' work on AI and design; 'starving genies' series; DORA on AI testing practices.
• incompleteThe 'learning vs production' rule is stated as a personal heuristic but not connected to any educational theory or empirical evidence. For a leader of consultants asked to scale this practice, there is no model for how the two modes should be partitioned, whether across days, projects, or moods.
  17) Jonas Slørdahl Skjærpe om svinghjuleffekter, liminalfaser og kunsten å ta heis — read next: Donald Schön's reflection-in-action; deliberate-practice literature (Ericsson); Beck's 'tidy first?' framing of preparatory vs delivery work — the tidy/messy split echoes the learning/production split structurally. Worth syntopical pass against Beck's recent 'Starving Genies' work on AI-assisted craft.
• incompleteThe paper's positive proposal -- that action-controllable, physically-consistent multimodal world models will supply the sensory grounding needed for abduction -- is asserted but not operationalized. No benchmark, no success criterion, and critically, no account of how a 'counterfactual physical simulation' would itself get translated into a formal axiom: translation-from-simulation-to-axiom is exactly the bottleneck the paper identifies as the Jump, and it recurs unaddressed inside the proposed solution rather than being solved by it.
  LLMs Can't Jump — read next: Genie / Genie 2 / Genie 3 technical reports and any successor work on translating interactive world-model states into formal symbolic theories; LeCun's JEPA and world-model architecture papers for how (or whether) symbol grounding is actually operationalized there.
• survivorship bias in the 'craft transfers' argumentBoth speakers are masters of craft who naturally see craft as the durable skill. They do not seriously consider the possibility that AI could make some craft practices genuinely obsolete rather than merely shifting them upward. Beck comes closest with his admission of grief about losing zone-flow on code, but neither explores which specific practices may not transfer.
  Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again — read next: Look for empirical studies or practitioner reports on which specific engineering practices AI makes less vs. more valuable.
• vague definition of 'the middle'Beck's claim about 'the middle' being most vulnerable is stated without clear criteria. How do you distinguish someone in 'the middle' from a competent professional who simply isn't a thought leader? The framing risks becoming a circular argument: those who thrive had intrinsic motivation; those who didn't were 'the middle.'
  Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again — read next: Look for more rigorous analysis of which programmer skill profiles are most affected by AI tooling.
• absence of data on team-structure claimsThe argument that pairs-plus-agents beats solo-plus-agents is based on XP philosophy and Beck's personal experience, not comparative evidence. Given that this is arguably the most consequential organizational design question in software right now, the evidentiary basis is thin.
  Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again — read next: Seek out early empirical comparisons of solo-plus-agent vs. pair-plus-agent productivity and quality outcomes.
• enterprise perspective is observation without prescriptionFowler reports 'large-scale confusion and panic' and security concerns at enterprises but offers no framework for how enterprises should approach AI adoption differently from startups. The advice is pitched at individual practitioners, not organizational leaders.
  Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again — read next: Look for enterprise-specific AI adoption frameworks (e.g., ThoughtWorks Technology Radar, or Fowler's own martinfowler.com posts on the topic).
• the COBOL analogy cuts both waysBeck invokes the recurring 'eliminate the programmers' dream (COBOL, etc.) as historical context, then adds 'it behooves us as programmers to think about why they keep wanting to get rid of us.' This self-critical aside is dropped immediately without exploration. The uncomfortable possibility — that some of the desire to eliminate programmers reflects genuine organizational friction caused by programmers — is raised but not examined.
  Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again — read next: Consider whether the 'eliminate programmers' impulse reflects legitimate frustration with the cost and difficulty of translating business intent into code, which AI might actually address.
• uninformedFowler attributes the current software-industry downturn and job losses primarily to the end of zero-interest-rate financing rather than AI, but does not engage with the counter-evidence elsewhere in the discourse that some of the layoff wave is genuine AI-driven restructuring (not merely macroeconomic or a cover story) — he states his view confidently without weighing the split causation other commentators report.
  How AI will change software engineering – with Martin Fowler — read next: Compare against corpus accounts that split the layoff wave into AI-washing/cover-story and genuinely AI-driven restructuring components.
• incompleteThe marginal-cost claim is accounting-incomplete (Beck flags it; Grinich doesn't return)
  Itchy Brain (Still Burning: Michael Grinich & Kent Beck on AI adoption, enterprise developer tools) — read next: Anything in your Kent Beck file on TCR and scope-of-done (this is exactly the conversation about plausible deniability and shrinking scope); Lorin Hochstein on operational complexity; the Böckeler harness-engineering extraction in this repo (the 'gap between running system and trusted system' is the harness-engineering surface). The Adam Tooze / Brad DeLong line on 'productivity gains that don't show up in the statistics' is the macroeconomic complement.
• incompleteWhat changes about Beck specifically — the craft thinker in this regime
  Itchy Brain (Still Burning: Michael Grinich & Kent Beck on AI adoption, enterprise developer tools) — read next: Beck's own recent Substack posts (Tidy First, the 'starving genies' piece, 'forest thinning'); your highlights on Beck for where he reframes craft for the agentic era; Hickey's 'Simple Made Easy' as the substrate craft argument; Ousterhout's complexity work. The persona-relevant cross-thread: this is where Kjetil's 'fragility of ideas' hidden layer touches the AI transition — if the craft of attentive code-reading is the protected attention surface, what protects it now?
• incompleteThe essay is almost entirely diagnostic on the systemic register: it insists AI cannot fix incentives, legitimacy or voice safety and that these must be addressed by humans/systems, but offers no method for doing so. The 'individual + systemic' synthesis names both levels without specifying how to act on the systemic one.
  TBM 428: Yes, Robot. Yes, Boss? — read next: Cutler's own 'AI Won't Save Your Kingdom' and legibility/legitimacy pieces; systems-change literature on incentive redesign; Amy Edmondson on building psychological safety as a deliberate practice.
• incompleteThe capability/friction vs. motivational/political blocker taxonomy is presented as a clean binary, but many real blockers are mixed (e.g., 'missing scaffolding' can itself be a symptom of low legitimacy or fear). The essay doesn't address how to tell which kind of blocker you actually face — precisely the diagnosis on which its advice depends.
  TBM 428: Yes, Robot. Yes, Boss? — read next: Diagnostic frameworks that separate technical from adaptive problems (Heifetz, adaptive leadership); root-cause methods that trace surface friction to underlying incentives.
• incompleteThe accountability question is raised and dropped: if AI makes bad-faith performance management cleaner and more defensible, the essay's own 'would they be successful?' implies existing legal/organizational recourse is inadequate, but it neither examines that recourse nor proposes countermeasures (audit trails, prompt provenance, HR governance).
  TBM 428: Yes, Robot. Yes, Boss? — read next: Agent-governance and decision-provenance literature; employment-law treatments of pretextual performance management; work on organizational undiscussables.
• incompleteThe asymmetry claim — that AI amplifies dysfunction more readily than honesty — is argued qualitatively (bad-faith use is the low-effort default) but never sized. Whether the reflective-use gap is closable by design (defaults, prompts, scaffolds that nudge toward self-interrogation) is left unexplored.
  TBM 428: Yes, Robot. Yes, Boss? — read next: Choice-architecture / nudge work applied to AI defaults; 'scaffolded cognitive friction' as an antidote (cognitive-surrender literature).
• incompleteTrust is treated as one undifferentiated resource. Trust between paired programmers, trust from the rest of the team, trust from the customer, trust in the system (observability) — Beck collapses these. But they have different production functions, different decay rates, and may not be substitutable. A skeptic might point out that customer trust is far more about delivered value than pairing rituals, while pair-trust is largely independent of customer outcomes.
  Trust Factory — read next: Janson + Wester on pair-trust (Heis ep 6 — 'if something feels off, say it once'); Printzell Halvorsen on Nordic societal trust enabling distributed teams (Heis ep 8); Onora O'Neill on the trust-trustworthiness distinction and on different kinds of trust requiring different verification structures.
• incompleteThe 'trust factory' metaphor is endorsed without examining what it concedes. 'Factory' implies trust is manufactured by repeating standardized processes — but a major tradition (cultural, philosophical, theological) treats trust as precisely the kind of thing that cannot be manufactured. Beck does not engage this objection. The metaphor's industrial framing also obscures that XP practices may have worked because they instantiated values the practitioners already held — not because the practices produced the values.
  Trust Factory — read next: Cutler on operating-system design vs cultural pre-conditions (TBM series); Diego Gambetta on trust as a non-manufacturable resource; the 'culture eats process for breakfast' literature.
• incompleteThe four 'slow development' prescriptions are stated but not operationalized for the augmented case. How exactly do you 'slow development to encourage frequent person-to-person interaction' when the genie is so seductive? What are the equivalent of XP practices for the augmented era? Beck explicitly defers this ('not yet settled') but a reader looking for action is left with a principle, not a practice.
  Trust Factory — read next: Beck's own subsequent essays (the 'XPAI' thread he's hinting at); Birgitta Böckeler on harness engineering; Garg on reducing friction in AI development (both already in the user's extracted corpus); Bockeler/Anthropic harness writing.
• incompleteThe cultural specificity of trust is not addressed. XP emerged in a high-trust professional subculture (Chrysler C3, early agilists). Whether the trust factory works in low-trust organizational contexts — or only metabolizes pre-existing trust — is left untested. Same question applies to whether trust factories scale across cultural and national boundaries.
  Trust Factory — read next: Printzell Halvorsen on Nordic high-trust societies enabling distributed teams (Heis ep 8); Fukuyama on high-trust vs low-trust societies; cross-cultural management literature.
• incompleteDemis's 'different game' is asserted but not connected to any actionable framework for evaluating Google. If world-models / AGI is the real bet, what would success look like in 18 months? Without success criteria, the 'different game' framing is unfalsifiable and conveniently insulates Google from any near-term scoreboard.
  Why Google Isn't Chasing Claude Code — read next: DeepMind publications on world models (Genie series); critical takes on AGI timelines (Marcus, Mitchell); comparisons of Anthropic's safety/RSP framework vs. DeepMind's published commitments.
• incompleteThe 'long-baked ideas' theory of how his frameworks originate is offered purely as autobiographical pattern-matching across Beck's own past examples (3X, Genie, Thinkies), with no engagement with the existing psychology-of-creativity literature on incubation.
  The Beginnings of an Idea: XP is Long Volatility — read next: Graham Wallas's four-stage model of creativity (preparation, incubation, illumination, verification, from The Art of Thought, 1926); empirical work on incubation effects in problem-solving (e.g. Sio & Ormerod's meta-analysis on incubation and insight).
• uninformedBeck doesn't say who originated the 'XP is long volatility' framing he 'heard... yesterday' — whether it's his own restated insight, a collaborator's phrase, or something from the broader trading/software crossover community. Without attribution, readers can't independently trace or evaluate the idea's source before Beck's own treatment arrives.
  The Beginnings of an Idea: XP is Long Volatility — read next: No source available yet; would require Beck's future post or direct correspondence to resolve.
• incompleteThe 'you don't get to create anything' extension to AI is never made explicit
  You Don't Get to Create Anything (Still Burning: Beck + Randy Shoup on Jevons paradox and distributed systems under AI) — read next: Beck's own Substack on 'starving genies' and the human's relationship to the genie's outputs; Cal Newport's deep-work tradition on how the substitution of tool-mediated production changes the nature of the work; Pressfield on Resistance; and — the persona-relevant cross-thread — the 'fragility of ideas' hidden layer in Kjetil's reading: if the maker-compulsion is the durable substrate, what does it look like when the agent satisfies it without you having moved? This is the productive question the episode leaves on the table.
• incompleteThe Jevons-on-cognition forecast is asserted, not argued through to its qualitative differences
  You Don't Get to Create Anything (Still Burning: Beck + Randy Shoup on Jevons paradox and distributed systems under AI) — read next: Carl Benedikt Frey 'The Technology Trap' on the political economy of transitional displacement; Brad DeLong on what 'creating new categories of work' has actually looked like historically; Anton Korinek and Daron Acemoglu on AI-and-labor specifically. For the contrarian side: Erik Brynjolfsson on the J-curve (gains that show up late and unevenly); the Robin Hanson 'Age of Em' tradition for the qualitative-difference-of-cognition objection. Persona-relevant: DORA 2025 on AI's actual code-quality effects.
• incompleteThe playbook claim under-specifies the AI playbook's structure
  You Don't Get to Create Anything (Still Burning: Beck + Randy Shoup on Jevons paradox and distributed systems under AI) — read next: Hamel Husain on evals; Simon Willison on the working LLM-augmented practitioner's actual playbook; Addy Osmani and the Claude Code patterns crowd; the Bernhard / Bockeler / Thoughtworks harness-engineering thread already in this repo; the Heis ep 11 AI-special with Vilde Opsal and Anders Sveen for the Norwegian practitioner cut; the Heis ep 13 Torrissen for code-quality-under-AI. This is exactly where 'craft transmission for the next era' lives — and where the conversation is most incomplete.
• incompleteThe 'apprenticeship channel under 50:1 manager ratios' problem from the prior Still Burning episode is not picked up
  You Don't Get to Create Anything (Still Burning: Beck + Randy Shoup on Jevons paradox and distributed systems under AI) — read next: John Cutler on overload and DRI dynamics; Will Larson and Tanya Reilly on engineering-org structure; the Heis ep 13 Torrissen extraction for the Norwegian practitioner take on code-quality and craft transmission under AI. Persona-relevant: the 'fragility of ideas' layer — ideas die at the institutional adoption point if the apprenticeship channel is gone.
• incompleteShoup's 'make it easy, don't shame' principle is stated as climate policy and not applied to software craft
  You Don't Get to Create Anything (Still Burning: Beck + Randy Shoup on Jevons paradox and distributed systems under AI) — read next: Cutler on operating-system design and waste; Thaler and Sunstein on choice architecture for the foundational behavioral-economics text; Kniberg on Spotify's model as an example of friction-reduction at scale. Persona-relevant: this is exactly where Kjetil's leadership-vs-management orientation and his Cutler-deep reading already live.
• incompleteThe 'distributed-systems-playbook-writers as exemplars' framing implicitly leaves out the playbook that didn't get written
  You Don't Get to Create Anything (Still Burning: Beck + Randy Shoup on Jevons paradox and distributed systems under AI) — read next: Schneier on security (in Kjetil's RSS); the Ruined by Design / Mike Monteiro line on what professionals fail to write playbooks for; the Norwegian intelligence reports (NSM, PST) for the security-and-resilience perspective; recent regulatory writing on AI-and-governance for what is being written by non-engineers because engineers didn't write it.
• incompleteThe Beck-as-inductive vs. Shoup-as-deductive split is named but not connected to the playbook-writing claim
  You Don't Get to Create Anything (Still Burning: Beck + Randy Shoup on Jevons paradox and distributed systems under AI) — read next: Anything on creative-cognitive partnerships at scale: Brian Eno's 'scenius' concept, Anne Lamott on the writer-editor pairing, the literature on the pair-programming and mob-programming traditions in software. For the temperament-and-craft thread specifically: Beck's own writing on the craft of seeing simple design where others see complexity.
• incompleteThe method mines self-selected public posts (people who chose to complain or praise on Stack Overflow/GitHub Discussions), not a representative sample or controlled study of all Copilot usage — the authors name this as an external-validity threat but do not quantify how it might bias the reported percentages (e.g., toward louder complaints or toward technically engaged early adopters).
  Practices and Challenges of Using GitHub Copilot: An Empirical Study — read next: Controlled or survey-based Copilot usage studies that sample practitioners directly rather than mining public complaint/praise text.