No PriorsNo Priors Ep 106 | With GitHub CEO Thomas Dohmke
CHAPTERS
- 0:00 – 2:03
Copilot becomes more agentic: Agent Mode and Project Padawan
Thomas describes GitHub’s latest Copilot shift from autocomplete/chat toward agentic workflows, including the newly announced Agent Mode in Copilot and VS Code. He previews “Project Padawan” (targeted for 2025), where Copilot can be assigned a well-scoped GitHub issue and produce a draft PR with an execution plan and iterative commits.
- •Agent Mode turns Copilot into an interactive implementation partner, not just chat/autocomplete
- •Human-in-the-loop is central: Copilot proposes actions (e.g., terminal commands) and the developer approves
- •Project Padawan vision: assign an issue → Copilot drafts a PR, plans work, and commits iteratively
- •Goal: Copilot evolves from pair programmer to “peer programmer” on the team
- 2:03 – 4:11
What’s blocking autonomous issue-to-PR agents: models, UX, and trust criteria
Sarah probes what’s preventing issue-assigned agents from being widely usable today. Thomas breaks it down into model reasoning improvements, workflow/UI design, and operational trust requirements so developers don’t feel the agent wastes time.
- •Model advances (e.g., improved reasoning) are required to raise task success rates on benchmarks like SWE-bench/V-bench
- •Workflow design: deciding when an issue is ready to assign vs. needs more specificity
- •Steerability: agents must ask clarifying questions and accept guidance mid-flight
- •Verification via PR-based workflows: inspect commits, roll back, and review like a teammate
- •Adoption hinges on being predictable, steerable, verifiable, and “tolerable” (time-saving vs. time-wasting)
- 4:11 – 6:07
Will agents replace developers? Where automation helps vs. where it falls short
The conversation shifts to timelines for “median programmer” performance and beyond. Thomas argues agents struggle with decomposing vague ideas into implementable chunks (systems thinking), but will rapidly improve on bounded tasks like bug fixes and feature tickets in existing codebases.
- •Hard part for agents: translating a big, fuzzy idea into a structured plan with the right decisions
- •Median developers won’t be replaced soon because architecture and decision-making remain human-heavy
- •Near-term wins: navigating codebases, locating bug sites, implementing well-scoped feature requests
- •Real example: a PM used the agent to create a PR that a developer reviewed and merged
- •Key gating factor becomes trust for daily, repeated use
- 6:07 – 8:28
How Copilot is built: AI engineering, evals, model routing, and rapid roadmaps
Sarah asks about Copilot’s development cycle, and Thomas outlines the “AI engineering” stack: integrating multiple models, running offline/online evaluations, and shipping via experimentation. He emphasizes how quickly vendor model releases can reshuffle roadmaps and planning horizons.
- •Copilot integrates multiple models/vendors and supports a “model picker” approach
- •Applied science + engineering collaborate on benchmarks and feature-specific validations
- •A/B testing and staged rollouts: employees first, then broader population segments
- •Roadmaps exist, but model progress forces frequent reprioritization
- •Planning is constrained by the pace of change—often only 1–2 months ahead feels reliable
- 8:28 – 10:40
Competing in a fast-moving devtools market: developer-first and product-driven culture
Sarah asks how GitHub thinks about “winning” amid rising competition in coding agents. Thomas frames GitHub’s advantage as deep developer empathy, internal dogfooding, and a belief that competition accelerates innovation for everyone.
- •GitHub’s identity: “developers building for developers,” using GitHub internally for nearly everything
- •Competition in devtools is unprecedented and energizing, not purely threatening
- •Innovation is happening in both open-source and proprietary ecosystems
- •GitHub aims to win by shipping the best experience, moving fast, and staying close to developer needs
- •Analogy: like Formula 1, multiple contenders improve the overall race quality
- 10:40 – 13:23
What usage data reveals: how much code Copilot writes—and where it still fails
Thomas shares early telemetry surprises and how developer behavior made the numbers plausible. He discusses how agentic workflows complicate measurement, while highlighting both the accelerating capability curve and the stubborn failure modes that keep humans essential.
- •Early surprise: Copilot wrote ~25% of code even as “just autocomplete”; later rose toward ~50% depending on language
- •Copilot matches an existing behavior loop: search/copy/paste/modify from StackOverflow/GitHub/blogs
- •With agents, “percent of code written” can become meaningless (prompt-only input, multi-file output)
- •Failure modes: repetitive rewrites, deleting files, getting stuck—reinforces need for oversight
- •Reality check: not yet at autonomous backlog-clearing; humans become primary reviewers and validators
- 13:23 – 16:44
Beyond coding: AI for code review, cloud dev environments, and security backlog burn-down
Elad asks where GitHub evolves besides coding agents. Thomas points to code review (especially for distributed teams), faster “outer loop” workflows via cloud environments, and security automation that fixes vulnerabilities, lint issues, and dependency problems.
- •Developers spend significant time reviewing code; AI can accelerate initial feedback loops
- •Human review remains important for security/trust, even with AI assistance
- •Need better UX and cloud environments to avoid repetitive local setup/branch/dependency work
- •AI-assisted remediation: fix vulnerabilities, outdated dependencies, and even trivial lint/formatting errors
- •Strategic impact: reduces tension between innovation work and tech debt/security/regulatory backlogs
- 16:44 – 19:38
Software development shifts: human language vs. deterministic code—and legacy reality
Sarah asks what new problems emerge as AI generates more code. Thomas argues code remains a deterministic layer beneath non-deterministic human language; engineering will increasingly move between the two. He also notes legacy systems (e.g., COBOL) will persist for years, limiting full automation.
- •Two layers: natural language (ambiguous) vs. programming languages (deterministic)
- •Engineers will rely more on human-language specs while still verifying code-level correctness and cost/performance constraints
- •Legacy modernization is not “magic”: transforming decades-old systems is a long-horizon challenge
- •Analogy to self-driving cars: capabilities expand by scope, but full autonomy is uncertain in timing
- •Kids/newcomers can already “render software” with prompts, but enterprise reality remains mixed
- 19:38 – 21:55
New team skills and workflows: specs, product management, and design converge with agents
Sarah asks what Thomas looks for in engineering teams as instructions become more natural-language driven. He emphasizes the growing importance of problem definition—writing issues/specs that are precise enough for agents—and describes Copilot Workspace concepts that help PMs and designers collaborate closer to implementation.
- •Core bottleneck at scale: describing problems and intent clearly (planning/tracking), not raw coding time
- •Small teams rely on short communication loops; large orgs need better issue/spec quality
- •Copilot Workspace: spec/brainstorming agents compare an issue to the codebase and describe “before/after” in human language
- •Designers may shift from manual wireframing to generating UI from specs grounded in design systems
- •Roles converge: PMs/designers/engineers can each drive more of the end-to-end change set via agents
- 21:55 – 24:34
Tooling landscape and developer choice: many models, many agents, no single winner
Elad asks whether one product/company will provide the full suite of agents for different users. Thomas argues GitHub’s principle is developer choice, expecting heterogeneous stacks and multiple specialized tools—similar to today’s mix of editors, clouds, and open-source components.
- •Developer choice is a core GitHub belief; one-size-fits-all platforms don’t serve diverse workflows
- •AI will mirror current dev stacks: different tools for different stages of the lifecycle
- •Model choice already exists; different scenarios favor different models
- •Even large platforms won’t supply everything (editor, OS, cloud, infra tools still vary)
- •Tech “battles” rarely end in total dominance; ecosystems remain pluralistic
- 24:34 – 29:50
Generalization vs. specialization and the ‘personal software’ future
Elad pushes on whether general-purpose models will reduce differentiation and whether trend-driven human decisions fade. Thomas sees potential model-level convergence but believes differentiation persists in higher-layer developer experience. He also forecasts a future where more software becomes personal and generated on demand.
- •Model convergence may happen, but timing is uncertain (self-driving analogy)
- •Differentiation will shift upward into UX, workflow integration, and reducing developer frustration
- •Software creation has long been about compressing time-to-ship for ideas larger than any one person
- •Agents won’t eliminate feedback loops: humans will still check alignment on goals
- •“Personal software” vision: natural-language tools generate personalized apps instead of installing generic ones (Jarvis analogy)
- 29:50 – 32:16
Copilot’s business impact: adoption, ROI, and why it spreads across industries
Elad asks about financial metrics and Microsoft impact. Thomas shares the last public figures and explains why Copilot’s price is small relative to developer cost while delivering measurable productivity gains—driving rapid adoption across company sizes and sectors.
- •Publicly shared: ~77,000 orgs and ~1.8M paid users (as of prior disclosure)
- •Adoption spans industries, not just startups or tech-native firms
- •Cost vs. salary makes ROI compelling; cited productivity gains include ~25–28% end-to-end improvement
- •Developers still do more than code, but coding acceleration changes throughput expectations
- •Copilot helps address universal pain: huge backlogs and software complexity that slows delivery
- 32:16 – 39:15
How AI changes software pricing: compute-based units, value perception, and deflation vs. premium tiers
The discussion turns to whether AI tools will be priced like “rent-a-programmer.” Thomas argues pricing will track compute (or derivatives of it) rather than human-equivalent wages, though premium tiers can command higher prices when value is clear. He expects a mix of deflation in some software and higher prices in high-ROI areas.
- •Pricing likely becomes compute-based rather than pegged to human labor replacement cost
- •Buyers won’t pay full human-developer equivalents for agents; humans still provide creativity and system decisions
- •Premium tiers emerge when value is evident (example: $200/month AI tiers in the market)
- •Agents have ‘infinite supply’ constrained mainly by compute/GPU capacity, unlike scarce human labor
- •Expect both deflation (some software becomes free/cheap) and premium pricing where ROI is highest
- 39:15 – 43:27
Open source vs. proprietary model APIs: innovation loops, accessibility, and GitHub’s model catalog
Sarah asks about the future relevance of open source models. Thomas argues open source will continue to drive innovation and democratize access, citing recent examples and emphasizing the feedback loop between open and closed ecosystems. He also explains how Copilot and GitHub Models broaden model access via extensions.
- •Copilot bundles major proprietary models (OpenAI, Claude, Gemini), while GitHub Models catalog includes open/open-weights options
- •Copilot can reach additional models via extensions connected to the model catalog
- •Open source accelerates innovation (examples referenced: DeepSeek, Stable Diffusion, FLUX)
- •Openness expands access for students, researchers, and hobbyists without paid API dependence
- •Market won’t resolve into a single winner; ecosystems evolve continuously (OS/language/library analogies)
- 43:27 – 50:34
Learning, ‘taste,’ and the next generation of developers—and Thomas’s East Berlin perspective
Sarah raises concerns that heavy AI use could reduce deep engineering understanding, while Thomas argues AI can also democratize learning via infinite patience and accessible knowledge. The episode closes with Thomas reflecting on growing up in East Berlin and living through reunification, shaping his view that technological transitions are irreversible and best met with optimism.
- •Concern: will new developers build architectural taste and understand trade-offs if AI writes more code?
- •Counterpoint: AI enables deeper, faster learning and individualized tutoring regardless of family background
- •Developers remain overcommitted; AI helps ship more without eliminating the need for judgment
- •Personal history: the fall of the Berlin Wall as a formative, irreversible transition
- •Perspective: software has had multiple ‘before/after’ eras (internet, open source, cloud, mobile, now AI)—and there’s no going back
