Skills on Tessl: a developer-grade package manager for agent skillsLearn more
Logo
Back to podcasts

The Developer Skills That Will Actually Survive AI

Transcript

Chapters

Introduction
[00:00:56]
The Evolution of Developer Tools
[00:02:33]
The Impact of AI on Software Development
[00:04:26]
Challenges and Opportunities in AI Development
[00:09:15]
The Future of AI in Developer Tools
[00:17:20]
Competition and Innovation in the AI Space
[00:21:11]
Leveraging Microsoft's Scale for Startups
[00:26:15]
Agent Collaboration in Software Development
[00:31:22]
Composability and Switching Costs in AI Tools
[00:35:58]
The Evolution of Developer Skills
[00:44:50]
Teaching AI Skills to the Next Generation
[00:50:26]
The Importance of Engineering and Business Skills
[00:54:16]

In this episode

In this episode of AI Native Dev, host Guy Podjarny talks with Thomas Dohmke, former CEO of GitHub, about the evolving landscape of AI-driven innovation in startups versus incumbents. They explore how AI agents are transforming developer workflows, the importance of maintaining UX while shipping fast, and pragmatic strategies for building impactful AI-native products. Key takeaways include leveraging comparative advantages, automating maintenance with human-in-the-loop safeguards, and prioritising a seamless user experience to maximise development efficiency and creativity.

In this AI Native Dev episode, host Guy Podjarny sits down with Thomas Dohmke—former CEO of GitHub and now back in founder mode—to unpack where AI-driven innovation is likely to emerge (startups vs. incumbents), how AI agents are already reshaping developer workflows, and the discipline required to ship fast without sacrificing UX. Along the way, they revisit the 2018 GitHub–Snyk courtship, reflect on how dev tools valuations and expectations have changed, and share pragmatic tactics for building AI-native products that actually land.

Different Weight Classes, Same Track: Startups vs. Incumbents in AI

Dohmke frames the competition between startups and incumbents like elite sports. Incumbents may be “on top,” but they’re also constrained by gravity: they need to add tens of billions in net-new ARR just to sustain double-digit growth. That forces a different calculus than a startup chasing its first $1–10M. Startups can move on pure product velocity; incumbents must weigh platform risk, cross-portfolio dependencies, and enterprise motions.

Distribution remains the incumbents’ superpower. GitHub’s acquisition and rollout of Dependabot is a canonical example—flip a switch and millions of repos gain a new capability. Yet the “where will innovation come from?” answer isn’t binary. Big companies are shipping AI features and agents across their stacks. Meanwhile, AI studios like OpenAI, Anthropic, and Black Forest Labs are setting the pace on model capabilities, enabling “AI-native” startups to build entirely new workflows from first principles. The real distinction is less about company size and more about constraints, culture, and time horizons.

The takeaway for dev teams: choose your comparative advantage. If you’re building in startup land, wedge into a painful workflow and iterate with direct user feedback. If you’re shipping inside an incumbent, lean on platform distribution, ecosystem leverage, and enterprise trust—but make sure your product quality withstands scale and complexity. In both cases, AI creates room for faster bets, but the fundamentals—learning loops, UX, and crisp business value—still decide winners.

Designing an AI-Native Morning: From Backlogs to Brainstorming with Agents

Dohmke describes an “AI-native” developer’s day starting not in Jira, GitHub Issues, or Linear—but in the terminal or an AI-accelerated IDE like Cloud Code, Cursor, or Gemini CI. The first step is brainstorming with an agent: clarify intent, surface constraints, outline tests, and propose an initial approach. That’s a very different cognitive entry point than grinding through a backlog or chipping away at tech debt.

To make this real, teams can standardise an agent-first loop:

  • Seed the agent with context: README, service boundaries, API contracts, architecture decisions, and recent PRs.
  • Prompt for an initial design and a test plan, then ask it to generate a minimal slice (scaffold + tests + safety checks).
  • Spin up an ephemeral environment to validate the slice quickly, then iterate on gaps (infra, types, interfaces, logging).
  • Only after the first slice passes do you bring it back to issue trackers and backlog grooming for sustained work.

For legacy-heavy teams, this doesn’t replace the backlog; it reprioritises the order of operations. Use the agent to convert “unknowns” into working code and tests, then align that with product prioritization. The practical benefit is cutting through front-loaded overhead—more time building, less time context-gathering.

Automating the Unglamorous: Security, Upgrades, and Tech Debt with Human-in-the-Loop

AI agents shine where toil is predictable yet non-trivial. Dependabot-like updates, Snyk findings, and tech debt refactors are perfect candidates. Dohmke’s pattern: let the agent handle the busywork, then require human approval at the edge. That keeps developers focused while maintaining a safety net for correctness and risk.

A concrete pipeline for safe automation:

  • Detection: Use Snyk, Dependabot, and static checks to identify vulnerabilities and outdated dependencies.
  • Remediation: Have an agent propose the patch, update lockfiles, and run unit/integration tests locally.
  • Validation: Enforce CI gates—tests, linters, security scans—and auto-generate a PR with a readable summary of deltas and risks.
  • Approval: Require codeowner review, then canary deploy with observability hooks; auto-revert on regressions.
  • Governance: Track agent-attributed changes separately for auditability and performance tuning.

For tech debt, Dohmke cites success stories of burning down issues in 25–30-year-old codebases using AI-assisted refactors (a thread he connects to lessons from Gene Kim and Steve Spear’s “Right Coding”). The key is scope control: target one module or dependency family at a time, use agents to generate migration plans and codemods, and verify with strong test harnesses. Done well, this frees significant creative time for net-new value.

Don’t Let Enterprise Sales Excuse Bad UX: The Battle for Wake Time

Dohmke warns against a common failure mode: using enterprise revenue motions to justify poor product quality. His recent attempt to set up SSO in a tool was needlessly painful—an avoidable tax that burns user trust and time. In a world where everything competes for “wake time” (work included), friction is expensive.

Dev tools teams should instrument and optimise “time-to-value” relentlessly:

  • Make onboarding one command or one copy-paste snippet; target a 5–15 minute “Hello, World” with meaningful output.
  • Ship SSO the modern way: OIDC first, just-in-time provisioning, sensible defaults, SCIM for lifecycle, and a clear, tested Okta/Azure AD/Google guide.
  • Provide a CLI that mirrors the UI for automation parity; include “doctor” commands to self-diagnose failures.
  • Maintain a friction log: every confusing step gets a ticket, owners, and a fix-by milestone.

Startups have an advantage here—no legacy customers or support contracts to constrain change. But that “happiest time” (no customers, no on-call, lots of prototyping) can backfire if it delays exposure to real users. Ship early to validate assumptions; polish ruthlessly on the path to product-market fit.

Honeymoon, Reality, and the Launch Flywheel

Both Podjarny and Dohmke acknowledge the founder’s “honeymoon” period: the runway is funded, the team is energised, and nobody is paging you at 3 a.m. Yet the anxiety grows the longer you avoid launch—what if you’re building something nobody wants? The antidote is the Amazon-style flywheel: ship, measure, learn, repeat.

Practical flywheel mechanics:

  • Define a narrow, high-pain use case, then release a minimal, lovable slice for that persona.
  • Wire telemetry before launch: command success rates, time-to-first-output, PR adoption of agent changes, and revert rates.
  • Run weekly customer councils; review recordings, friction logs, and metric deltas; ship fixes continuously.
  • Celebrate deletes and simplifications; every removed step or page reduces cognitive load and support cost.

As AI compresses timelines, incumbents and startups alike can place bigger product bets faster. But the conversation underscores a simple truth: velocity without feedback is risk, and scale without UX is churn. The teams that turn agent power into reliable, low-friction workflows will earn the right to compound.

Key Takeaways

  • Pick your lane: Startups optimise for learning speed and focus; incumbents should leverage platform distribution and trust. Both can innovate; constraints differ.
  • Start agent-first: Begin work by brainstorming with an agent in tools like Cloud Code, Cursor, or Gemini CI, then move to issues/backlogs once the first slice works.
  • Automate maintenance safely: Use agents to remediate security findings and tech debt with human-in-the-loop approvals, strong CI gates, and canary rollouts.
  • Ruthless UX focus: Measure and improve time-to-value. Make SSO/OIDC setup trivial, keep defaults secure, and maintain a friction log.
  • Launch the flywheel: Ship early to real users, wire telemetry, and iterate weekly. Velocity matters, but validated learning wins.
  • Guard your wake time: Reduce toil with agents so devs can spend more cycles on “net-new” creativity—where your product and business actually differentiate.

Chapters

Introduction
[00:00:56]
The Evolution of Developer Tools
[00:02:33]
The Impact of AI on Software Development
[00:04:26]
Challenges and Opportunities in AI Development
[00:09:15]
The Future of AI in Developer Tools
[00:17:20]
Competition and Innovation in the AI Space
[00:21:11]
Leveraging Microsoft's Scale for Startups
[00:26:15]
Agent Collaboration in Software Development
[00:31:22]
Composability and Switching Costs in AI Tools
[00:35:58]
The Evolution of Developer Skills
[00:44:50]
Teaching AI Skills to the Next Generation
[00:50:26]
The Importance of Engineering and Business Skills
[00:54:16]