Kent Dodds and Sue Black Warn Engineers to Prioritize Impact Over Scale

What's worth building when AI can build anything? — GitHub

GitHub

The surge in autonomous software generation makes intentional restraint and human-centric design the primary factors for achieving meaningful, large-scale societal influence.

AI-assisted summary of What's worth building when AI can build anything? — original source. Check the original for full context.

Source published:

Key ideas

  • Kent C. Dodds demonstrates that solo developers using autonomous agent pipelines can manage codebases exceeding 1.2 million lines, generating the historical output equivalent of two to three full engineering teams. (7:44)
  • Sue Black's doctoral research on the 'ripple effect' highlights how undocumented code changes cause systemic bugs, emphasizing that modern agentic velocity requires architectural restraint and systems thinking rather than unchecked code generation. (4:45)
  • Autonomous pipelines at kody.codes use architectural decision records, AI review bots, and preview environments to allow agents to file, implement, test, and merge PRs directly into production without human line-by-line inspection. (18:01)
  • While generative AI democratizes software creation for individuals outside traditional computer science, solo-built systems risk lacking the diversity of thought—spanning race, gender, and background—vital for global software. (21:19)

Detailed notes

## Background Published by GitHub on YouTube on November 11, 2026, this GitHub Universe 2026 session features a dialogue between Sue Black of Durham University and Kent C. Dodds of kody.codes. According to the video description, the presentation examines what is actually worth building when AI can generate virtually anything, advocating for building software deliberately rather than reflexively while exploring developer tooling, maintenance, and the true cost of velocity.

## TL;DR Addressing the modern software dilemma where AI agents make code generation frictionless, Kent C. Dodds and Professor Sue Black argue that intentional restraint, scope reduction, and human purpose matter more than raw code velocity. The speakers connect historical software engineering principles—such as the ripple effect in legacy codebases and agile user-centric design—with cutting-edge autonomous agent pipelines capable of writing, reviewing, and deploying code without manual intervention. They emphasize that while AI democratizes technical execution, the future of engineering relies heavily on systems thinking, community collaboration, and diversity of thought. The session closes by reframing developers' existential automation anxieties into a challenge to harness modern leverage to improve the lives of one million people.

## Atmosphere & style The conversation carries an engaging, grounded tone that balances candid admissions of existential career dread with contagious technical optimism. Kent C. Dodds's fast-paced, cutting-edge demonstrations of autonomous agent workflows complement Sue Black's warm, seasoned storytelling, which spans early computing punchcards, academic research, and grassroots historical preservation. Watching the exchange feels like an intimate fireside chat that strips away industry hype, ultimately converting developer anxiety into an inspiring, human-centered call to action.

## Bulletin - [07:44](https://www.youtube.com/watch?v=VY4jwwNF9No&t=464s) Kent C. Dodds demonstrates that solo developers using autonomous agent pipelines can manage codebases exceeding 1.2 million lines, generating the historical output equivalent of two to three full engineering teams. - [04:45](https://www.youtube.com/watch?v=VY4jwwNF9No&t=285s) Sue Black's doctoral research on the 'ripple effect' highlights how undocumented code changes cause systemic bugs, emphasizing that modern agentic velocity requires architectural restraint and systems thinking rather than unchecked code generation. - [18:01](https://www.youtube.com/watch?v=VY4jwwNF9No&t=1081s) Autonomous pipelines at kody.codes use architectural decision records, AI review bots, and preview environments to allow agents to file, implement, test, and merge PRs directly into production without human line-by-line inspection. - [21:19](https://www.youtube.com/watch?v=VY4jwwNF9No&t=1279s) While generative AI democratizes software creation for individuals outside traditional computer science, solo-built systems risk lacking the diversity of thought—spanning race, gender, and background—vital for global software.

## Key takeaways - [00:04](https://www.youtube.com/watch?v=VY4jwwNF9No&t=4s) Rapid advancements in autonomous AI agents have shifted the fundamental software engineering question from what developers can build to what is actually worth building. - [04:45](https://www.youtube.com/watch?v=VY4jwwNF9No&t=285s) Decades-old lessons on the software 'ripple effect' remain crucial, as modifying individual components without clear maps causes unpredictable downstream failures across large codebases. - [07:44](https://www.youtube.com/watch?v=VY4jwwNF9No&t=464s) High velocity in code output does not equate to value; historically transformative products like Instagram and WhatsApp succeeded through radical feature reduction and disciplined restraint. - [11:04](https://www.youtube.com/watch?v=VY4jwwNF9No&t=664s) Computer science education is pivoting from manual syntax writing toward systems architecture, software orchestration, and evaluating the broader societal impacts of technology. - [13:08](https://www.youtube.com/watch?v=VY4jwwNF9No&t=788s) Junior engineers remain essential to the software ecosystem, as automated tools catalyze an exponential expansion in software volume rather than a permanent plateau. - [14:41](https://www.youtube.com/watch?v=VY4jwwNF9No&t=881s) Continuous refactoring and aggressive code deletion are vital health metrics when using AI tools, preventing codebases from accumulating low-quality digital sprawl. - [18:01](https://www.youtube.com/watch?v=VY4jwwNF9No&t=1081s) Fully autonomous deployment pipelines require strict blast-radius controls, preview environments, automated review bots, and architectural decision records to operate reliably without manual line-by-line review. - [21:19](https://www.youtube.com/watch?v=VY4jwwNF9No&t=1279s) AI lowers entry barriers for creators from non-technical backgrounds, but solo engineering risks eliminating the multi-perspective collaboration required to build inclusive, global products. - [23:17](https://www.youtube.com/watch?v=VY4jwwNF9No&t=1397s) 'Invisible software' will allow proactive agents to synthesize bespoke, ephemeral applications on the fly for personal problems, even as centralized systems remain necessary for core public infrastructure. - [25:45](https://www.youtube.com/watch?v=VY4jwwNF9No&t=1545s) Sue Black's historic campaign to preserve Bletchley Park demonstrates that individual initiative, when paired with community organizing, can alter institutions and preserve foundational computing history. - [28:25](https://www.youtube.com/watch?v=VY4jwwNF9No&t=1705s) Instead of succumbing to existential dread over AI automation, engineers should leverage modern agentic leverage to tackle ambitious projects capable of improving life for at least a million people.

## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=VY4jwwNF9No&t=4s) Opening and Audience Reality Check

Kent C. Dodds and Sue Black take the stage, immediately gauging the pulse of the room with an informal survey. Before diving into the technical discourse, Kent asks for a quick show of hands: how many people in the audience feel confident that what they will be doing a year from now is exactly what they are doing today? Seeing not a single hand raised across the auditorium, Kent jokes that he is relieved not to embarrass anyone, observing that all bets are completely off across the software industry. Looking back at where software engineering stood just twelve months earlier compared to the present moment, he notes that nobody could have realistically predicted the speed or scale of the current transformation.

With that reality acknowledged, Kent frames the core dilemma confronting modern engineers: what is actually worth building when artificial intelligence can build virtually anything? Rather than treating AI capability as an open invitation to generate endless software unchecked, Kent suggests that developers must step back and establish their own purpose, prompting Sue to share her personal history to ground the philosophical question in decades of hard-won industry experience.

[01:08](https://www.youtube.com/watch?v=VY4jwwNF9No&t=68s) Sue Black’s Path into Tech, BCSWomen, and Bletchley Park

Sue introduces herself, noting her roots in London and an unconventional entry into computing. She left school at age sixteen due to challenging family circumstances and did not re-enter education until she was twenty-six, by which point she was a single mother raising three young children. Seeking a way forward, she enrolled in college and took mathematics classes at night school before pursuing an undergraduate degree in computing. Even decades ago, she felt strongly that technology was the future and wanted to secure a stake in it. During her final year of undergraduate studies, her project supervisor asked her what she thought about pursuing a PhD. Sue enthusiastically agreed on the spot, admitting in hindsight that she had no idea what a PhD actually was and felt somewhat foolish about her initial ignorance.

Undeterred, Sue completed her doctorate in software engineering, secured a full-time lectureship, and eventually attained the rank of professor. Throughout her academic career, she actively launched social and community initiatives. Realizing how dramatically technology had elevated her own economic and family situation, she founded #techmums, a social enterprise designed to teach digital skills to mothers, particularly those living in disadvantaged areas. Exactly twenty-five years earlier, she established BCSWomen—the British Computer Society’s women's network and the UK’s first online network for women in tech. Her advocacy for women in computing led to a parallel career as a keynote speaker, as well as her prominent, successful public campaign to save Bletchley Park, the historic UK site where wartime codebreakers worked. Roughly eight years ago, she brought this blend of advocacy and technical depth to Durham University in the North of England, stepping into her role as Professor of Computer Science and Technology Evangelist.

- Left formal schooling at age 16; re-entered night school mathematics at age 26 as a single parent with three children. - Completed a computing degree followed by a PhD in software engineering. - Founded #techmums to impart foundational tech skills to mothers in underprivileged communities. - Founded BCSWomen, marking its 25th anniversary as the UK's first online network dedicated to women in technology. - Spearheaded the public campaign to preserve Bletchley Park.

[03:15](https://www.youtube.com/watch?v=VY4jwwNF9No&t=195s) Kent C. Dodds, Existential AI Crisis, and Kody

Kent reflects on his own career, contrasting his fourteen years in technology with Sue’s deeper historical perspective. For the vast majority of that time, Kent focused on education—teaching developers how to design and build world-class user experiences on the web through comprehensive courses, YouTube content, and workshops. However, at the beginning of the year, the rapid, staggering leaps in model intelligence triggered an acute existential crisis for him, a feeling he suspects many developers in the room shared. Watching models execute tasks he had spent over a decade mastering—often performing them better and faster than he could alone—forced a profound reckoning with what it means to be a software developer.

Emerging from that crisis, Kent found himself more optimistic than ever about where the software engineering field is headed and what humans can achieve alongside autonomous systems. He channeled that energy into building Kody, an experimental product designed to coordinate and facilitate cooperation among multiple AI agents. While Kent remains committed to education and rejects the notion that society has entered a post-education era where technical understanding is obsolete, he acknowledges that the sheer capability of agents forces a radical choice on builders. As Kent puts it: “It is just an interesting time where when you can build anything, do you just build everything or do you build nothing?” The temptation is either to surrender all initiative and build nothing, or to mindlessly churn out vast digital sprawl simply because the agents make it effortless.

[04:45](https://www.youtube.com/watch?v=VY4jwwNF9No&t=285s) The Ripple Effect and Software Maintenance in the 1990s

Kent brings the conversation back to Sue’s academic research, noting a prevalent modern anxiety: that the latent wisdom accumulated by engineers who have spent thirty, forty, or fifty years in the trenches will be discarded or lost as agents improve. Kent argues that this veteran intuition is more urgently needed now than ever before, inviting Sue to explain her doctoral research on the "ripple effect" in software systems.

Sue explains that her PhD centered on reformulating and calculating the ripple effect algorithm originally developed in the United States, which measures the systemic impact across an entire codebase when an engineer modifies a single component. Back in the 1990s, the press was constantly filled with alarming stories about massive banking systems ballooning to twenty million lines of code—a figure that seemed colossal at the time, and depending on context, still represents an unwieldy operational challenge. Developer peers often confided in her that making changes to these legacy monoliths was terrifying because no one could predict what downstream features would break. Although software engineering dogma heavily emphasized writing inline comments and keeping comprehensive system-wide documentation up to date, developers in fast-paced commercial settings rarely maintained these maps. Sue describes the prevailing development culture of that era: “And so these developers were like making changes and hoping that there wouldn't be some like bad ripple effects.”

Because computing hardware in the 1990s lacked the processing power required to run the original mathematical formulation on production codebases, Sue simplified the algorithm and wrote a few thousand lines of code to analyze toy programs rather than twenty-million-line banking giants. Beyond the code itself, Sue realized that the ripple effect served as an enduring metaphor for life and leadership: a single individual’s actions can generate massive, cascading outcomes across an entire ecosystem. Her doctoral years also coincided with a major tectonic shift in software philosophy, transitioning away from rigid Waterfall lifecycles toward Agile methodologies. Reading Kent Beck's work on Extreme Programming and pair programming introduced what was then a radical, eye-opening revelation: asking end-users what they actually wanted, listening to their feedback, and iterating with them continuously throughout the development process.

```mermaid flowchart TD accTitle: The Software Ripple Effect accDescr: A diagram illustrating how a single targeted code change propagates unpredictable side effects through an undocumented system.

subgraph Input["Local Modification"] A["Developer Modifies Component"] end

subgraph Propagation["Systemic Interdependence"] B["Direct Dependency Impact"] C["Indirect Functional Cascade"] D["Undocumented Legacy Coupling"] end

subgraph Outcome["Systemic Ripple Effect"] E["Unforeseen Bugs in Distant Modules"] F["System Instability & Fragility"] end

A --> B A --> D B --> C C --> E D --> E E --> F ```

[07:44](https://www.youtube.com/watch?v=VY4jwwNF9No&t=464s) High Velocity vs. Intentional Restraint (Burbn, WhatsApp, and Code Volume)

Turning to modern development, Kent illustrates the dizzying leverage currently available to a single engineer using AI-assisted workflows. He shares metrics from his own active project, noting that a slide prepared just two weeks prior listed the codebase at one million lines of code, but the total has already swelled to 1.2 million lines. Kent stresses that he does not cite this volume to brag, expressing confidence that anyone in the room could generate similar figures. Instead, he highlights the underlying trap: anyone can consume billions of tokens to output millions of lines of syntax, but high velocity does not equate to creating genuine human or business value.

To illustrate the paramount importance of restraint, Kent recalls Burbn, an early location-based mobile check-in app created by Kevin Systrom. Conceived essentially as a Foursquare competitor, Burbn allowed users to check in at venues, upload photos, and leave comments, but users consistently ignored almost all of its complex feature set, gravitating exclusively toward uploading photos. While an engineer equipped with modern AI agents might instinctively try to solve this problem by deploying agents to fix, polish, or promote the neglected features, Systrom chose radical subtraction instead: he deleted every peripheral feature and stripped the application down exclusively to photo sharing, transforming Burbn into Instagram. Similarly, when Jan Koum created WhatsApp, competing messaging platforms were cluttering their applications with social games, banner advertisements, and ancillary distractions. Koum published a focused manifesto affirming that WhatsApp would remain strictly a fast, pure utility for chat, which ultimately drove its global adoption.

Reflecting on these examples, Kent underscores that while developers can now build at an unprecedented pace, intentional restraint is the actual differentiator. Kent encapsulates the core lesson of the AI coding boom: “Having restraint on what you build actually is almost more powerful. And in fact, I would say it's even harder.” This dynamic introduces a pressing question for engineering educators: if a single developer can generate the output of several entire engineering teams, do we still need more people entering the software industry, and what foundational skills remain valuable to teach them? Sue acknowledges the challenge, turning to her firsthand experience educating first-year computer science students at Durham University.

- Kent C. Dodds expanded his personal project from 1.0 million to 1.2 million lines of code in approximately two weeks using AI tooling. - Burbn stripped away check-ins, gaming mechanics, and complex social features to focus purely on photo uploads, becoming Instagram. - Jan Koum intentionally rejected in-app games, marketing gimmicks, and advertising to keep WhatsApp strictly dedicated to core messaging. - Unchecked code generation is cheap and frictionless; thoughtful omission and deliberate scope reduction represent the true high-leverage skills in software engineering.

[11:04](https://www.youtube.com/watch?v=VY4jwwNF9No&t=664s) Systems Thinking, Soft Skills, and Educating the Next Generation

Traditionally, the central challenge of computer science was mastering coding syntax and getting implementation details right. Sue Black notes that while foundational programming still matters, education must evolve to teach students computing “in the large.” Rather than training students to spend five to ten years writing isolated routines inside an enterprise, universities must teach them systems architecture, software orchestration, and how to analyze software's broader impact on society. In her courses at Durham University, Black brings in startup and scale-up entrepreneurs to facilitate ideation sessions, highlighting that building software products is no longer restricted to computer science majors.

Industry practitioners visiting Black's classes consistently emphasize human skills over technical syntax. Team dynamics, interpersonal communication, and professional networking have surpassed raw manual coding in day-to-day value. Software engineers are shifting from daily line-by-line coding to high-level system designers and orchestrators. As Black summarizes:

> “You've got to understand it at the systems level, and you've got to understand the impact on the wider world and not just the code that you're writing.”

[13:08](https://www.youtube.com/watch?v=VY4jwwNF9No&t=788s) The Enduring Value of Junior Developers and the Software S-Curve

Addressing the widespread industry question of whether junior engineers are obsolete because automated agents handle junior-level tasks faster and better, Kent C. Dodds rejects the premise that software engineering was ever strictly about typing out code. Both junior and senior engineering roles exist to solve problems; juniors advance to senior status by attempting senior-level problems under the supervision and guidance of experienced engineers.

Dodds points out the vast surge of code production revealed during the GitHub Universe keynotes. While conventional wisdom five years ago assumed the industry might have saturated its software needs, automated tooling is generating an unprecedented volume of software. This surge explains GitHub's major investments in underlying infrastructure. Rather than an industry plateau, Dodds argues the tech landscape sits at the foot of an exponential curve requiring even more engineers. As Dodds explains:

> “The purpose was to solve problems. And the way that a junior becomes a senior is by pretending to be a senior and doing senior things as closely as they possibly can.”

[14:41](https://www.youtube.com/watch?v=VY4jwwNF9No&t=881s) Managing Autonomous Agents Across a Million-Line Codebase

Black raises a classic computer science concern: with a solo developer creating a 1.2-million-line codebase, how can anyone guarantee the software remains fit for purpose? Dodds explains that he began building his project in March and has already deleted nearly as many lines as remain in the active codebase. He treats continuous codebase refactoring and pruning as an essential health metric that distinguishes real product engineering from simply slapping code together.

When asked about his team composition, Dodds explains that he does not micromanage individual autonomous bots. He interacts with a single primary implementation agent managed via Rockbot. Unlike early workflows where he had to prompt and supervise each agent individually, the primary agent now acts as an engineering manager, autonomously spinning up subagents to handle tasks, conduct reviews, and push changes. Dodds estimates that shipping this volume of software at this velocity would historically require two or three dedicated engineering teams. Black reflects on the dramatic shift from her early coding days—debugging Basic, Pascal, and COBOL programs that spat out 60 compiler errors across the terminal—to modern conversational development environments.

```mermaid flowchart TD accTitle: Autonomous Agent Pull Request Workflow accDescr: Workflow diagram showing how an autonomous agent identifies an issue, creates a PR, tests in preview, and merges to production.

subgraph IssueAndCreation ["1. Issue Detection & Creation"] A["Agent uses product & files issue"] --> B["Primary Agent spawns Subagents"] B --> C["Subagent opens PR via ADRs"] end

subgraph Verification ["2. Verification & Review"] C --> D["CI runs 3 AI Review Bots"] D <-->|"Iterative feedback"| E["Implementer Agent updates PR"] E --> F["CI deploys Preview Environment"] F --> G["Agent tests in production-like environment"] end

subgraph Deployment ["3. Production Release"] G --> H["Agent merges PR automatically"] H --> I["Production deployment (kody.codes)"] I --> J["Blast radius controls: Flags, Sentry, Backups"] end ```

- **Codebase Scale**: Reached 1.2 million lines of code written by a single engineer since March, with an equivalent volume of outdated or refactored code deleted. - **Team Equivalence**: The automated agent workflow replaces the output capacity of approximately two to three full software engineering teams. - **Agent Architecture**: A single lead orchestration agent (via Rockbot) manages context, talks with the developer, and spawns modular subagents to perform implementation runs.

[18:01](https://www.youtube.com/watch?v=VY4jwwNF9No&t=1081s) Autonomous CI/CD, Safety Rails, and PR Verification

Dodds demonstrates a video of his autonomous pipeline moving an issue from pull request to production without human review. Often initiated while he is asleep, an issue is filed by testing agents using the product. An implementer agent picks up the issue, consults architectural decision records (ADRs) to select appropriate codebase primitives, and opens a pull request. The pull request triggers CI checks and runs three separate AI review bots. The implementer agent iterates directly on the bots' review comments, fixes flagged errors, and waits for CI to spin up an isolated preview environment.

The implementer agent runs verification tests against this preview environment before merging the pull request into production on kody.codes. To ensure the application remains fit for purpose without manual line-by-line inspection, Dodds relies on strict defensive architectures:

- **Architectural Decision Records (ADRs)**: Documenting architectural design patterns and API primitives so agents consistently discover and reuse approved interfaces. - **Verification & Review Bots**: Running three automated review bots concurrently alongside preview environment integration tests. - **Blast Radius Control**: Isolating database operations, deploying behind feature flags, and maintaining disaster recovery plans so failed changes cannot corrupt user data. - **Observability**: Real-time error and application monitoring powered by tools like Sentry.

By automating low-level implementation details and verification safeguards, the developer focuses purely on input design and product goals. As Dodds states:

> “I make the decision up front and then it ends up in production. I don't look at anything.”

[20:19](https://www.youtube.com/watch?v=VY4jwwNF9No&t=1219s) AI's Dual Impact on Diversity and Industry Inclusion

With solo developers capable of replacing multi-team software operations, Dodds asks Black whether AI widens tech inclusion or narrows it by cutting off entry points. Black views the trend as nuanced, describing the answer as both "yes and no."

Black shares her work directing TechUpWomen at Durham University, a program designed to retrain women from underserved communities into technology careers. While AI eliminates technical barriers and allows anyone to build complex software without deep traditional syntax knowledge, it simultaneously reduces the immediate need for large engineering teams. This shift disrupts the traditional career on-ramps historically used to integrate diverse talent into the tech sector.

[21:17](https://www.youtube.com/watch?v=VY4jwwNF9No&t=1277s) AI, Diversity, and Democratizing Access

Sue Black highlights the double-edged nature of artificial intelligence when it comes to diversity in software creation. On the positive side, generative tools dramatically lower the barrier to entry, empowering people who never had the chance to learn traditional coding to translate their ideas directly into functioning products and services. Yet this democratization brings a troubling corollary: when a single individual can build an entire system from scratch with AI, it becomes much harder to bake in the diversity of thought—spanning age, culture, nationality, race, and gender—that modern global software requires. As Black points out, developing products fit for a worldwide user base has historically benefited from multi-perspective teams, leaving an open question about how inclusive solo-built software will truly be.

Drawing on her own lived experience, Black reflects on her work establishing programs for women facing multiple structural barriers to entering the tech sector. She recounts how, in her twenties, she was a single parent living in poverty on welfare with three small children before gaining the opportunity to study mathematics and computer science. That intervention fundamentally altered her trajectory, launching a career that led to professorships and keynote stages—an outcome she still finds astonishing when looking back thirty years. Remarking on how social mobility ripples through generations, Black jokes about her four children and six grandchildren alongside Kent C. Dodds's family of six children, remarking, “I kind of feel like we're changing the tech industry on our own from having lots of children and grandchildren.” Ultimately, she underscores the systemic stakes of access, emphasizing: “Because I know from my background, you know, like talent is everywhere, but opportunity isn't.”

- AI tools allow non-programmers to materialize product ideas, broadening who gets to build software. - Solo development threatens diversity of thought across race, gender, background, and nationality in global products. - Black transitioned from living in poverty on government assistance with three young kids to becoming a computer science leader, demonstrating the generational impact of tech education.

[23:17](https://www.youtube.com/watch?v=VY4jwwNF9No&t=1397s) Invisible Software and Agent-Built Solutions

Kent C. Dodds validates Black’s concern about solo engineering, candidly admitting that building products in isolation can be lonely despite having open-source contributors and outside help. When building systems intended for broad audiences, solo creators inevitably miss crucial perspectives unless they stay exceptionally close to their users. For this reason, Dodds strongly supports teaching developers collaboration and networking rather than assuming all future software will be authored by isolated individuals. At the same time, Dodds introduces his concept of “invisible software”—a paradigm where individuals encode their personal values into software that is bespoke, ephemeral, and designed exclusively for their own use.

Dodds predicts that the developer landscape will expand from hundreds of millions of traditional engineers to billions of software creators. Crucially, this shift will not require ordinary users to manually prompt agents to code applications. Instead, proactive agents will detect friction—such as scheduling conflicts or logistical bottlenecks—and autonomously generate custom applications on the fly to resolve those specific problems. This model promises to serve marginalized and underserved communities whose niche needs have historically been ignored by mass-market commercial software. However, Dodds clarifies that centralized infrastructure will remain indispensable: society still requires standardized, shared software for institutions like banks, airlines, and governments, because not every citizen can maintain their own private window into core civic or financial infrastructure.

```mermaid flowchart TD accTitle: Invisible Software vs Centralized Systems accDescr: Diagram contrasting personalized agent-generated invisible software with shared institutional infrastructure.

subgraph UserLayer["User Problem Space"] Needs["Underserved Individual Needs"] Conflicts["Friction (e.g., Scheduling)"] end

subgraph AgentLayer["Proactive AI Agents"] Agent["Autonomous Agent"] end

subgraph SoftwareOutputs["Software Paradigms"] Invisible["Invisible Software<br/>(Bespoke, single-user apps)"] Centralized["Centralized Infrastructure<br/>(Airlines, banks, governments)"] end

Needs --> Agent Conflicts --> Agent Agent -->|"Generates custom code"| Invisible Invisible -.->|"Complements, does not replace"| Centralized ```

- Dodds defines invisible software as hyper-personalized, agent-generated applications tailored to a single user's exact values and workflows. - Proactive agents will increasingly identify user problems independently and synthesize software solutions without explicit prompting. - Centralized, robustly engineered platforms remain non-negotiable for large-scale societal infrastructure such as aviation, banking, and public administration. - Framing the tension between solo building and large-scale impact, Dodds asks: “And yes, I can build a pretty interesting and cool system, but how can I affect massive change?”

[25:45](https://www.youtube.com/watch?v=VY4jwwNF9No&t=1545s) Individual Impact and the Campaign to Save Bletchley Park

Responding to Dodds's question about how an individual developer can affect systemic change, Black rejects cynicism, insisting that individual initiative often sparks massive historical turning points. Reflecting on her own journey after entering technology—including founding the UK's first online network for women in tech—she shares the story of her multi-year battle to preserve Bletchley Park. Surveying the audience to see who recognized the site, she points to only three or four raised hands before explaining that Bletchley Park was the secretive British intelligence headquarters where approximately 10,000 codebreakers, including Alan Turing, decrypted enemy communications during World War II.

Their clandestine work was estimated to have shortened the war by two years during an era when 11 million people were dying annually, yet the site was kept secret for decades and faced imminent closure due to financial insolvency. When Black discovered the historic site was about to go under while serving as head of a university computer science department, she took action by emailing computer science department heads across the United Kingdom. What began as an email blast turned into an intense, three-year public campaign between 2008 and 2011. The grassroots campaign ultimately rescued the historic landmark, securing £4.6 million from the UK Heritage Lottery Fund alongside corporate sponsorship from Google. Black uses the achievement to illustrate that one person, anchored by community, can alter history: “And I think a really big thing now, particularly with where we are, is kind of all around collaboration and community building communities of people that care about the same things.”

- Bletchley Park housed roughly 10,000 wartime codebreakers whose cryptographic breakthroughs shortened World War II by an estimated two years. - Facing complete financial collapse, the historic facility was rescued through a dedicated three-year campaign (2008–2011) initiated by Black. - The campaign secured £4.6 million from the UK lottery fund and vital backing from Google, ensuring the site's permanent preservation. - Black emphasizes that solitary momentum becomes transformative when channeled into community organizing: “And, you know, I feel like as one person, we kind of feel sometimes that we can't really make an impact, but actually we really can.”

[28:25](https://www.youtube.com/watch?v=VY4jwwNF9No&t=1705s) The Million-Person Impact Challenge

Building on Black’s historic example, Dodds concludes the presentation by issuing an explicit challenge to developers grappling with existential dread over generative AI and agentic automation. Rather than retreating into passivity under the assumption that agents will soon build everything, Dodds urges engineers to invert their perspective and harness modern leverage. With state-of-the-art developer tooling and agentic workflows, an individual programmer now commands the distribution and implementation power to reach populations at an unprecedented scale.

Dodds leaves the audience with a framing question designed to guide what software engineers choose to build next: “So what could you do to make the life better for a million people?” Reassuring attendees that such reach is well within their grasp, he and Black wrap up the stage session and invite attendees to continue the dialogue, ask questions, and take photos at the nearby venue speakeasy.

- Dodds counters industry anxiety about AI automation by framing current tooling as an unprecedented multiplier for individual agency. - The closing challenge asks engineers to deliberately focus their efforts on projects capable of improving life for at least one million people. - The speakers close the session and direct attendees to the speakeasy space for open Q&A, networking, and attendee feedback.

## Notable quotes > [07:44](https://www.youtube.com/watch?v=VY4jwwNF9No&t=464s) Having restraint on what you build actually is almost more powerful. And in fact, I would say it's even harder. — Kent C. Dodds

> [11:04](https://www.youtube.com/watch?v=VY4jwwNF9No&t=664s) You've got to understand it at the systems level, and you've got to understand the impact on the wider world and not just the code that you're writing. — Sue Black

## Mentioned Kent C. Dodds, Sue Black, Durham University, kody.codes, GitHub Universe 2026, #techmums, BCSWomen, British Computer Society, Bletchley Park, Extreme Programming, Kent Beck, Burbn, Kevin Systrom, Instagram, WhatsApp, Jan Koum, Foursquare, Rockbot, Sentry, TechUpWomen, Alan Turing, Heritage Lottery Fund, Google

## Video description AI can build almost anything you ask it to, which makes a harder question unavoidable: what's actually worth building? In this GitHub Universe 2026 conversation, Sue Black of Durham University and Kent C. Dodds of kody.codes make the case for building software deliberately rather than reflexively. This session explores what responsible software looks like and takes a deeper dive into the daily reality of shipping, choosing developer tools, and maintaining what is already built. You'll leave with a sharper set of questions to bring to your own work, along with a clearer sense of when development speed is worth it and when it isn't.

Speakers:

Kent C. Dodds, Product Engineer, kody.codes Sue Black, Professor of Computer Science and Technology Evangelist, Durham University

Watch more videos from GitHub Universe 2026: https://www.youtube.com/watch?v=AArI948SDz8&list=PLENrlACZ7mnU

— CHAPTERS —

00:00 Welcome to GitHub Universe 2026 00:22 What's worth building with AI? 01:06 Sue Black's journey in Technology 03:15 Kent C. Dodds' AI optimism & kodi 04:45 Understanding the ripple effect 07:44 Building with restraint in AI 10:30 Educating the next generation of developers 14:41 Ensuring software is fit for purpose 20:19 AI and diversity in tech 23:14 Invisible software & individual impact 28:25 The million-person impact challenge 29:08 Join the conversation & feedback

#GitHubUniverse #SoftwareEngineering #OpenSource

Stay up-to-date on all things GitHub by connecting with us:

YouTube: https://gh.io/subgithub Blog: https://github.blog X: https://twitter.com/github LinkedIn: https://linkedin.com/company/github Insider newsletter: https://resources.github.com/newsletter/ Instagram: https://www.instagram.com/github TikTok: https://www.tiktok.com/@github

About GitHub It’s where over 180 million developers create, share, and ship the best code possible. It’s a place for anyone, from anywhere, to build anything—it’s where the world builds software. https://github.com

[Source](https://www.youtube.com/watch?v=VY4jwwNF9No)

Reading summary

Kent C. Dodds and Sue Black argue that as autonomous AI agents make code generation frictionless, the defining challenge of software engineering shifts from technical implementation to intentional restraint, systems-level orchestration, and community-centered purpose. Velocity Traps and Intentional Restraint (7:44) Dodds illustrates modern AI leverage by noting his personal project expanded from 1.0 to 1.2 million lines of code in roughly two weeks, achieving velocity that historically required multiple engineering teams. However, he warns that cheap, high-volume code generation does not inherently produce human or commercial value. Instead, deliberate omission and scope reduction have become the most difficult and high-leverage engineering skills. To demonstrate the power of subtraction over addition, Dodds points to Burbn stripping check-ins, gaming mechanics, and complex social features to become Instagram, as well as Jan Koum's refusal to add advertisements or games to WhatsApp in order to preserve a pure messaging utility. Unchecked agentic workflows risk generating digital sprawl, making focused restraint the critical differentiator for modern builders. Autonomous Pipelines and Managing Ripple Effects (14:41) Black's doctoral research in the 1990s evaluated the "ripple effect," calculating how modifying a single software component can trigger unpredictable, cascading failures across large codebases. She notes that developer anxiety around legacy systems often stemmed from a lack of architectural maps and documentation—a vulnerability that resurfaces when solo engineers generate codebases exceeding a million lines. Dodds addresses this systemic risk by deploying automated guardrails rather than manually inspecting code. In his workflow, a primary orchestration agent manages subagents that file pull requests against documented Architectural Decision Records (ADRs). These pull requests are autonomously reviewed by three AI bots, iterated on, and tested in isolated preview environments before merging. Blast radius controls, feature flags, Sentry error monitoring, and continuous code deletion ensure software integrity without manual line-by-line supervision. Systems Architecture and Junior Engineering Roles (11:04) With AI taking over routine syntax writing, Black emphasizes that computer science education must shift from teaching isolated implementation to computing "in the large." In her curriculum at Durham University, she focuses on systems architecture, software orchestration, and societal impact. Visiting industry practitioners consistently report that interpersonal communication, team dynamics, and networking now matter more in day-to-day work than manual coding. Addressing industry speculation that AI eliminates junior developer roles, Dodds rejects the premise that engineering was ever merely about typing syntax. He contends that junior engineers advance by attempting senior-level problem-solving under supervision. Given the surging volume of global software production, Dodds argues the industry sits at the beginning of an exponential adoption curve that will require more problem solvers, not fewer. Inclusion Risks, Invisible Software, and Impact (21:17) Black observes that while generative AI democratizes entry by allowing non-programmers to translate ideas into functional tools, solo development threatens the diversity of thought—spanning race, gender, culture, and nationality—historically provided by multi-perspective teams. Drawing on her journey from living on welfare as a single mother to entering tech through higher education, she stresses that talent is universal but opportunity remains uneven. Dodds balances this concern by proposing the concept of "invisible software," where proactive agents independently detect personal friction and autonomously build bespoke, ephemeral applications tailored to marginalized or niche users. However, centralized software remains essential for critical civic infrastructure like banking and aviation. Citing Black's successful three-year campaign that raised £4.6 million to save Bletchley Park, the speakers emphasize that individual agency achieved through modern tools must ultimately be directed toward broad social impact, challenging developers to build projects that improve life for at least one million people. While autonomous agents allow solo developers to achieve the technical output of several engineering teams, the discussion leaves open how the software industry will maintain diversity of thought and preserve early-career on-ramps as traditional multi-person development structures give way to automated workflows.

Source quotes

[7:44] Kent C. Dodds: Having restraint on what you build actually is almost more powerful. And in fact, I would say it's even harder. [11:04] Sue Black: You've got to understand it at the systems level, and you've got to understand the impact on the wider world and not just the code that you're writing.

Original transcript

[0:04] Please welcome Sue Black and Kent C Dodds. [0:20] Hello. [0:21] Hi. Hi, everybody. We're so excited to talk with you. [0:24] Before we get into anything, I want to ask a show of hands. [0:28] How many of you are confident that what you are going [0:31] to be doing a year from now is exactly what you're doing right now? [0:35] Okay, good. I didn't want to embarrass anybody. [0:37] Nobody raised your hand. [0:39] There are all bets are off. [0:41] I can't imagine what where we were a year ago and to be where we are now. [0:47] It just couldn't have predicted that at all. [0:49] Yeah. So thank you very much. [0:52] So we're going to talk about what is worth building when AI can build anything. [1:00] And to to get us into that, [1:01] I think it'd be useful for us to get some context on who we are. [1:04] So, Sue, why don't you introduce yourself to everybody here? [1:08] Thanks very much, Ken. Hi, everybody. [1:09] It's such a pleasure to be here. [1:12] As you can probably tell, I'm not from the US. [1:14] I'm from London in the UK. [1:16] So my background is that I. I left school early at 16 [1:22] because of my family circumstances [1:24] and didn't go really into education until I was 26, [1:28] by which time I was a single parent with three small children. [1:32] And I went to college and studied maths at night school [1:37] and then did a degree in computing, because I just thought back then, [1:40] which is some time ago now, that technology is the future, [1:44] and I was very excited to be part of that. [1:46] I did a degree in computing, and then in the final year of my degree, [1:51] my project supervisor said to me, what do you think about doing a PhD? [1:54] So I said, oh, I'd love to do a PhD. [1:56] But what I didn't tell him was I didn't know what a PhD was. [1:59] So. So I felt a bit stupid. [2:02] But so then I did a PhD in software engineering [2:05] and then applied for a full time lectureship, became a professor, [2:09] had various roles in academia, also set up a social enterprise, [2:14] tech mums teaching tech skills to mums, [2:17] particularly mums living in disadvantaged areas. [2:19] Because I realized from my own background that working [2:21] in tech had just made a massive difference to my life [2:24] and to my Twilight financial circumstances. [2:27] And yeah, and then so did various other things, lots of things around. [2:32] Women in tech set up the UK's first online network for women in tech, VCs, women. [2:37] So that's the British Computer Society Women's Network, [2:40] which is actually 25 years old this month. [2:42] So we just had our anniversary, which is really cool. [2:45] And then I've ended up kind of with a sort of keynote speaking career as well, [2:50] like public speaking, because of all the stuff I've done around women in tech. [2:54] And also I ran the campaign to save Bletchley Park. [2:57] If anyone knows about Bletchley Park in the UK where the codebreakers worked, [3:02] and about eight years ago I joined Durham University in the UK, [3:06] right up in the North of England as Professor of Computer Science [3:09] and Technology evangelist, and I think I'll stop there. [3:12] Otherwise I'm going to talk for the whole time. [3:15] I love it. You've just had a wealth of experience for myself, [3:18] I've only been in the industry. [3:20] Well, it sounds so short now, but about 14 years and for the bulk of that, [3:27] I've been an educator teaching people how to build excellent user experiences [3:31] on the web with a collection of courses and YouTubes and all of that. [3:38] But at the beginning of the year, I had a bit of an existential crisis. [3:41] Anybody else relate to that? [3:43] The AI models just got so, so good. [3:47] And you're thinking, wow, [3:48] they're they're doing what I used to do better than I used to do it. [3:53] And so I come out of that, [3:55] and I am now more optimistic than ever about the future of this industry [4:00] and the things that we can do. [4:02] And so I am now working on a product called Cody that helps agents work together. [4:09] And I'm just experimenting with that. [4:11] It's a wonderful and exciting time, and I'm still educating. [4:14] I still care very much about teaching people. [4:16] And I don't think that we're going to post education society or anything like that. [4:21] But things are rapidly changing and it is just an interesting time where [4:28] when you can build anything, do you just build everything or do you build nothing? [4:35] Nothing. [4:36] For my yeah, to build nothing in. The agent spelled it all. [4:39] Or are we more mindful about what it is that we're building? [4:42] So let's get into this. [4:44] Yeah. [4:45] Now you have some research that you have done about [4:50] in like the years that you've been in the industry. [4:54] And I think that some people are concerned that we're going [4:57] to lose some of that latent experience that you've developed over the years. [5:01] And some people here have also been in the industry working [5:05] for 30, 40, maybe 50 years. [5:08] I personally believe that that latent experience is desperately needed, [5:12] even as agents get better. [5:14] But I'd like to hear about your research and the ripple effect. [5:17] Great. Thanks very much, Ken. [5:19] Yeah. So my PhD was in the ripple effect. [5:22] So someone in the US had come up with this algorithm for computing the ripple effect. [5:28] So if you make a change to some software over here, [5:31] what is the effect across the whole system? [5:33] And back in the 1990s, when I was doing my PhD, [5:36] there was always something in the press around these big government, sorry, [5:40] big banking systems, which were well, back then, 20 million lines of code, [5:45] which seemed like a lot then, but maybe not so much now. [5:48] Depending on the context, it still feels like a lot. [5:50] Yeah. It's true. And so I had lots of friends who were developers [5:54] and were kind of like talking about the fact that it was quite hard [5:58] to make any changes to these systems because they'd make a change over here, [6:02] and they couldn't tell what the impact would be because back then, you know, [6:06] we were all like, it was really drummed into us to write lots [6:08] of comments in our code. [6:10] But we didn't have like a whole map of what, what the system did and how it did it. [6:14] And back then it was all about, you've got to keep your documentation [6:17] up to date of the whole system, but no one ever did because industry is fast paced. [6:21] And so these developers were like making changes [6:25] and hoping that there wouldn't be some like bad ripple effects. [6:28] And so I reformulated this algorithm to compute ripple effect and simplified it [6:33] because again, back in the 90s, [6:35] we didn't have anything like the computing power that we've got these days. [6:38] And so it was just impossible to compute the actual use the actual algorithm. [6:42] So I simplified it, wrote a few thousand lines of code and created like a toy system, [6:48] which you could run toy, you know, [6:49] like short programs through not 20. I never got to the 20 million lines of code. [6:55] And so that was my PhD. [6:56] And I kind of feel like the, [6:58] the ripple effect has kind of been a big part of my life, really, [7:02] and all of the things that I've done because like I gradually [7:05] realized over the years that as one person, you can have a massive effect on, [7:09] on lots of different things around you. [7:10] And maybe we'll get into that in a minute. [7:12] But then back then in the 90s, you know, [7:14] the most exciting thing I think that happened during my PhD was we kind [7:18] of moved from everyone thinking about using the waterfall lifecycle [7:23] to kind of like agile came in and that was like a really exciting thing. [7:26] I remember reading Kent Beck's book, Peer Programing, [7:30] about peer programing and just getting very, very excited. [7:32] The fact about the fact that we would actually, like, [7:35] ask users what they wanted and then keep talking to them, [7:38] which then seemed like a really exciting new thing to do. [7:41] And today, you know, it's just obvious really. [7:44] So how about you, Kent? [7:47] You know, what's building like for you now? [7:48] Because it's just so different from what it was like then. [7:51] It really has evolved, especially just this year. [7:54] I think it has moved faster than anything else. [7:57] And so I want to show you an example of what an individual person is able to do. [8:02] Now, this is what I have been working on and these numbers are actually wrong. [8:07] I it's when this slide was made, it was a million lines of code. [8:10] Now it's 1.2 million lines of code. [8:12] Was that like two weeks ago, I think? [8:14] Yeah. Well, I it's wild how fast this is moving and, and this is just an individual, [8:22] an individual operating at the scale of what used to take several teams to do. [8:28] I'm not showing this to brag. [8:30] I think any one of you could do this. [8:32] The trick is how do you have this level of velocity [8:36] while still actually accomplishing something of value? [8:40] Because anybody can spend billions of tokens and generate tons [8:45] and tons of lines of code. [8:47] But building something that actually has value, that's, that's the tricky thing here. [8:52] And so I'm actually a good example of this is an app called [8:59] Bourbon that was made a long time ago. [9:02] You probably haven't heard of it, but it was basically a Foursquare clone, [9:07] so you'd be able to go check into a place and take a picture, upload it, [9:10] and have some comments and all of that. [9:12] Well, Kevin Systrom, who had created Bourbon, [9:16] was struggling because users weren't using a lot of the features of the app. [9:21] In fact, the only feature they really used was just uploading photos. [9:25] And so for myself, I would have just thought, oh, well, [9:28] let's just throw a bunch of agents at this problem [9:30] and figure out how to make those other features easier to use or something else. [9:33] But Kevin took a different approach. [9:36] He said, how about we just delete all of the other features [9:39] and just do photo sharing? [9:41] And guess what that turned into Instagram. [9:44] So that worked out okay for for Kevin. [9:48] And then another example is Jan Koum, [9:49] the creator of WhatsApp was building WhatsApp [9:52] at a time where everybody else was building chat apps and adding like games and ads [9:56] and everything into it. [9:58] And he posted this manifesto, you could call it that said, no, we are just. [10:02] It's just a chat app. And then of course, WhatsApp ended up exploding. [10:06] And so. I think even though it's possible to build [10:09] at just a rapid pace, and I think that we. [10:11] We can and should in many contexts, [10:14] having restraint on what you build actually is almost more powerful. [10:18] And in fact, I would say it's even harder. [10:21] And you have greater leverage by being more thoughtful [10:25] and mindful about what you actually do build. [10:28] So that kind of leads into a question that I have for you, Sue, [10:33] which is you're teaching new people in this industry all the time. [10:37] And it feels like if one person can build all like this, [10:41] then maybe we don't need that many people in this industry. [10:43] And so I'm curious from your perspective, [10:49] do we need more people in this industry and how do we teach them? [10:53] What is it that is actually valuable to teach them? [10:56] Yeah, that's a great question. Thanks, Kent. [10:59] Yeah. So I teach the first year computer science students at Durham University. [11:04] And, you know, traditionally, [11:06] I guess the hard thing about computer science was the coding and getting it right. [11:11] And so yeah, we live in very different times now. [11:13] And of course, that's still important, but I think it's kind of moved on now in that, [11:18] you know, the things that I think are students really need [11:21] to learn right from the beginning is to understand computing in the large, you know, [11:25] like, how can we use it in the world? [11:26] What do we need to think about when we're creating these big [11:29] software systems that we can all create now? [11:31] And so the teaching that I do is more kind of helping them to understand that. [11:37] So we bring in entrepreneurs to talk about, you know, [11:39] startups and scale ups and what that looks like. [11:42] We do some ideation around entrepreneurship for the students because of course, [11:46] there's all sorts of opportunities for, for everybody now, [11:49] really not even just computer science students to create their own products. [11:54] And I also bring in people from industry [11:56] to help them understand what it's like working in industry. [11:59] And the thing that the people coming [12:02] in from industry always say is that you really need to focus on the soft skills. [12:07] So, you know, things like how to work in teams, how to network, you know, [12:12] connecting with people is actually really, really important. [12:15] And so it's kind of switched really from the, the hard stuff being the coding, [12:19] which still, you know, particularly at a higher level, you know, [12:23] I think now we're kind of we need to think about, you know, [12:25] rather than going in and being a coder within an organization. [12:29] Of course, you need to understand that, [12:30] but it's going to be more about kind of a systems level, I think, [12:34] and kind of about software like orchestration, [12:37] rather than just sitting and writing code every day, [12:39] which kind of probably like when I was at uni, [12:41] that was the thing that you were expecting to do as a software engineer. [12:45] So I think, you know, that's what I'm really trying to get over is, [12:48] is it's a changing world out there and there are all sorts of opportunities. [12:52] And, you know, you're not probably just going to become a software developer [12:55] and stay writing code for, you know, five, ten years maybe. [12:59] You've got to understand it at the systems level, [13:02] and you've got to understand the impact on the wider world [13:05] and not just the code that you're writing. [13:08] So actually, I might one, one thing that I've heard from a lot of people is like our, [13:16] our juniors even valuable anymore. [13:18] Like, is there a place for a new developer to come into this industry? [13:23] Because all of the stuff that I would ask a junior to do, [13:26] I just ask an agent to do and it's going to do it better anyway. [13:29] And my thought on that is juniors were never about writing code. [13:34] That wasn't like the purpose of the job for seniors, juniors, anybody. [13:38] The purpose was to solve problems. [13:41] Yeah. And and the way that a junior becomes a senior is by pretending to be a senior [13:46] and like doing senior things as closely as they possibly can. [13:50] Now, they're not going to do as efficiently or as well or whatever. [13:54] And that's why the seniors are there to kind of help guide them on that journey. [13:58] Yeah, but I don't think that anything has changed in that. [14:01] And, and I believe that actually you just saw yesterday in the Keynote, [14:06] those those graphs of the amount of code that's being created. [14:10] You might think that, you know, five years ago, we've got plenty of software. [14:14] There's so much software, but like, look at those graphs. [14:16] We are generating so much more software. [14:19] And I do not think that that's the end. [14:21] And this is why GitHub is making all their investments in infrastructure [14:25] and everything, because we are we're [14:28] at the very beginning of what I see as a massive S curve. [14:31] And maybe it will never s maybe it's just exponential forever. [14:35] Who knows? But I, I do think we have a lot more need for software engineers. [14:40] Yeah. So with that in mind, [14:41] so one thing that was really drummed into me when I was a degree [14:45] student studying computer science was how, [14:48] how can we tell that the code is fit for purpose? [14:50] And like, so how do we do that now when, you know, [14:53] like you can develop a 1 million line of code app on your own? [14:55] 1.2 sorry, On your own. [14:57] How can we tell that it's fit for purpose? [14:59] Yeah, yeah. [15:00] I would like to show. [15:02] Oops. Here we go. Yeah. [15:04] I would like to show everybody how I make my my product fit for purpose. [15:11] Meaning like that it actually solves valuable work. [15:14] So you see. Wow, a million line code base by one person. [15:17] I started that in March, by the way. [15:19] It's it's crazy. And actually I just looked [15:22] and I've removed almost as many lines as there are in the code base now. [15:26] So it's a, it's an evolving thing. [15:29] And honestly, I would say that's partially like an indicator of whether [15:35] you're actually developing a product or you're just throwing [15:37] things together is that you're constantly evolving the code base. [15:40] But so, so how many agents you've created agents, obviously to your team, [15:46] how many agents have you got and what are their roles? [15:48] Yeah, that's a fine question. [15:49] So the I pretty much have just a single agent. [15:53] I use Rockbot for most everything now. [15:57] And and I manage pretty much one agent as the primary implementer, [16:02] but then that agent will spawn any number of subagents to make it happen. [16:07] And this is the exciting thing is that we get these new layers of leverage. [16:10] So back in March, that wasn't a thing. [16:12] And so I was managing every single one of these, [16:14] and I'd spin them up and they'd work in isolation. [16:17] And now I've got a, like an agent manager that I can just have a conversation with. [16:24] And it's amazing. And the trick is like, obviously nobody, [16:28] no one person can review a thousand pull requests a month that you're just, [16:31] it's not going to happen. [16:33] You cannot review that much code. [16:35] And so how do you know that it's fit for purpose? [16:38] How do you review all that? [16:39] How do you make sure that it ends up in production in the right way? [16:42] And I have set things up now at a point where I can just have a conversation [16:46] with my agent and it can spin up other agents and they make their make their changes, [16:54] review them and get them up into production without me looking at it at all. [17:00] So I make the decision up front and then it ends up in production. [17:03] I don't look at anything. [17:04] So I want to yeah, yeah. [17:06] So no. So just making me think. [17:07] So how many people is that kind of replacing? [17:09] Like if you had a team of people, how many people would that be? [17:13] Yeah. Well, so I've been in this industry a while. I've worked [17:15] at bigger companies that would build this kind of a product. [17:18] And I would say that they're this size of product [17:21] at the pace that I'm moving would require at least 2 or 3 teams of people. [17:25] Wow. And so yeah, it is, I would say that, yes, [17:29] it's replacing what typically would be a software engineering team or set of teams. [17:35] But again, we're, we're able to build so much more. [17:37] And at the end, we've got a challenge for you all. [17:39] So don't leave early. But but like this is a massive opportunity. [17:45] It's just crazy when I think about it because like when I first started programing, [17:48] you know, I was like basic and then Pascal and then COBOL, you know, [17:51] and I'd sit there and kind of like write some small bit of code [17:54] and then get 60 errors, like, you know, [17:56] like scrolling up the screen and thinking, oh my God. [17:59] And now just look at where we are. It's just crazy. [18:01] Yeah. It's exciting. So I want to actually show you what this looks like from like PR [18:06] to production. So here I've got a quick video. [18:09] We start with a pull request. [18:12] This is fixing a number of issues that [18:15] in fact the issue that this particular pull request is fixing was an issue [18:20] that was filed by agents that are working in the code base and using the product. [18:24] And so this is that that feedback cycle that is constantly going, [18:28] this is the sort of thing that happens when I'm sleeping. [18:30] In fact, it doesn't say the date, [18:32] but I was probably asleep when this pull request was opened and merged. [18:35] So this is what happened. [18:37] First, the pull request is opened following my address [18:39] and everything to make sure that it's building the right thing. [18:42] And then CI starts running an AI review. [18:44] Bots start going through it. [18:46] Yes, I do use three of them and they're fabulous. [18:48] All of them. And my agent will implement [18:50] or agent will iterate with these review bots. [18:53] And the CI also deploys a preview environment in which my agent, the implementer, [18:59] can then test its changes in a production like environment, [19:02] and then the agent merges it itself. [19:03] Once everything looks good and it goes off to production@codex.com. [19:07] So this is just an amazing way to work. [19:11] Once you have the agents building the right thing in the first place, [19:14] so you have things set up with architectural decision records, [19:18] and your primitives are well laid out and discoverable. [19:21] And then once the PR has been made, [19:24] you catch any mistakes through an intensive review and the verification process. [19:31] And then you, you limit the blast radius as well. [19:34] Like in production, you don't want a mistake to end up taking out your database [19:39] or deleting user data or causing problems for users. [19:42] So you have feature flags and disaster recovery and those sorts of things. [19:46] And once you have all of that in place. [19:48] Oh, and observability love. [19:50] Sentry. But once you have those things in place, [19:53] then you can just say my inputs go into the system [19:57] and then the outcome is what I'm looking for. [19:59] I don't really like the output matters, the code that's generated, it does matter, [20:04] but we can automate a lot of that now [20:07] and move to a higher level of leverage with these agents [20:10] so that we can focus on building products that solve actual user pain. [20:16] Yeah. So they are fit for purpose. [20:18] Yes, exactly. So it's fit for purpose. [20:21] Now, if I can build something like this myself. [20:26] Do you think that AI widens the circle of who can be included in this industry? [20:32] Or are we now saying, oh, we don't need you? [20:35] What is your thought on that? [20:37] Yeah, I mean, it's a really interesting time, right? [20:39] And I kind of think that it's like, yes and no. [20:42] You know, like there's two answers to that. And I think, you know, it's great. [20:46] So here's a photo of one of my programs that we run at Durham University, [20:50] which is tech up women retraining women from underserved communities [20:53] into tech careers. So I've ended up kind of focusing a lot of my efforts into trying [20:59] to help build diversity in tech teams, [21:03] which is kind of interesting now because we don't necessarily need a team. [21:07] So yeah, so I think so AI opens up so many opportunities, of course, [21:12] because now basically anyone can write produce a software system that does anything. [21:17] So kind of on the, on the positive side, that's amazing because people that maybe, [21:22] you know, wouldn't have ever learned to code can come up with great ideas [21:26] and they can now build products and services, which will, which will match that, [21:30] which is great in terms of diversity because it means that anyone can do it. [21:34] And then at the same time, if we've got one person building a system, [21:40] how how do we get the diversity in there? [21:42] Diversity of thought, you know, because we know now that diversity is a strength, [21:45] right? Diversity of all sorts of age backgrounds, you know, like country, [21:50] nationality, race, gender, all of those things. [21:54] If we're building products [21:55] and services that are fit for purpose for everyone around the world. [21:58] We now live in a global marketplace. [22:00] How do we get that diversity in there? [22:02] And so, I mean, it's an open question. [22:04] I don't exactly know the answer, [22:06] but I'm looking forward to seeing what happens as time goes on [22:09] because things are changing so rapidly. [22:11] It's insane. So yeah, I've spent a lot of my time running programs to help, [22:16] particularly women, particularly women [22:18] who face multiple barriers get into the tech industry. [22:20] Because I know from my background, you know, [22:23] like talent is everywhere, but opportunity isn't. [22:26] And if I hadn't been able to, to study maths, [22:28] to study computing when I was like in my 20s as a single parent with no money, [22:33] basically living in poverty, you know, I've now had an amazingly successful career. [22:38] And, you know, I can't believe I come to give, you know, [22:41] to sit on stage with you and chat to you guys about, about stuff. [22:45] Because that's just so not where I was like 30 years ago at all. [22:50] And I can just see that that's not just changed my life. [22:52] It's changed my kids lives. [22:54] I've got four kids and six grandchildren now. You've got six kids. [22:58] I kind of feel like we're changing the tech industry on our own [23:01] from having lots of children and grandchildren. [23:04] But yeah, I think AI does widen the circle. [23:07] But at the same time, we need to be aware that, you know, like if it's one person, [23:12] you know, building a product, then how do we get the diversity in there? [23:15] It'd be interesting to hear your point. [23:17] Yeah. You know, I think that even though I'm building this on my own, [23:21] I'm kind of lonely and I would like to work with some people and, [23:25] and I do have contributors and help who are helping a lot. [23:28] But I think that there is something that we miss [23:32] when we're building big systems that are intended for a big [23:34] audience where if we're just building it by ourselves. [23:37] And so being really close to users helps with that a lot. [23:41] But I agree with your approach of teaching people how to work in teams [23:45] and how to network, because I don't think that we're getting to a place [23:48] where every product is just going to be built by a single person. [23:51] That said, I do think that we are getting [23:53] to a really interesting place that I call invisible software, where the. [23:59] You can encode your own values into the software [24:02] because the software is just for you. [24:05] And we're going from hundreds of millions of software developers [24:09] who are building software to billions of people who build software, [24:13] not because they're using agents and saying, build me this app or whatever, [24:17] but because people will eventually figure out what we have all [24:19] figured out, and that is that agents are really good at not just answering questions, [24:23] but doing things for you and solving problems. [24:26] And agents will get better and better at being proactive and saying, [24:29] I noticed that you had this scheduling conflict or you have this other problem. [24:34] How about I solve that for you? [24:36] And the agents are going to use software to solve that problem. [24:38] They'll just build the app for the user. [24:41] And so what this wonderful about this is that many of the underserved [24:46] will now have their problems actually served directly, [24:49] exactly the way that they need it to be. And that's awesome. [24:53] But that said, not everything can be invisible software like that. [24:58] We do need to have software that is a centralized system for governments [25:03] and for airlines and banks, and you can't just have everybody having their own app, [25:08] their own window into their bank account. [25:10] That's not going to at least that's not in the future that I envision. [25:13] And not everybody's going to own their own plane. [25:16] Maybe one day. I don't know if technology is amazing, [25:19] but that's one thing that I think is going to be a really good thing for the world, [25:24] is that people can get their own needs directly addressed by [25:29] custom software that their agent builds for them. [25:33] And it's an exciting time. [25:34] And like I said, it's, it's not just custom software, [25:38] but it's big systems that still will need to exist even in this future. [25:43] And sometimes that can feel a little bit daunting. [25:45] So Sue, I'm just one person. [25:48] And yes, I can build a pretty interesting and cool system, [25:51] but how can I affect massive change? [25:54] What? What can I do as just one developer? [25:57] Yeah, that's a really good question. [25:58] And yeah, it's, it's, there's not a simple answer to that. [26:02] There's no simple answers anymore. [26:03] I feel like, and, you know, I feel like as one person, [26:07] we kind of feel sometimes that we can't really make an impact, [26:10] but actually we really can. [26:11] You know, I know from my life and the things that I've managed to do, you know, [26:15] going from basically living on welfare with three small children, I've, you know, [26:19] getting into tech, doing the things that I've done, setting up the, [26:23] the UK's first online network for women in tech kind of helped me [26:26] to realize various things. [26:27] And then running the campaign to save Bletchley Park actually. [26:31] Has anyone here been to Bletchley Park? [26:33] Does anyone know what it is? [26:35] Yeah. Two people. Awesome. [26:37] Three. Four. [26:39] Yeah. So Bletchley Park is the place in the UK where the codebreakers works. [26:43] I'm sure you've all heard of Alan Turing. [26:44] I hope you've all heard of Alan Turing, [26:46] one of the codebreakers that is particularly famous, [26:50] but so it's a place where the codebreakers worked during the Second World War [26:54] and I ended up finding out that about 10,000 people worked [26:57] there during World War two. [26:59] And the work that they were that they the work that they did was said [27:04] to have shortened the war by two years. [27:06] And at that time, 11 million people a year were dying. [27:09] So their work was really fundamental, but kept completely secret for, [27:12] for decades afterwards. [27:14] And so I went up there on a visit and found this out [27:17] and then found out that it might have to close. [27:19] And so back then, I was head of a computer science department. [27:23] I emailed all the heads of professors of computing [27:25] in the UK basically started a campaign. [27:27] I didn't realize that's what I was doing at the time, but that's [27:30] what it was. And then ran a three year campaign to save Bletchley Park, [27:34] which was ultimately successful. [27:37] Bletchley Park, you know, [27:38] it looked like they were going to go under [27:39] because they had no money. [27:41] And then after three years of kind of struggling along, [27:43] they got 4.6 million from the lottery funds in the UK [27:47] and some funding from Google as well. [27:50] And so then we knew that they'd be safe. [27:52] So that's back. That was 2008, 2011. And yeah, [27:56] kind of like looking back from my background, [27:58] I just never would have thought that I could make the difference that I've made. [28:02] And I think a really big thing now, particularly with where we are, [28:06] is kind of all around collaboration [28:08] and community building communities of people that care about the same things. [28:13] And, you know, I just feel like as one person, you might think you can't do much, [28:17] but actually you can make a massive change happen. [28:19] And particularly if you surround yourself [28:21] with the right people that care about the same things that you do. [28:24] Absolutely. And that brings us to our challenge. [28:27] So we want to challenge you. [28:30] We have a huge opportunity. [28:32] So what could you do to make the life better for a million people? [28:37] Think about that. We have just the most amazing technology that you can reach [28:43] so many people. And at a time where a lot of us are feeling those existential crises, [28:47] like, what could I possibly do? [28:49] Oh, no, the agents are doing everything. [28:53] Flip that around. You can do [28:55] so much now by taking advantage of this amazing technology, [29:00] and you can reach just a massive number of people. [29:02] So really think about that. [29:04] What could you do to make life better for a million people? [29:07] And you can. So that's all that we have. [29:10] But we're not totally done [29:12] because here in a minute we're going to go over [29:15] to the speakeasy just like just right over there and have continue the conversation. [29:20] So if you're interested in talking with Sue or me or getting photos or whatever, [29:24] then we welcome you to come and say hi and ask us more questions [29:29] or talk with us more about this subject. [29:31] We're so excited that you came here to listen to us talk [29:35] to each other about these issues. [29:38] And if you have any comments or anything, [29:40] you can also submit your feedback here with that. [29:44] Sue, thank you so much. [29:45] Yeah. [29:45] Thank you. Yeah, it's been fun. And thank you all very much. Thank you, thank you.