# From AI-Assisted to AI-Native: Building a Frontier Development Team — Clare Liguori, AWS

## Executive summary

Frontier development represents a step-function improvement in productivity using AI agents, moving beyond simple coding assistance. The core finding is that success is not dependent on the tools themselves, but rather on intentionally changing engineering workflows and building new habits. Key practices include investing heavily in agent context, slowing down to refactor codebases (e.g., migrating from untyped languages like Python/JavaScript to TypeScript or Rust), implementing parallel agent execution, making intent explicit via documentation, and shifting testing left using local deterministic mocks.

## Key takeaways

- Frontier Development Definition: Productivity gains are characterized by engineers writing only 1-2% of the code; agents running for hours without interruption; and multiple agents operating in parallel. This represents a median productivity improvement of 4.5x to over 10x compared to previous AI phases (0:00, 7:04).
- The Importance of Process Over Tools: A pilot study involving 50 teams on existing codebases found that the difference between <3x and >4.5x productivity gains was determined by how the team worked, not the AI tools used (9:21).
- New Bottleneck Identification: As coding speed increases dramatically, the bottleneck shifts from writing code to decision-making speed and organizational review processes. Fast decisions, especially reversible ones, are critical for scaling (11:38).

## Technical details

- Agent Context Management: Engineers must proactively identify and document knowledge missing from agent steering files or skills files to prevent agents from making mistakes. Furthermore, teams must prune old workarounds from context as model capabilities improve (e.g., comparing Sonnet 3.7 to Opus 4.5) (8:14, 9:21).
- Codebase Refactoring for Agents: To enable agents, teams must intentionally slow down and perform deep engineering work on brownfield codebases. This includes improving error messages, building new tools/MCP servers, restructuring the codebase, or changing languages (e.g., moving from untyped Python/JavaScript to TypeScript or Rust) to improve testability and compiler feedback (10:31).
- Advanced Testing Strategies: To enable agents to run autonomously for hours, teams must implement fast feedback loops by shifting testing left. This involves adding unit tests, integration tests, performance tests, security tests, and utilizing local deterministic mocks instead of relying solely on end-to-end cloud services (12:50).
- Agent Workflow Optimization: Productivity increases by 'feeding' agents with clear tasks and validation criteria rather than continuously 'babysitting' them through back-and-forth conversations. Agents should be designed to self-correct only when they meet a high quality bar (e.g., passing tests, compiling successfully) (10:31).

## Practical implications

- Prioritize process change and habit formation over tool adoption to achieve significant productivity gains.
- Invest in improving the underlying code quality (typing, error handling) of legacy systems before expecting agents to succeed.
- Implement robust local testing environments using deterministic mocks to give AI agents fast feedback loops for self-correction.
- Shift focus from writing code to defining clear requirements and optimizing organizational decision-making processes.

## Topics

AI Engineering, Software Architecture, Build Process, Productivity, CI/CD, Kiro, AWS Bedrock, Sonnet 3.7 / Opus 4.5

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