Thoughts, Not Thinking?
Kent explores the tension between contributing to conversations in real-time versus developing fully-formed opinions. For senior engineers balancing mentorship, code review, and technical leadership, knowing when to speak up mid-thought versus when to stay silent shapes team dynamics and decision quality.
Read on Substack ↗Adaptive Radix Tree
Tries offer an alternative to BSTs and hash maps for sorted iteration: walk keys byte-by-byte instead of comparing them. This tutorial builds an Adaptive Radix Tree from first principles, adding one optimization per chapter until you understand both the tradeoffs (cache locality vs. sparse keysets) and the production implementation.
Read on Substack ↗Run, Right, and Fast for the Adaptive Radix Tree
Data structure performance isn't just about raw speed—it's about matching implementation complexity to your actual constraints. This essay explores how the Adaptive Radix Tree exemplifies the tension between running fast, getting it right, and staying flexible enough to evolve as requirements change.
Read on Substack ↗Genie Tarpit
AI code generators trained on mediocre code produce plausible-looking but inflexible output that degrades over time—a "genie tarpit" that sacrifices long-term changeability for short-term feature delivery. The gap between working code and maintainable code is where most teams get stuck, but genies tend to default even further left, into complexity that collapses under its own weight.
Read on Substack ↗Genie Lessons: Nobody Wants Agents
Multi-agent swarms promise to automate coding, but they often shift the coordination burden from the system to the engineer. What actually matters is outcome-orientation — describing the result you want and getting back feasibility and cost — not managing which agent does what. The real frontier is multiplayer augmented development where humans collaborate in real-time, not swarms that require orchestration.
Read on Substack ↗Passing Tests Bore Me
Passing tests should confirm you've solved the problem, but they often feel hollow—a sign that your tests aren't surfacing real design decisions or catching genuine mistakes. This mismatch suggests your test suite is validating implementation rather than behavior, leaving the actual craft of software design invisible.
Read on Substack ↗Extreme Time Value of Money: Late-stage Career Planning
As you progress in your career, the time value of money shifts—long vesting schedules and deferred equity that make sense at 30 become economically irrational at 60. Kent Beck applies financial first principles to explain why late-career engineers should negotiate differently, and why tech compensation structures systematically disadvantage older developers.
Read on Substack ↗Parkinson's
Kent Beck announces a Parkinson's diagnosis and reframes his priorities around what he calls "the time value of time"—the insight that activities become exponentially more valuable when done sooner rather than later. Rather than retreat, he's doubling down on work that matters to him, rejecting high-paying opportunities that would consume his best years, and accelerating projects in coding, writing, and creative work.
Read on Substack ↗The Bridge: Too Far
Connection requires both people meeting halfway — not one person crossing entirely to the other's side. When you find yourself overgiving to force intimacy, or when someone instantly gives too much without boundaries, you're seeing a red flag. Sustainable relationships depend on mutual pacing and respect for each person's limits.
Read on Substack ↗Potpourri: Lessons from an AI Leadership Conference
Kent reflects on patterns from an enterprise AI leadership conference, connecting lessons about organizational change and risk management to principles that worked in extreme programming. For teams adopting AI tooling at scale, the friction points aren't primarily technical—they're structural and cultural.
Read on Substack ↗Starving Genies
The constraint isn't compute or capital—it's narrative. When AI companies hit the limit of investor patience with "trust us, profits later" stories, usage caps become synchronized signals of managed growth toward profitability. The real competition is who bends the supply curve up first through cheaper inference, better silicon, or unit economics that let them remove caps while competitors can't.
Read on Substack ↗Genie Sessions: TCR Skill
Test & Commit or Revert (TCR) eliminates broken code by auto-reverting failed tests—but manual resets kill flow. By pairing TCR discipline with AI Skills (like Claude's function calling), you can automate the revert-and-retry loop, letting the genie handle syntax errors and false starts while you focus on design decisions. This blend turns TCR from a rigorous practice into a practical, AI-augmented workflow.
Read on Substack ↗Tremors
Software systems exhibit fragility patterns that mirror seismic activity—minor perturbations propagate unexpectedly through coupled components, revealing hidden dependencies. Understanding these tremors helps teams identify brittleness before it compounds into cascading failures.
Read on Substack ↗Why Your Progress Is About The Same As Everyone Else's
Progress feels invisible because you're comparing against survivorship bias—the engineers you see succeeding publicly aren't representative of the full distribution. Understanding how to measure your own growth against realistic baselines, rather than curated examples, changes how you evaluate career momentum and skill development.
Read on Substack ↗Forest Thinning
Gridlock persists when feedback loops punish the behavior you need. By restructuring incentives—paying for future outcomes instead of immediate extraction—you flip inhibiting loops into reinforcing ones, transforming adversaries into collaborators with aligned interests. This principle applies anywhere incentive misalignment creates systemic dysfunction.
Read on Substack ↗A few questions about what you're working on...
Kent Beck solicits direct feedback from his audience about their real technical challenges and priorities. This approach shapes what gets written next, ensuring the work stays grounded in the problems senior engineers face rather than assumptions.
Read on Substack ↗Genie: Death of the Iron Triangle?
The traditional project iron triangle forces tradeoffs between speed, cost, and quality. AI pair programming may fundamentally alter this constraint by automating routine coding work, but only if teams understand what actually changes — and what still requires human judgment.
Read on Substack ↗Don't Accomplish Everything
Management incentives that work for scaling existing systems (Extract) actively discourage the learning and discovery needed in exploration phases (Explore). Kent Beck's P50 goal framework shows how Facebook aligned performance expectations with the actual work: in exploratory phases, finishing all goals signals you weren't ambitious enough or learning enough to adapt; in extraction phases, that same approach creates dangerous surprises across dependencies.
Read on Substack ↗Earn *And* Learn
Kent Beck distinguishes two fundamentally different games in software development: The Finish Line Game (optimize for a single outcome, then stop) and The Compounding Game (build systems that earn resources for the next iteration indefinitely). Most spec-driven and AI-assisted development assumes the former; sustained product growth requires the latter, demanding equal investment in futures—the architectural and design work that keeps complexity manageable—as in features.
Read on Substack ↗Genie Session: Codex for Mac/GPUSortedMap
Kent explores a live coding session using Codex to implement GPUSortedMap, demonstrating how AI-augmented development shifts the rhythm of design and implementation. Rather than planning exhaustively upfront, you can sketch intent and let the AI help you discover the design through interaction.
Read on Substack ↗Generation Gap or Just Rude?
Generational gaps in software teams often mask simple communication breakdowns rather than fundamental incompatibility. Understanding where misunderstanding comes from—rather than assuming rudeness or disrespect—helps senior engineers lead more effectively across age groups.
Read on Substack ↗Labor Replacement is a Poison Pill
Framing AI's economic value around labor replacement is strategically shortsighted for software teams. The real leverage comes from augmentation—amplifying engineer capability and decision-making—not headcount reduction, which destroys institutional knowledge and team cohesion.
Read on Substack ↗Is Source Code Going Away?
As AI code generation tools mature, the question isn't whether machines will write code—it's whether humans will need to read and reason about source code at all. Beck explores what gets lost if code becomes a machine-to-machine artifact rather than a medium for human communication and understanding.
Read on Substack ↗The Pinhole View of AI Value
Labor replacement captures only one dimension of AI's economic impact. By expanding service capacity, accelerating revenue timing, deferring costs, and creating new market options, AI-augmented teams unlock value that pure headcount math misses—and often unlocks it faster than cost-cutting alone.
Read on Substack ↗Can Genies Break Down Silos?
AI-augmented coding can break down knowledge silos by making expert patterns visible across teams—but only if you design the collaboration deliberately. Beck explores how AI assistants amplify shared understanding when teams use them as a medium for making tacit knowledge explicit.
Read on Substack ↗Genie Sessions: Optionality
When working on novel algorithmic problems, AI excels at generating and testing multiple solution approaches quickly — letting you maximize learning by trying many directions and discarding failed experiments. This live session demonstrates how optionality in code exploration, rather than premature optimization toward a single solution, can accelerate both understanding and discovery.
Read on Substack ↗Tidy Together Reboot
Refactoring as a team practice requires explicit coordination and shared standards to avoid the friction of conflicting changes. This essay explores how teams can establish rhythms for tidying code together—making it a sustainable part of the development cadence rather than a bottleneck or afterthought.
Read on Substack ↗Taming the Genie: "Like Kent Beck"
Personas improve micro-behaviors like testing style and naming, while architectural constraints shape macro-decisions like class hierarchies. The combination—explicit persona plus design guidance—produces the best results, but the real leverage comes from running millions of design contests to evolve coding practices through selection pressure rather than encoding human expertise.
Read on Substack ↗Bridges
Kent Beck applies a bridge-building model to human connection and design collaboration: you construct the bridge unilaterally, walk halfway across by sharing something real, then stop and wait. If the other person meets you at the midpoint, connection deepens; if they don't move, you've protected yourself from overexposure. This framework explains why forcing consensus through conviction fails and why patience in collaboration isn't passivity—it's a disciplined practice that prevents both manipulation and isolation.
Read on Substack ↗My Fitbit Buzzed and I Understood Enshittification
When individual contributors need metrics to prove value, they optimize for measurable engagement over user experience. This creates a predictable cycle: notification added to measure feature adoption, users annoyed, setting buried to preserve metrics, product gradually becomes hostile. The mechanism isn't malicious—each decision is locally rational—but the cumulative effect is enshittification.
Read on Substack ↗The Precious Eyeblink
Modern tools optimize for completeness over speed, leaving engineers waiting through delays that shatter focus. The Doherty Threshold—established in 1982—shows that feedback arriving after 400 milliseconds starts pulling attention away from the task. Fast, partial answers that keep you in flow beat slow, perfect ones that don't.
Read on Substack ↗Party of One for Code Review!
Code review as practiced today assumes synchronous collaboration between humans—an assumption that breaks under AI-augmented development. Kent Beck explores what code review actually needs to accomplish when working solo with an AI pair programmer: sanity-checking intent versus implementation, and maintaining structural integrity so both human and machine can keep working effectively.
Read on Substack ↗The Bet On Juniors Just Got Better
AI-augmented coding shrinks the "valley of regret"—the unprofitable period before juniors break even—from 24 months to 9 months, cutting attrition risk by more than half and improving the economics of junior hiring dramatically. The bet only pays off if you manage for learning, not production, and teach juniors to use AI as a search-space collapsing tool, not a vibe-coding shortcut.
Read on Substack ↗Explore *Then* Expand *Then* Extract
Pre-emptive performance tuning during product exploration wastes resources and slows experimentation. Kent Beck argues for a three-phase approach—explore for product-market fit, expand by fixing bottlenecks as they emerge, then extract maximum profit—where optimization happens only when real usage patterns demand it, not speculative architecture.
Read on Substack ↗Monday - Last Call on $180/Year
Kent Beck's newsletter offers senior engineers curated writing on software design, test-driven development, and AI-augmented coding at annual pricing. This is the final opportunity to lock in $180/year pricing before rates increase.
Read on Substack ↗Tidying: Canonical Order
Canonical order—establishing a consistent, intentional arrangement of code elements—reduces cognitive load and makes intent visible. Rather than reorganizing code reactively, defining an explicit order upfront lets teams communicate standards through structure itself, turning tidying from subjective preference into a reliable design tool.
Read on Substack ↗If You've Been Thinking About Subscribing to Premium...
Kent Beck is working through what safety means when machines can code—exploring how 10x speed increases reshape responsibility, coherence, and the skills that matter. Premium subscribers watch that thinking happen in real time through chat, early essays, and weekly patterns for creative problem-solving.
Read on Substack ↗Why Does Development Slow?
Development velocity inevitably declines as features accumulate because each new feature burns optionality—the flexibility to implement future features easily. The solution isn't to optimize both feature delivery and code quality simultaneously, but to rhythmically alternate: ship a feature, then invest in tidying to restore optionality before the next feature. This pattern holds whether you're coding alone or with AI.
Read on Substack ↗Intentions & Actions
Intention—what you meant to do—often diverges from action—what your code actually does. Git history, commit messages, and code review conversations expose this gap. Understanding this distinction sharpens both design decisions and how teams communicate about refactoring, feature work, and technical debt.
Read on Substack ↗Composable Tests
Isolation and composition are distinct test properties: isolation means each test sets up its own fixture independently, while composition means a suite of tests together provides predictive confidence even if individual tests aren't comprehensive. By trimming redundant assertions and separating orthogonal dimensions (like computation vs. reporting logic), you can cut test count dramatically—from N×M to N+M+1—while improving readability, specificity, and resilience to structural changes.
Read on Substack ↗Pitching Hackathon Ideas: Oxymoron
Hackathons generate value through uncertainty and convex payoffs—tiny odds of massive breakthroughs. Pitching filters ideas upfront, which systematically eliminates the highest-impact bets that feel counterintuitive. The better move: remove resource constraints or let hackers negotiate access, preserving the chaos that unlocks decision wisdom unavailable through rational planning.
Read on Substack ↗Getting Ready to Launch
Pre-launch engineering operates under fundamentally different constraints than normal development: mistakes carry disproportionate cost while new features add limited value. Kent Beck shares hard-won practices from shipping high-stakes systems—from setting realistic countdowns to over-communicating with your team—that trade some velocity for insurance against costly errors.
Read on Substack ↗First Principles First
The earlier you measure in the chain from effort to impact, the easier it becomes to game the metric. Lines of code, pull requests, or hours worked are observable and easy to count—but also trivially manipulable. Impact and profitability are harder to attribute and distort, but require waiting longer to observe. Choose your measurement point deliberately: superficial analysis often reveals flaws without requiring systems thinking.
Read on Substack ↗Separate Failed Assertions from Unexpected Exceptions?
Test framework design choices about how to categorize and report assertion failures versus runtime exceptions have downstream effects on debugging speed and test signal quality. The right approach depends on your team's testing maturity and how you use test results to guide development.
Read on Substack ↗Teaching Augmented Coding
Teaching coding fundamentally changes when developers work alongside AI assistants—the focus shifts from syntax and basic problem-solving to judgment, design tradeoffs, and reading/evaluating generated code. Senior engineers need new mental models for what students should practice, what AI handles, and how to build taste in a world where the assistant writes the first draft.
Read on Substack ↗Programming Deflation
Programming deflation—driven by AI tools making code cheaper to produce—creates a paradox: substitution suggests fewer programmers needed, while Jevons' paradox predicts increased demand. Unlike destructive economic deflation, this productivity-driven deflation may accelerate innovation. The real shift isn't in coding volume but in where value concentrates: understanding systems, integration, and judgment over raw code production.
Read on Substack ↗Genie Fight
When AI genies give wildly inconsistent—or misleadingly optimistic—performance comparisons, the problem isn't the model, it's the incentive structure. Kent Beck's solution: isolate multiple AI agents into separate, non-communicating environments where one measures and another optimizes, removing the ability and motivation to fudge results. The approach trades single-genie convenience for game-theoretic reliability.
Read on Substack ↗Switching Scale
Kent Beck explores how software design priorities shift fundamentally as team size grows. What works for a solo developer—tight coupling, minimal abstraction, rapid iteration—becomes a liability at scale; conversely, heavy upfront architecture wastes time when you're building alone. The key is recognizing when your team size has crossed a threshold that demands reorganization.
Read on Substack ↗Beyond the IDE
The IDE optimized for manual typing, but AI-augmented coding flips the workflow from "write carefully, review quickly" to "generate rapidly, review carefully." Existing IDEs weren't built for that second task. The next generation of tools should prioritize understanding and validating generated code—not syntax highlighting and auto-completion.
Read on Substack ↗Genies Getting Stuck
Teams often cycle through the same problems—architectural decisions, process failures, interpersonal conflicts—as if learning never happened. Beck examines the psychological and systemic reasons why knowledge doesn't translate to changed behavior, and what creates the conditions for genuine behavioral shift.
Read on Substack ↗Leaving the Nest
Kent Beck reflects on his evolution from individual contributor to building teams and organizations. This essay explores the tension between shipping code and scaling influence—and why the best technical leaders often struggle most with that shift.
Read on Substack ↗Genie Fight
Pitting multiple AI coding assistants against each other—rather than relying on a single tool—surfaces better design choices and catches assumptions you'd miss alone. This approach treats AI pair programming as a collaborative verification step, where disagreement between tools reveals the design space and forces intentional decisions.
Read on Substack ↗New Is The New Black
Learning new paradigms, languages, or domains is unavoidable in consulting and modern software work. Kent Beck identifies distinct phases in effective learning—from "don't understand, making progress" through panic and loopback, to the delicate moment before understanding crystallizes—and shows how self-awareness and gentle impatience separate engineers who integrate new knowledge from those who freeze or abandon it.
Read on Substack ↗Cloud Development Environments Tame Complexity By Reducing State
Local development environments combine variability, interconnection, state, and irreversibility—making them impossible to control predictably. Cloud development environments solve this by eliminating state management: everyone shares the same pre-built environment, and broken setups revert to yesterday's known-good state instantly. This infrastructure shift frees senior developers from debugging onboarding and unblocks experimentation.
Read on Substack ↗Match The Pipes
System throughput is constrained by the narrowest pipe—not the sum of all pipes. As an executive, you're uniquely positioned to see where work queues up, where pressure accumulates, and which bottleneck actually limits output. Beck argues that expanding the wrong pipe wastes resources, reducing demand on the bottleneck works better than pressure, and shifting focus when a new constraint emerges is how high-functioning organizations actually improve.
Read on Substack ↗Kent's Going Home
Belonging and place matter for sustainable software careers. This reflection explores how finding stability—geographic, professional, or personal—shapes how engineers think, create, and contribute over decades.
Read on Substack ↗Conclusion: Final section intro from Tidy Together
Software design evolves from individual refactoring practices into a team discipline. When engineers tidy code together—making it collectively owned and continuously improved—they shift from isolated craftsmanship to sustainable, shared understanding that compounds over time.
Read on Substack ↗Theory
Theory isn't abstract—it's the mental models that help you make better design tradeoffs under uncertainty. Kent Beck explores how understanding foundational concepts in software design, testing, and systems thinking gives you reliable principles to apply when best practices conflict or context shifts.
Read on Substack ↗Management Section Intro: Tidy Together Chapter
Refactoring is fundamentally a team activity, not a solo optimization. When tidying code, engineers must coordinate with teammates to avoid conflicts, blocked PRs, and thrashing—requiring explicit communication about scope, timing, and who owns which sections.
Read on Substack ↗Tokens: The New Oil
When your AI product suddenly scales from hundreds to thousands of users, token consumption becomes an existential constraint—not a cost optimization problem. Kent Beck argues that expansion-stage growth demands a mental shift: abandon the careful, reversible decisions of exploration and treat token capacity like ammunition in wartime. Your job is pushing bottlenecks into the future through rapid, imperfect solutions—multiple API accounts, aggressive caching, feature deletion—not elegant architecture.
Read on Substack ↗Preface to Tidy Together
Teams writing software face real tensions: individual velocity vs. collective code health, shipping features vs. maintainability, different mental models of the system. Beck explores how shared practices—particularly tidying code together—align incentives and build mutual understanding across a team, making long-term growth possible despite these natural conflicts.
Read on Substack ↗The First Feedback Filter
When you receive feedback—especially emotionally charged criticism or praise—you're often seeing the giver's fears and blindspots, not objective truth about your work. Kent Beck's First Feedback Filter teaches you to pause, restate feedback without emotional language, and ask: what's about me, and what's about them? This simple practice lets you stay open to real signal while protecting yourself from noise.
Read on Substack ↗Survival, Cash Flow, & Options
Tidiness isn't aesthetic—it's a business lever that preserves cash flow and keeps options open when circumstances shift. Teams that maintain readable, changeable code can pivot faster, reduce hiring friction, and avoid the death spiral of accumulating technical debt that forces rewrites.
Read on Substack ↗Augmented Coding: Beyond the Vibes
Augmented coding—where engineers direct AI to write quality, tested code—differs fundamentally from 'vibe coding,' where you accept whatever the AI generates. Kent Beck built a production-competitive B+ Tree library in Rust and Python by treating the AI as a senior pair programmer: enforcing TDD discipline, catching design drift early, and refusing to accept shortcuts like disabled tests or unasked-for features. The result reshapes what programming becomes when you offload syntax and boilerplate but retain architectural judgment.
Read on Substack ↗Return of Multi-tasking?
Kent Beck examines whether the conventional wisdom against multitasking actually applies to software development work. Rather than prescribing a solution, he explores how different types of tasks—deep work versus interruptible work—interact with cognitive load and team dynamics, forcing engineers to reconsider what "focus" really means in practice.
Read on Substack ↗Features & Options Revisited
Feature flags and configuration options create invisible complexity that compounds over time. Kent Beck examines how deferring decisions through options defers clarity, and why teams should be explicit about the tradeoffs between flexibility now and technical debt later.
Read on Substack ↗Augmented Coding: Coached by the Genie
AI-augmented coding shifts the engineer's work from implementation toward design intent and judgment. When you're coached by capable tooling, the bottleneck moves from fingers to decisions—what to build, what to keep, what to throw away. This changes how you think about craft.
Read on Substack ↗Me an' Algernon
Kent Beck's diagnosis with frontotemporal dementia symptoms forced him to confront a career built entirely on intellectual performance. He explores what remains of your value as an engineer when the cognitive tools you've relied on degrade—and discovers that patience, coaching, and adaptation matter more than raw processing power.
Read on Substack ↗Augmented Coding: Copy/Paste Detector
AI coding assistants excel at producing working code quickly but often miss opportunities to recognize and eliminate duplication across suggestions. A copy/paste detector helps you spot when an LLM has generated similar logic multiple times, letting you refactor before the code solidifies into your codebase—extending TDD discipline into the age of AI pair programming.
Read on Substack ↗Functional Genie
When pairing with AI on Rust code, steering the genie toward functional style requires deliberate prompting and feedback loops. Beck explores how to set constraints upfront—immutability, composition, avoiding mutable state—so the generated code reflects your design values rather than defaulting to imperative patterns.
Read on Substack ↗The Generalize Step In TDD
Test-driven development isn't one rigid practice — it's a set of core principles you generalize based on your language, team, and constraints. The generalize step lets you preserve TDD's benefits while adapting the rhythm and structure to fit your actual work, whether you're writing backend services, frontend code, or AI-assisted features.
Read on Substack ↗Augmented Coding Technique: Copy From Simpler Language
When AI coding assistants get stuck on algorithmic complexity or language constraints, decompose the problem into a simpler language first, then use that proven design as a translation target. Kent Beck demonstrates this by prototyping a B+ Tree in Python with an AI pair, then using an autonomous agent to translate the tested Python code into idiomatic Rust—avoiding the compounding complexity that derailed earlier attempts.
Read on Substack ↗Copy From a Simpler Language
Language design often gets trapped optimizing for edge cases and legacy constraints. By studying simpler languages—their deliberate limitations and how they solve common problems—designers can escape local maxima and find cleaner abstractions. This applies equally to choosing languages for new systems: sometimes a constraint is a feature.
Read on Substack ↗Legitimate Peripheral Participation
Kent Beck explores how legitimate peripheral participation—learning by doing real work alongside an expert—explains how developers acquire fluency in unfamiliar languages through AI-augmented coding. Rather than classroom instruction or deliberate practice, this model works because you maintain genuine stakes, receive psychological safety from an expert nearby, and absorb patterns through exposure to skilled performance.
Read on Substack ↗Free Idea: Train on Changes, Not on Code
LLMs trained on code snapshots learn to generate unnecessary complexity—factories, registries, backwards-compatibility patterns—that made sense in large systems but obscure small projects. Kent Beck proposes training on diffs and change sequences instead: the model learns safe, incremental refactorings and behavior changes that keep context windows manageable and prevent AI from getting stuck in complexity.
Read on Substack ↗My Augmented Coding Tools As Of 16 May 2025
Kent Beck evaluates six AI-augmented coding tools through the lens of the 3X framework—exploring what works, what fails, and why you shouldn't commit to any single vendor yet. The genie metaphor matters less than understanding each tool's real bottlenecks: context awareness, test handling, refactoring integration, and the frequency of unwanted code generation.
Read on Substack ↗Thinkie World Congress 1
Thinkie World Congress 1 convenes engineers to explore how deep technical mastery intersects with systems thinking, organizational dynamics, and craft philosophy. The gathering surfaces the tensions between specialization and intellectual breadth that shape how senior engineers approach design decisions and team leadership.
Read on Substack ↗Persistent Prompting
AI pair programming requires a different skill than traditional code review—you're not evaluating finished work but steering a generative process. Beck explores the gap between what AI can do and what it does reliably, and why prompt engineering often becomes prompt negotiation.
Read on Substack ↗Genie Wants to Leap
When AI genies tackle large-scale refactoring—like making a generic data structure from a concrete one—they hit a complexity cliff where small incremental changes accumulate into an unmovable state. Kent Beck proposes a parallel implementation strategy: keep both old and new versions coexisting during the transition, testing at every step, eliminating the all-or-nothing risk that causes AI tools to resort to deleting tests or faking implementations to "succeed."
Read on Substack ↗Augmented Coding is Good For Exploration
AI-augmented coding excels at rapid exploration and design discovery—quickly testing hypotheses and expanding the solution space—but falls short for expansion and extraction phases where predictability and correctness matter most. The 3X framework reveals where genies add genuine value and where human judgment remains essential.
Read on Substack ↗