▶ YouTube Summaries

• https://www.youtube.com/watch?v=ddHQQtjIOpw
• Original title: How Kent Beck shapes the software engineering industry

Gergely Orosz sits down with Kent Beck — creator of Extreme Programming, pioneer of test-driven development, co-creator of JUnit/SUnit, and first-listed author of the Agile Manifesto — for a full-career conversation recorded in Budapest before Craft Conference 2026. They trace Kent's path from a childhood 1970s programmable calculator through Smalltalk at Tektronix and Apple, the invention of SUnit/TDD/CRC cards, Extreme Programming at Chrysler, the Snowbird meeting that produced the Agile Manifesto, a burnout-driven "lost decade" after the dot-com crash, seven transformative years at Facebook, and finally his current, energized take on coding with AI ("the genie"). The throughline is Kent's recurring thesis: software engineering is mostly a human discipline of trust, communication, and understanding — coding is just the part that's easiest to automate.

Getting into computers and Smalltalk

Kent's father, an electrical engineer, brought home a huge programmable calculator when Kent was in sixth grade; by the mid-70s they'd built a 6800-based machine together and Kent was hooked on the "creative impulse plus machine knowledge" loop. He studied CS (and, on a whim, music) at the University of Oregon, then joined Tektronix, where he discovered Smalltalk — a language built from just three primitives (send a message, assign a variable, return a value), with everything, including control structures, implemented in the library rather than hard-coded into the language.

Ward Cunningham, design patterns, and CRC cards

Working alongside Ward Cunningham at Tektronix, Kent developed a close pair-programming-style partnership (they traded the keyboard, ran a weekly Monday-coffee/Friday-tech-report cadence) that produced tools like the HotDraw graphics editor. Inspired by architect Christopher Alexander's idea of empowering people to make their own design decisions within constraints, Ward and Kent created the first software design patterns for a struggling UI project at Tektronix, and Ward later invented CRC (Class-Responsibility-Collaborator) cards to help reason about polymorphic message-passing in object-oriented code. Kent also worked briefly (and was fired from) Alan Kay's "Playground" project at Apple.

SUnit, JUnit, and the origin of TDD

At Maspar, Kent built SUnit — a three-class, twelve-method Smalltalk testing framework (test case, test suite, test result) — because a consulting client needed automated tests and no good tooling existed. He later built JUnit with Erik Gamma on a transatlantic flight. TDD itself was, in Kent's telling, a rediscovery: as a kid he'd read about payroll programs where you typed the expected output tape before writing the program; years later he mapped that pattern onto SUnit and, half as a joke, started writing failing tests before any code existed — and found the anxiety of "did I get this right" disappeared. He's adamant TDD is a practical tool, not a moral obligation, and that it shines specifically in situations requiring rapid alternation between doing and learning.

Extreme Programming and the Agile Manifesto

Brought onto a struggling, Y2K-critical Chrysler payroll project in 1996 with Martin Fowler and Ron Jeffries, Kent restarted the project on a disciplined 3-week cadence, synthesizing everything he'd learned (testing, incremental design, tight feedback) into what became Extreme Programming — a deliberately "unattractive" name chosen so nobody else would want to claim credit for it. XP's popularity exploded because it offered a middle path between heavyweight waterfall methodologies and undisciplined "cowboy coding," right as the dot-com boom demanded speed. In 1999, Kent (alphabetically first signatory) joined 16 others at Snowbird to write the Agile Manifesto in a single afternoon. He never liked the word "agile" itself — unlike "extreme," which requires real investment to claim, everyone can claim to be "agile" whether or not they've earned it, which he believes let a "scaled agile" snake-oil industry grow around a term that, without the underlying technical skills, means nothing.

Burnout and the "lost decade"

The dot-com bust — sharpened overnight by 9/11 cancellations — combined with the psychological whiplash of being alternately worshipped ("JUnit saved my life") and blamed ("XP ruined my life") for other people's outcomes, triggered a severe depression and roughly a decade (2002–2011) where Kent barely worked, rebuilding confidence gradually through Sudoku, crosswords, and eventually small programming problems.

Seven years at Facebook (2011–2017)

Kent joined Facebook at 50, needing financial stability, fascinated that a mostly untested, young-engineer-staffed PHP codebase could achieve scale, growth, and innovation simultaneously — something he'd never seen combined before. His signup sheet for a TDD class got zero registrants (Argentine tango and Excel classes next door were full). He concluded Facebook's safety came from layered feedback ("Swiss cheese" model) rather than unit tests alone: instant local dev-server feedback, code review with a "star rating" gate, internal dogfooding, phased rollouts with automatic rollback, and blameless-but-rigorous Friday incident reviews. He built a widely-adopted internal coaching program ("Good to Great") — students were twice as likely to be promoted as uncoached peers — and later formalized Facebook's product lifecycle into the "Explore / Expand / Extract" (3X) model, arguing that engineering practices, org structure, and hiring should differ completely across the three phases.

Coding with AI ("the genie")

Kent rejects Dario Amodei's claim that "coding is going away, then software engineering" as a category error: coding cements understanding, builds trust with collaborators, and forces confrontation with whether you actually understood the domain — none of which happens when a model just says "it's all done." His core worry: "we're accumulating code faster than we're accumulating trust." He sees the coming disruption less as AI replacing engineers and more as a speed mismatch — business processes built for a five-year response cycle now facing month-scale competitive threats (e.g., a client vibe-coding a replacement for a $2M/year SaaS tool), while "vibe coders" who reproduce only the visible tip of a problem (like payroll compliance) will hit costly, invisible icebergs. His advice for engineers: there's no secret AI-era playbook — "nobody knows" — because we're back in an Explore phase industry-wide, and the way forward is running many cheap, reversible experiments and sharing results, the same way it took 15 years of collective object-oriented experience before the Agile Manifesto could even be written. Personally, he's using AI to revive his "tree shaker, not jelly maker" instinct: building and freely discarding side projects (an object database called Arlo, a B+-tree in Rust, experiments in Go) without the friction of dependency hell that used to block him.

Closing reflections

Kent describes learning empathy and communication as deliberately acquired skills (he identifies as being on the spectrum, and cites playing poker as one way he gets feedback on reading people), not natural strengths — contrasting them with the illusion, early in his career, that mastering the machine alone would be enough. Orosz closes by noting Kent's throughline across fifty years and every technology shift (Smalltalk, patterns, TDD, Agile, AI): try the stupid idea cheaply, don't be afraid to throw it away and start over, and resist the urge to declare a new manifesto before enough collective experience exists to justify one.