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)