More The AI Native Dev episodes

Edith Harbaugh: Code Is Cheap. The Last Mile Isn't. thumbnail

Edith Harbaugh: Code Is Cheap. The Last Mile Isn't.

Published 10 Nov 2026

Duration: 00:49:29

Feature flags and AI agents transform software delivery by enabling autonomous rollbacks and rapid iteration, though human judgment remains vital for defining success and maintaining stability.

Episode Description

Automated software delivery is moving faster than the people who used to approve every release. LaunchDarkly co-founder and CEO Edith Harbaugh tells G...

Overview

The conversation explores how the pace of software delivery has shifted from quarterly releases to thousands of changes per day, and what infrastructure supports that velocity. Edith Harbaugh, founder and CEO of LaunchDarkly, discusses feature flags as a vendor-independent technique for controlling behavior in production, enabling rapid rollbacks and gradual rollouts without a full redeploy.

The discussion extends to AI agents in development workflows. Harbaugh describes how agents can handle autonomous rollbacks, flag cleanup, and code review at scale, but notes that compliance requirements and the need for human judgment on what good looks like remain barriers to full autonomy. She frames the software factory metaphor as a way to think about repeatability and gates in the development lifecycle, with feature flags occupying the last mile between code review and production impact.

A recurring theme is the distinction between technical capability and product judgment: agents can execute changes, but defining success criteria, managing risk tolerance, and making bold strategic decisions still require human irrationality and vision. Harbaugh also describes LaunchDarkly's Agent Control product, which allows runtime switching of models and prompts for agents without redeployment.

What If

  • What if you wrapped your next feature in a flag and gated it to a small user subset before full release?

    • Move: Before your next release, wrap the feature in a feature flag and expose it to a small percentage of users while monitoring error rates and engagement metrics, then expand or roll back based on telemetry.
    • Why Now?: The source notes that even at "10 or 100 changes a day you need a way where you can quickly detect if something is going right or wrong and move it back". As a solo operator, a bad deploy without a flag means a full redeploy cycle.
    • Expected Upside: You could potentially roll back within seconds rather than hours, reducing the blast radius of a bad change and freeing you to iterate on the next feature immediately.
  • What if you decomposed your next refactor into atomic agent tasks instead of one broad prompt?

    • Move: Break your next codebase cleanup into specific, verifiable tasks (e.g., "ensure all functions in module X are documented," "identify unused imports in module Y") and point an agent at each one individually.
    • Why Now?: The source describes how the "one-shot agent that goes away and doesn't work is more like us trying to decompose work into smaller and smaller and smaller and smaller atomic units". Vague instructions like "refactor" produce unusable output.
    • Expected Upside: You could potentially get usable, verifiable agent output on a solo project without needing a team to coordinate scope or interpret ambiguous directives.
  • What if you ran an agent to audit and clean up stale feature flags in your codebase?

    • Move: Point an agent at your existing flags and have it determine which are still in use, which are redundant, and which can be safely deleted, then review and approve the removals.
    • Why Now?: The source describes an agent that "goes around examine every flag and say is this still in use is it still needed and if not uh safely delete it". Flag sprawl from "adding features for every release" is a known source of accidental misfires.
    • Expected Upside: You could potentially eliminate the "boring part of doing the dishes" that accumulates over time, reducing the risk of an unknown flag being accidentally triggered in production.

Takeaway

  • Wrap every new feature in a feature flag before release so you can roll back within seconds if telemetry shows problems, rather than performing a full redeploy.
  • Before deploying any agent task, write explicit success and failure criteria (e.g., "load within this time," "performant to this standard") so the agent has concrete guardrails to verify against.
  • Schedule recurring flag cleanup: examine every flag to determine if it's still in use and delete stale ones, treating it as ongoing maintenance rather than a one-time project.
  • When using agents for code changes, decompose work into atomic, specific tasks rather than broad instructions like "refactor," since agents lack the implicit shared context humans have.
  • Define your risk tolerance per feature: identify which changes can proceed autonomously and which require human sign-off, particularly for compliance-sensitive areas like SOC or HIPAA.

Recent Episodes of The AI Native Dev

27 Oct 2026 Caleb Sima: AI Attackers Move at Machine Speed

"AI-driven cybersecurity threats are evolving rapidly, with attackers leveraging speed, complexity, and swarm-like behavior to exploit vulnerabilities, necessitating advanced defensive strategies like automation and high-fidelity monitoring to counter escalating risks."

13 Oct 2026 Maria Gorinova: Feedback Loops That Fix Your Codebase

"Software factories and agentic coding require robust feedback loops to balance efficiency, reliability, and human oversight, with structured workflows and clear intent improving automation outcomes."

6 Oct 2026 Legora CTO: Why AI Agents Need More Than a Chat Window

"AI enhances legal and engineering workflows by automating tasks like drafting and coding, but human judgment remains critical for subjective or high-stakes decisions, with tools like Legora streamlining processes while addressing challenges in tooling, orchestration, and resource optimization."

More The AI Native Dev episodes