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

## Executive summary

The discussion explores the massive acceleration of software delivery, noting the shift from quarterly releases to organizations deploying tens of thousands of changes daily (e.g., Anthropic's jump from 2,500 to 30,000 changes/day). The core argument is that while automated delivery and autonomous rollback are necessary, the bottleneck has moved to the 'last mile'—the ability to ensure a feature has a productive, positive impact on the end-user or business metrics, which requires human judgment and careful definition of success for AI agents.

## Key takeaways

- The Pace of Modern Delivery: The current pace of application delivery requires workflows far beyond traditional methods. The ability to roll back a deployment within seconds is necessary, but insufficient, given the volume of changes.
- Autonomous Rollback is Critical: For high-volume deployments, autonomous rollback mechanisms are needed, as human intervention in a 2:00 a.m. incident is too slow. AI is positioned as key to achieving this autonomous fail-safe.
- The Bottleneck Shifts to the Last Mile: As code generation becomes cheap (e.g., using LLMs), the primary bottleneck shifts from writing code or even code review to determining if the implemented feature has a genuinely productive impact on the end-user or business metrics.
- Defining Success for Agents: AI agents cannot understand abstract concepts like 'good' or 'bad.' To succeed, work must be decomposed into smaller, atomic units, and the desired outcome (success criteria) must be explicitly defined and measurable for the agent.

## Technical details

- Feature Flags and Release Management: Feature flags are a technique (not proprietary to LaunchDarkly) used to manage behavior and allow for gradual, controlled rollouts. A 'good' feature flag is one that is fully understood by the team, preventing 'stale flags' that can cause unexpected issues.
- Autonomous Rollback Systems: Advanced systems can monitor telemetry (error rate, operational metrics, ticket uptick) and automatically trigger a rollback without human intervention. This capability is crucial for high-velocity CI/CD.
- Agentic Coding and Workflow: The 'one-shot coding agent' dream is limited. Effective agent use requires decomposing complex tasks into smaller, atomic units and providing explicit guardrails and success metrics. The engineer's role shifts toward architecting and reviewing the agent's work (e.g., reviewing PRs generated by a fleet of agents).
- Runtime Controls for AI Agents: The concept of 'Agent Control' involves applying feature flag principles to AI models themselves. This allows developers to control an agent's behavior at runtime by switching models or adjusting prompts (e.g., if a chatbot starts generating excessive customer complaints or burning too many tokens).

## Practical implications

- Implement robust, automated feature flagging systems to manage risk during high-velocity deployments.
- Focus on defining measurable success criteria for any AI agent integration, rather than giving vague instructions (e.g., 'make it look good').
- Treat feature flagging as a core, continuous part of the SDLC, not just a release mechanism, to manage risk across multiple distributed teams.
- Develop internal processes to audit and clean up 'stale flags' to prevent technical debt and unexpected behavior.

## Topics

Software Delivery, Feature Flags, Autonomous Systems, AI Agents, CI/CD, Software Architecture, LaunchDarkly, Tessl

Source: https://www.youtube.com/watch?v=ao3GNietz1w
