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

Clare Liguori, AWS

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/pqlWNihgdjI-from-ai-assisted-ai-native-building-frontier) · [Video](https://www.youtube.com/watch?v=pqlWNihgdjI)

## From AI-Assisted to AI-Native: Building a Frontier Development Team

Clare Liguori explains how Amazon teams changed their daily work to support hours of independent agent execution—and why faster implementation shifts the bottleneck toward review, organizational learning and decisions.

### What changes when engineers leave the continuous loop

[0:12](https://www.youtube.com/watch?v=pqlWNihgdjI&t=12s)

Inline completion helps write the next line or function. Chat answers questions about a codebase. Vibe coding turns implementation into a running conversation. Yet Clare Liguori, Senior Principal Engineer at AWS working mostly on Kiro, had personally felt only about a 10–20% productivity improvement through those earlier phases. That is her anecdotal starting point. Amazon’s internal pilots were beginning to report much larger gains: a median of 4.5×, sometimes exceeding 10×. The question is what changed in the work itself.

Amazon calls the emerging practice **frontier development** and defines it through observable behavior:

- **Hands-off coding:** Engineers write perhaps 1–2% of the code they produce; agents write the rest.
- **Infrequent intervention:** Engineers aim to give agents enough direction to run for hours without interruption.
- **Concurrent work:** Multiple agents work through a backlog in parallel, reducing idle time.

These behaviors change where human attention goes. An engineer must prepare work that can continue without a new instruction after every generated change.

### An exceptional team, then a carefully prepared sprint

[2:11](https://www.youtube.com/watch?v=pqlWNihgdjI&t=131s)

The first striking example was Bedrock Mantle. Bedrock’s model-hosting service needed a new inference data plane, with an original estimate of 30 people over 18 months. The anticipated work included building the service and migrating customers and models. Instead, six engineers built the new data plane in 76 days with Kiro. Liguori describes this as the pathfinder result, reporting up to 20× improvement from an assessment that looked at commits.

The six included two distinguished engineers and some of Amazon’s strongest experts in distributed systems and LLM architecture. Their result established a possibility, but its staffing made reproduction an immediate concern. Other teams could adopt the tool; they could not simply acquire the same concentration of expertise.

Prime Video tested a different group of six engineers in a 10-day sprint. Their progress changed the project delivery estimate from 90 weeks to 24 weeks, and the team compared sprint commits with its earlier commit history. The 24-week figure was a revised forecast, rather than a completed delivery. The conditions were also unusually favorable: no on-call duties, limited meetings and few distractions.

The preparation explains part of what made that sprint executable. A senior engineer had spent the preceding three weeks creating small, well-scoped tasks with detailed requirements. Six engineers could then spend the protected sprint churning through already-defined work. The fast execution rested on earlier human effort to remove ambiguity. That left the next question: could ordinary teams sustain this pattern while maintaining existing systems and handling their normal obligations?

### Fifty ordinary teams expose the difference in working practices

[5:41](https://www.youtube.com/watch?v=pqlWNihgdjI&t=341s)

Amazon Stores observed 50 teams for the better part of a year. These teams had normal mixes of early-career, mid-career and senior engineers. They worked in existing codebases, unlike Mantle’s greenfield build. The measure also moved closer to customer delivery: deployment velocity to production, or how quickly teams could get changes out to customers.

Half the teams achieved less than a 3× increase. The stronger-performing half saw a median of 4.5×, with some exceeding 10×. Ninety percent used Kiro alongside other internal tools. Liguori attributes the split to deliberate changes in working practices: the teams pulling ahead reorganized how they worked, while the others added assistants to their existing routines. This observational account does not isolate the causal effect of individual habits or establish gains every team should expect. Its deployment measure also differs from the earlier commit assessments and revised project estimate.

Interviews with the pilot teams, Bedrock Mantle and Prime Video produced five recurring habits. The emphasis on habits matters: a protected sprint can demonstrate potential, while everyday development requires a repeatable way to define, delegate and check work. Building that routine takes time.

### Write down team knowledge, then make the codebase easier to work in

[8:10](https://www.youtube.com/watch?v=pqlWNihgdjI&t=490s)

The first habit is investing in agent context. Much of a team’s operating knowledge lives in people’s heads and moves through Slack conversations, onboarding, mentoring, code reviews, stand-ups and sprint planning. Agents need access to that knowledge too. Whenever an agent makes a mistake or chooses an unwanted approach, the practical question is what it needed to know that was missing from the skills or steering files. Those files turn a correction into guidance available on future tasks.

Context maintenance includes subtraction. Earlier models required numerous prohibitions to work around recurring quirks; improved model behavior made some of those instructions unnecessary. Keeping every old workaround adds context without necessarily improving the next run. The habit therefore has two directions: add missing team knowledge, and prune instructions whose original purpose has disappeared.

The second habit is accepting an initial slowdown. Almost every interviewed team reported lower productivity while intentionally adopting its new workflow. Existing codebases needed engineering work before agents could succeed independently. That investment addressed several distinct obstacles:

- **Opaque failures:** Better tool error messages helped models understand what went wrong and attempt a correction.
- **Missing operations:** New tools and MCP servers gave agents ways to perform work they otherwise could not complete.
- **Difficult navigation:** Restructuring code helped agents find and understand the parts they needed to change.

These are concrete preparation costs, rather than benefits that arrive automatically with access to a coding assistant.

Some teams went as far as changing programming languages. Liguori had seen teams struggle with Python and JavaScript when their workflow lacked compiler feedback that would expose mistakes before the agent returned its work. Moves to TypeScript and use of Rust offered more useful compiler diagnostics. The mechanism is actionable feedback: the agent gets a signal it can use to repair its own output. A language migration is optional, and these examples do not establish that every codebase needs one.

### Give agents a completion standard and resolve intent before code

[11:10](https://www.youtube.com/watch?v=pqlWNihgdjI&t=670s)

The third habit addresses the engineer’s own waiting time. A conversation that repeatedly generates code, waits 30 seconds to a minute, and returns for human review keeps the engineer occupied throughout execution. Each response requires reading and redirection. That attention cannot also go to other work, and running several such conversations in parallel becomes difficult.

An independent assignment gives the agent both the work and the means to validate it. The agent should keep correcting its changes until they meet a stated quality bar: the code runs, compiles, passes tests, is testable and has high coverage. Putting these expectations in steering files makes them recurring instructions. The human no longer has to supply the same completion standard in every prompt.

The fourth habit is making intent explicit. A high-level prompt can produce extensive changes before anyone notices that the requirements or technical design were misunderstood. Correcting code scattered across a repository is then an expensive way to discover what the feature should do. For ambiguous, complex work, Amazon engineers refine a specification before implementation.

Kiro can generate the initial specification, so explicit intent does not require manually writing the whole document. The engineer and model can work through disagreements in one place before those disagreements become implementation changes. Conversation remains useful here: its purpose is to settle the task, giving later autonomous execution a clearer destination.

### Move testing earlier so the agent can correct itself locally

[13:33](https://www.youtube.com/watch?v=pqlWNihgdjI&t=813s)

The fifth habit, shifting testing left, supplies the feedback that makes a long independent run useful. Agents will make mistakes. Linters and unit, integration, performance and security tests give them signals they can act on before returning to an engineer. Familiar engineering hygiene gains another use: the same checks can support repeated autonomous correction throughout implementation.

A concrete change is the move from integration tests that depend on live services to mock services with deterministic responses running entirely locally. In the earlier arrangement, testing required starting other services and connecting to cloud systems. With local mocks, the agent can perform the test loop on a laptop. A failed check supplies feedback; the agent changes the code and checks again. Reducing the wait for each result permits more correction cycles in the same period. The benefit concerns speed and repeatability in this local loop; a mock does not establish every property of the live integration.

Where does the engineer stop being required at every turn? The diagram follows that local correction loop: the assignment and quality bar enter at the start, while failed checks return to implementation rather than immediately returning to the human.

The loop makes the relationship between testing and autonomy visible. Clear instructions alone cannot tell the agent whether its implementation works. Local checks supply that information quickly enough for it to continue repairing the change. Meeting the completion standard becomes the point at which it returns to the engineer.

A local feedback loop supports independent execution
Deterministic local mocks reduce dependency setup and cloud connections in the test loop. Failed checks guide another correction; passing the stated quality bar ends the independent assignment.
- Work and quality bar — Specify what to do and how to self-validate.
- Implement or correct — The agent changes its work using feedback.
- Run local checks — Tests use mock services with deterministic responses.
- Return to the engineer — The work meets the stated completion standard.
- Work and quality bar → Implement or correct (Start independent work)
- Implement or correct → Run local checks (Validate the change)
- Run local checks → Implement or correct (Failure guides correction)
- Run local checks → Return to the engineer (Quality bar met)

### Parallel agents still create human work

[15:02](https://www.youtube.com/watch?v=pqlWNihgdjI&t=902s)

These habits do not produce effortless productivity. Engineers may stay up late trying to perfect a prompt so an agent can run overnight and leave a finished change in the morning. Multiple concurrent agents also mean switching between terminal tabs and tasks. Independence at the agent level can increase pressure and cognitive load for the person coordinating the work.

Review is a particular difficulty. Senior engineers have often spent years assessing other people’s code. Early-career engineers may not yet have developed that skill, and reviewing generated output can feel harder than writing the code themselves. Reducing manual implementation therefore changes the human task; it does not necessarily make that task easier.

Organizations must also allow the initial investment. Liguori admits sharing the leadership temptation to ask why a team with strong models and tools is not already shipping faster. She describes taking two months to invest in a codebase, discover team practices and establish new habits. Constant pressure to ship features every month can consume the time needed to make agents effective.

Expansion needs the same patience. Amazon learned through an exceptional pathfinder, a focused sprint and the 50-team pilot before attempting broader adoption. At the time of the talk, the 2026 challenge was extending the approach to the next 2,000 teams—a scaling objective, rather than an achieved result. An immediate organization-wide mandate would send teams into the new workflow before they had learned which practices and context their own environment required.

### Faster implementation makes decision delays dominate

[18:32](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1112s)

The ending moves beyond coding practices to the time a customer waits for a product. Liguori describes work that previously took 9–12 months to implement and can now take 1–2 months. If the organization still spends two months deciding whether to build it and another two months approving launch, those decisions become the longest part of delivery. Their duration did not have to increase for them to become the bottleneck; implementation became much shorter.

Frontier teams can consequently spend more time making decisions than writing code. The practical recommendation is to make decisions faster, especially when they are easy to reverse. Reversibility identifies choices that can be revisited, giving organizations a specific place to reduce deliberation as the implementation loop accelerates.

Frontier development requires a deliberate change in daily work across engineers and their organizations. The closing invitation is to examine each interaction with an AI tool: what knowledge, clearer intent or feedback would let the work continue without another intervention? The same question eventually reaches product decisions and launch processes. Freed attention still needs somewhere useful to go.

## Key takeaways

- The 50-team pilot associated stronger deployment gains with deliberate workflow changes. Commit counts, revised delivery estimates and deployment velocity describe different outcomes.
- Agent context needs maintenance in both directions: preserve missing team knowledge and remove obsolete model workarounds.
- Independent execution depends on clear intent and actionable checks. Local deterministic mocks shorten the correction loop, allowing agents to repair more mistakes before returning.
- Allow time for codebase investment and bounded organizational learning. Parallel agents also increase coordination and review demands, particularly for less experienced reviewers.
- When implementation shrinks, product decisions and launch approvals can dominate delivery time. Decisions that are easy to reverse are a specific opportunity to move faster.

## Related talks

- [Spec-Driven Development: Agentic Coding at FAANG Scale and Quality — Al Harris, Amazon Kiro](https://ai.engineer/talks/HY_JyxAZsiE-spec-driven-development-agentic-coding-at-faang) — Continue with the specification approach that gives autonomous implementation a clearer destination.
- [Making Codebases "Agent-Ready"](https://ai.engineer/talks/ShuJ_CN6zr4-making-codebases-agent-ready) — Explore the codebase preparation behind the initial slowdown and later independent execution.
- [Let’s Talk About FOMAT – Fear of Missing Agent Time](https://ai.engineer/talks/W-SX_srBa3Y-lets-talk-about-fomat-fear-missing-agent) — Follow the human pressure created by trying to keep agents working continuously.

## Slides

### From AI-Assisted to AI-Native

Clare Liguori introduces practices used by Amazon teams that she says have produced substantial productivity improvements.

[0:17](https://www.youtube.com/watch?v=pqlWNihgdjI&t=17s) [Title slide for Building a Frontier Development Team, presented by Clare Liguori of Amazon Web Services.](https://assets.ai.engineer/sites/aiecode2025/sha256/fe75ec5095df8f76796ab91f8be16fd1c3d24be1fde12b2980d98d168bf64fd8.webp)

From AI-Assisted to AI-Native
Building a Frontier Development Team

Clare Liguori
Senior Principal Engineer
Amazon Web Services

aws

© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Evolution of AI for development: earlier stages

Liguori places frontier development after code completion, code questions and vibe coding. She estimates the first three made her 10–20% more productive, based on her own experience.

[1:09](https://www.youtube.com/watch?v=pqlWNihgdjI&t=69s) [Four stages of AI development, with an anecdotal 10–20% productivity improvement attributed to the first three.](https://assets.ai.engineer/sites/aiecode2025/sha256/449ba150206218d8b1752b413ee3b42797cf1dcdeec7b2f0e4d03dc6a141115f.webp)

Evolution of AI for development

Inline code completion
Ask questions about my code
Vibe coding
Frontier development

Anecdotally, 10 – 20% productivity improvement

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Evolution of AI for development: frontier development

Liguori contrasts her anecdotal 10–20% productivity gain from earlier AI tools with Amazon pilots reporting a 4.5x median improvement for frontier development, and more than 10x for some teams.

[1:21](https://www.youtube.com/watch?v=pqlWNihgdjI&t=81s) [Four stages of AI development, with an internal pilot reporting a 4.5x median productivity improvement for frontier development and more than 10x for some teams.](https://assets.ai.engineer/sites/aiecode2025/sha256/2d7fb07e126f0afa90767fe6d5b60aeea8512131b0e6207cf3626528f8f4cb4b.webp)

Evolution of AI for development

Inline code completion
Ask questions about my code
Vibe coding
Frontier development

Internal pilot study shows 4.5x median productivity improvement; some teams more than 10x

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Frontier developers

Liguori describes Amazon frontier developers who hand-write 1–2% of their code, aim for hours of autonomous assistant work, and keep parallel agents working through a backlog.

[1:39](https://www.youtube.com/watch?v=pqlWNihgdjI&t=99s) [Three behaviors: hands-off coding, infrequent agent interaction, and minimizing agent idle time, beside an illustration of a wagon train with computers.](https://assets.ai.engineer/sites/aiecode2025/sha256/a5f9d6fe673afce25fdf5d4d0f55fed6ecb196ba001b4ef9c1dcd57dc646c130.webp)

Frontier developers

1. Hands-off coding: Hand-write 1-2% of the code they produce.
2. Interact with agents infrequently: Aim to get a coding assistant to run for long periods on its own, often on the order of hours.
3. Minimize agent idle time: Keep multiple agents continuously active in parallel on a steady stream of tasks.

SPRINT PLANNING
[illegible]

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### The pathfinder: Amazon Bedrock Mantle

Six people built Bedrock Mantle with Kiro in 76 days, against a projection of 30 people over 18 months. Commits rose from two to 40 per week.

[2:20](https://www.youtube.com/watch?v=pqlWNihgdjI&t=140s) [Slide reports 86% faster delivery, 80% fewer people, and a 20-fold increase in commits for the Bedrock Mantle project.](https://assets.ai.engineer/sites/aiecode2025/sha256/29a9851a43f75db2b8d329f7e347f06c48a4b894cbb016082957dfecbc24e0e5.webp)

The pathfinder: Amazon Bedrock Mantle
A brand-new inference data plane built entirely with Kiro

86%
faster project delivery:
76 days vs. 18-month projection

80%
fewer people:
6 people vs. 30 person projection

20x
increase in commits:
40 commits per week, up from two

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Amazon Bedrock Mantle team

Mantle’s six-person team included two distinguished engineers, a senior principal engineer and three principal engineers. Liguori says their expertise raised questions about whether other teams could reproduce the result.

[3:26](https://www.youtube.com/watch?v=pqlWNihgdjI&t=206s) [The six-person team included two distinguished engineers, one senior principal engineer and three principal engineers.](https://assets.ai.engineer/sites/aiecode2025/sha256/5e31d30466ea5b62e0ff2f752dc475c211bb1114d651d8428887bc71c48d8524.webp)

The pathfinder: Amazon Bedrock Mantle
A brand-new inference data plane built entirely with Kiro

“Built with only six people”*

* 2 Distinguished Engineers
  1 Senior Principal Engineer
  3 Principal Engineers

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Prime Video Financial Systems sprint results

Six engineers used Kiro in a 10-day sprint. Their project delivery estimate fell from 90 to 24 weeks, while they made 556 commits against a baseline of 96.

[4:03](https://www.youtube.com/watch?v=pqlWNihgdjI&t=243s) [A 10-day sprint reduced the project delivery estimate from 90 to 24 weeks and produced 556 commits versus a baseline of 96.](https://assets.ai.engineer/sites/aiecode2025/sha256/81d88eb3d65dc01d6444d199d1c089906363457daa8e26e3d10a54011356226c.webp)

The sprint: Prime Video Financial Systems
10-day experiment with six engineers in one room

73%
faster project delivery: reduced estimate from 90 to 24 weeks

5.8x
increase in commits: 556 commits vs baseline of 96

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Prime Video sprint conditions

For the 10-day sprint, six engineers had no on-call duties and limited meetings. A senior engineer spent three prior weeks preparing well-scoped tasks with detailed requirements.

[4:59](https://www.youtube.com/watch?v=pqlWNihgdjI&t=299s) [The six engineers had no on-call duties and limited meetings; a senior engineer spent three weeks preparing scoped tasks and detailed requirements.](https://assets.ai.engineer/sites/aiecode2025/sha256/a32c83b31f16e17505ba23d80514b84e2cf4f522a3971f375f31c59ae9f2a9e2.webp)

The sprint: Prime Video Financial Systems
10-day experiment with six engineers in one room

“Six engineers in one room”*

* No on-call duties.
Limited meetings.
Senior engineer spent 3 weeks prior creating well-scoped tasks with detailed requirements.

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Amazon Stores AI adoption pilot

In a 2025 pilot of 50 teams, 25 adding AI to existing workflows saw under 3x productivity gains; 25 changing how they worked saw a 4.5x median. Productivity meant production deployment velocity.

[5:46](https://www.youtube.com/watch?v=pqlWNihgdjI&t=346s) [A 50-team study compares 25 teams with less than threefold productivity gains against 25 teams with 4.5-fold median productivity; productivity is production deployment velocity.](https://assets.ai.engineer/sites/aiecode2025/sha256/f4d03b2e4a95f6ede3e41bba51224cf6ae748fec7f19b7874e71d3462bc83135.webp)

The pilot: Amazon Stores

2025 study of AI adoption across 50 “normal” teams: typical distribution of experience, working on brownfield systems.

50%
25 teams saw <3x productivity increase: Sprinkled Kiro and other internal AI tools on their existing way of working

50%
25 teams saw 4.5x median productivity: Intentionally adopted a new way of working with Kiro and other internal AI tools

Productivity = production deployment velocity

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Habits of frontier teams

Interviews across the pilot and other teams surfaced five habits, from investing in agent context to shifting testing left. Liguori emphasizes that teams build these habits day to day.

[7:47](https://www.youtube.com/watch?v=pqlWNihgdjI&t=467s) [Five habits: invest in agent context, slow down to speed up, feed agents without babysitting, make intent explicit and shift testing left.](https://assets.ai.engineer/sites/aiecode2025/sha256/9c300b310a4d90b2783fb1835fbcef71683c13bda49fc5cc895d293fc0735f62.webp)

Habits of frontier teams

1. Invest in agent context
2. Slow down to speed up
3. Feed agents, don’t babysit
4. Make intent explicit
5. Shift testing left

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Invest in agent context

Write down team knowledge for agents. Use mistakes to find missing guidance, then revisit skills as new models improve so outdated instructions do not bloat context.

[8:24](https://www.youtube.com/watch?v=pqlWNihgdjI&t=504s) [After an agent mistake, ask what is missing from skills files; when a new model is released, reconsider what the skills still need.](https://assets.ai.engineer/sites/aiecode2025/sha256/19b699a72f2c924c071d5f16d4ecfb0f202b7ed11e10aaf927e6ba6fd2c45284.webp)

Habit 1: Invest in agent context

Every time the agent makes a mistake:
“What am I missing in my skills files?”

Every time a new model is released:
“Do I still need this in my skills?

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Habit 2: Slow down to speed up

Almost every interviewed team reported a productivity dip while adopting a new way of working. Liguori recommends investing in agent context, tools, and codebases to help agents work effectively.

[9:37](https://www.youtube.com/watch?v=pqlWNihgdjI&t=577s) [Checklist of engineering investments: agent context, better error messages, new tools and MCP servers, codebase restructuring, and programming language changes.](https://assets.ai.engineer/sites/aiecode2025/sha256/9c21c90abf99e842bc09206ba359d25e81570decd9486691549778889e714dda.webp)

Habit 2: Slow down to speed up

Plan for intentional engineering work:
✓ Build agent context
✓ Improve existing tools’ error messages
✓ Build new tools and MCP servers
✓ Restructure codebase
✓ Change programming language

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Habit 3: Feed agents, don’t babysit

Give agents the task and its validation criteria upfront. In the authorization example, that includes passing unit and integration tests and 90% coverage for new code, so the agent can self-correct before returning.

[11:07](https://www.youtube.com/watch?v=pqlWNihgdjI&t=667s) [Compares repeated back-and-forth instructions with a complete authorization task that includes tests and validation criteria.](https://assets.ai.engineer/sites/aiecode2025/sha256/cf9c2281860b3cd9fbdad7c794c04c2f4579cd94aad261198931dd9efb1fc7e1.webp)

Habit 3: Feed agents, don’t babysit

Babysitting:
Lots of back and forth
- Add authorization to this API
- Add tests
- The tests don’t pass
- The tests still don’t pass
- We don’t have enough test coverage
- Add integration tests
- The integ tests don’t pass

Feeding:
Provide what to do + how to validate
- Add authorization to this API. Add unit tests. Run the unit tests; ensure they pass and achieve 90% coverage for the new code. Add integ tests to validate authorization and ensure they pass.

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Habit 4: Make intent explicit

For ambiguous, complex features, Liguori recommends iterating on a specification with the agent: correcting intent in a document is easier than revising code scattered across a codebase.

[12:32](https://www.youtube.com/watch?v=pqlWNihgdjI&t=752s) [Feature specification template covering objective, use cases, key functionality, and technical requirements and design.](https://assets.ai.engineer/sites/aiecode2025/sha256/2b031d72250ea855fcdeabc65c87b35c382dd6dc8c38cfb06cb8aec82578a981.webp)

Habit 4: Make intent explicit

# Feature Specification

## Objective
What is the main objective or purpose of the project

## Use Cases
Who are the users and how will they use the feature

## Key Functionality
What are the key elements, style, and design approach required

## Technical Requirements and Design
What specific technical or quality requirements must be met and how should the feature be implemented

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Habit 5: Shift testing left

Linters, tests and local mock services give agents fast feedback so they can self-correct. Liguori says deterministic mock responses let agents run more feedback loops locally.

[13:52](https://www.youtube.com/watch?v=pqlWNihgdjI&t=832s) [A fast local feedback loop includes linters, mock services, and unit, integration, performance, and security tests.](https://assets.ai.engineer/sites/aiecode2025/sha256/2cb76d091abb6dfbc48bdb0f5af118d863b776d22ca71956402d96dc83441e15.webp)

Habit 5: Shift testing left

Give the agent a fast, local feedback loop:
✓ Linters
✓ Mock services
✓ Unit tests
✓ Integration tests
✓ Performance tests
✓ Security tests

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### What is still hard: Burnout

Engineers stay up late preparing agents for overnight runs, while switching between parallel agents adds cognitive load. Liguori says reviewing AI output can be especially hard for early-career engineers.

[15:42](https://www.youtube.com/watch?v=pqlWNihgdjI&t=942s) [Burnout concerns include fear of missing agent time, cognitive load from parallel agents, and the difficulty of reviewing AI output.](https://assets.ai.engineer/sites/aiecode2025/sha256/1936ffd248ae8c68ee323620e215332692b6ada695d9240b97be30d8e0440fca.webp)

What is still hard: Burnout

• FOMAT: Fear Of Missing Agent Time
• Cognitive load increases with number of parallel agents
• Reviewing AI output sometimes harder than writing it

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### What is still hard: Organizational change

Liguori says teams need time to adapt their code and habits before scaling. As coding speeds up, decisions and launch reviews can become new bottlenecks.

[16:42](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1002s) [Organizational challenges include accepting a temporary slowdown, moving too broadly and quickly, and new bottlenecks.](https://assets.ai.engineer/sites/aiecode2025/sha256/25569e6fe6147792042307ce1ddc1b74c3fc2167b051e6536309aa5be7cd85fb.webp)

What is still hard: Organizational change

• Accepting slowing down to speed up
• Going too broad, too fast
• New bottlenecks

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

### Intentionally change the way you work

Liguori says frontier engineering requires new habits across teams and organizations, including changing how people interact with AI tools to free themselves from being in the loop.

[19:56](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1196s) [Closing slide presents the takeaway: intentionally change the way you work.](https://assets.ai.engineer/sites/aiecode2025/sha256/c87bf4ad624a84e29513335feb679112d912520923c8ccd3513e4bfc107fd49c.webp)

My one big takeaway:
Intentionally change the way you work

Clare Liguori
X @clare_liguori
linkedin.com/in/clareliguori

aws
© 2026, Amazon Web Services, Inc. or its affiliates. All rights reserved.

## Full transcript

[0:01](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1s) [music]

[0:12](https://www.youtube.com/watch?v=pqlWNihgdjI&t=12s) >> My name is Claire La Gory and I'm a

[0:15](https://www.youtube.com/watch?v=pqlWNihgdjI&t=15s) senior principal engineer at AWS. I

[0:18](https://www.youtube.com/watch?v=pqlWNihgdjI&t=18s) mostly work on Kuro, our agent encoding

[0:20](https://www.youtube.com/watch?v=pqlWNihgdjI&t=20s) assistant, but today I want to talk

[0:22](https://www.youtube.com/watch?v=pqlWNihgdjI&t=22s) about some of the practices we've been

[0:24](https://www.youtube.com/watch?v=pqlWNihgdjI&t=24s) seeing inside of Amazon and Amazon teams

[0:27](https://www.youtube.com/watch?v=pqlWNihgdjI&t=27s) where we've been seeing really exciting

[0:29](https://www.youtube.com/watch?v=pqlWNihgdjI&t=29s) results of productivity increases that

[0:33](https://www.youtube.com/watch?v=pqlWNihgdjI&t=33s) are step function improvements since

[0:34](https://www.youtube.com/watch?v=pqlWNihgdjI&t=34s) what what we've been seeing with AI so

[0:36](https://www.youtube.com/watch?v=pqlWNihgdjI&t=36s) far.

[0:38](https://www.youtube.com/watch?v=pqlWNihgdjI&t=38s) So, I've been working on agentic AI for

[0:42](https://www.youtube.com/watch?v=pqlWNihgdjI&t=42s) over 3 years now and I've kind of seen

[0:44](https://www.youtube.com/watch?v=pqlWNihgdjI&t=44s) the evolution that's happened in our

[0:46](https://www.youtube.com/watch?v=pqlWNihgdjI&t=46s) industry when it comes to coding

[0:48](https://www.youtube.com/watch?v=pqlWNihgdjI&t=48s) assistance with AI. First, we had this

[0:51](https://www.youtube.com/watch?v=pqlWNihgdjI&t=51s) inline code completion helping us to

[0:54](https://www.youtube.com/watch?v=pqlWNihgdjI&t=54s) write the next line, maybe the next

[0:56](https://www.youtube.com/watch?v=pqlWNihgdjI&t=56s) function. We moved on to chat, asking

[0:59](https://www.youtube.com/watch?v=pqlWNihgdjI&t=59s) questions about our code. Everybody

[1:01](https://www.youtube.com/watch?v=pqlWNihgdjI&t=61s) started doing vibe coding sometime last

[1:03](https://www.youtube.com/watch?v=pqlWNihgdjI&t=63s) year, but now we're starting to see kind

[1:06](https://www.youtube.com/watch?v=pqlWNihgdjI&t=66s) of an early adopter phase of what we've

[1:08](https://www.youtube.com/watch?v=pqlWNihgdjI&t=68s) been calling frontier development.

[1:11](https://www.youtube.com/watch?v=pqlWNihgdjI&t=71s) And completely anecdotally, based on my

[1:13](https://www.youtube.com/watch?v=pqlWNihgdjI&t=73s) own experience, I've really only felt

[1:16](https://www.youtube.com/watch?v=pqlWNihgdjI&t=76s) maybe 10 to 20% more productive with all

[1:19](https://www.youtube.com/watch?v=pqlWNihgdjI&t=79s) of these phases that have come before.

[1:22](https://www.youtube.com/watch?v=pqlWNihgdjI&t=82s) But now inside of Amazon, we've been

[1:24](https://www.youtube.com/watch?v=pqlWNihgdjI&t=84s) running pilots with different teams

[1:26](https://www.youtube.com/watch?v=pqlWNihgdjI&t=86s) across the company and we've been seeing

[1:29](https://www.youtube.com/watch?v=pqlWNihgdjI&t=89s) a median of 4.5x productivity

[1:31](https://www.youtube.com/watch?v=pqlWNihgdjI&t=91s) improvement and sometimes more than 10x.

[1:34](https://www.youtube.com/watch?v=pqlWNihgdjI&t=94s) So, something has really changed here

[1:36](https://www.youtube.com/watch?v=pqlWNihgdjI&t=96s) now that we're seeing these step

[1:38](https://www.youtube.com/watch?v=pqlWNihgdjI&t=98s) function improvements in productivity.

[1:40](https://www.youtube.com/watch?v=pqlWNihgdjI&t=100s) And I like to

[1:43](https://www.youtube.com/watch?v=pqlWNihgdjI&t=103s) define what we've been calling frontier

[1:45](https://www.youtube.com/watch?v=pqlWNihgdjI&t=105s) developers inside of Amazon by three

[1:48](https://www.youtube.com/watch?v=pqlWNihgdjI&t=108s) behaviors that I've been seeing. One is

[1:51](https://www.youtube.com/watch?v=pqlWNihgdjI&t=111s) hands-off coding. Frontier developers

[1:53](https://www.youtube.com/watch?v=pqlWNihgdjI&t=113s) write maybe 1 to 2% of the code that

[1:56](https://www.youtube.com/watch?v=pqlWNihgdjI&t=116s) they produce. The rest is agents.

[2:00](https://www.youtube.com/watch?v=pqlWNihgdjI&t=120s) The second is that they interact with

[2:01](https://www.youtube.com/watch?v=pqlWNihgdjI&t=121s) their agents infrequently. They'll aim

[2:04](https://www.youtube.com/watch?v=pqlWNihgdjI&t=124s) to get their coding assistant to run for

[2:06](https://www.youtube.com/watch?v=pqlWNihgdjI&t=126s) up to hours at a time without their

[2:09](https://www.youtube.com/watch?v=pqlWNihgdjI&t=129s) intervention.

[2:10](https://www.youtube.com/watch?v=pqlWNihgdjI&t=130s) And third is that they minimize idle

[2:12](https://www.youtube.com/watch?v=pqlWNihgdjI&t=132s) time.

[2:13](https://www.youtube.com/watch?v=pqlWNihgdjI&t=133s) These frontier developers tend to run

[2:15](https://www.youtube.com/watch?v=pqlWNihgdjI&t=135s) multiple agents in parallel churning

[2:18](https://www.youtube.com/watch?v=pqlWNihgdjI&t=138s) through a backlog of tasks.

[2:22](https://www.youtube.com/watch?v=pqlWNihgdjI&t=142s) The first time that I saw a frontier

[2:24](https://www.youtube.com/watch?v=pqlWNihgdjI&t=144s) developer team was the Bedrock Mantle

[2:27](https://www.youtube.com/watch?v=pqlWNihgdjI&t=147s) team. Bedrock is our model hosting

[2:30](https://www.youtube.com/watch?v=pqlWNihgdjI&t=150s) service.

[2:31](https://www.youtube.com/watch?v=pqlWNihgdjI&t=151s) Hosts LLMs like Claude and GPT. And

[2:36](https://www.youtube.com/watch?v=pqlWNihgdjI&t=156s) sometime last year we knew or I say we

[2:40](https://www.youtube.com/watch?v=pqlWNihgdjI&t=160s) but the Bedrock team

[2:42](https://www.youtube.com/watch?v=pqlWNihgdjI&t=162s) knew that they were going to need to

[2:43](https://www.youtube.com/watch?v=pqlWNihgdjI&t=163s) build a new inference data plane. But

[2:46](https://www.youtube.com/watch?v=pqlWNihgdjI&t=166s) they had estimated it at 30 people over

[2:50](https://www.youtube.com/watch?v=pqlWNihgdjI&t=170s) 18 months. This is a big big service and

[2:53](https://www.youtube.com/watch?v=pqlWNihgdjI&t=173s) it was going to take time to build the

[2:55](https://www.youtube.com/watch?v=pqlWNihgdjI&t=175s) new one, migrate customers over, migrate

[2:58](https://www.youtube.com/watch?v=pqlWNihgdjI&t=178s) models over. They decided to take a step

[3:00](https://www.youtube.com/watch?v=pqlWNihgdjI&t=180s) back. They took six people and they

[3:03](https://www.youtube.com/watch?v=pqlWNihgdjI&t=183s) built [snorts] it in 76 days with Kiro.

[3:06](https://www.youtube.com/watch?v=pqlWNihgdjI&t=186s) So this was a huge achievement. This was

[3:08](https://www.youtube.com/watch?v=pqlWNihgdjI&t=188s) the first time we've we'd seen anything

[3:10](https://www.youtube.com/watch?v=pqlWNihgdjI&t=190s) of the kind inside of Amazon. So this

[3:13](https://www.youtube.com/watch?v=pqlWNihgdjI&t=193s) was truly the pathfinder team that

[3:15](https://www.youtube.com/watch?v=pqlWNihgdjI&t=195s) proved that it was possible to get up to

[3:18](https://www.youtube.com/watch?v=pqlWNihgdjI&t=198s) 20X improvement. Now they looked at

[3:21](https://www.youtube.com/watch?v=pqlWNihgdjI&t=201s) commits and I'll talk about a couple of

[3:23](https://www.youtube.com/watch?v=pqlWNihgdjI&t=203s) other ways that we are uh measuring

[3:25](https://www.youtube.com/watch?v=pqlWNihgdjI&t=205s) productivity improvements.

[3:27](https://www.youtube.com/watch?v=pqlWNihgdjI&t=207s) But there was one problem with this

[3:29](https://www.youtube.com/watch?v=pqlWNihgdjI&t=209s) story which was that yes, it was built

[3:32](https://www.youtube.com/watch?v=pqlWNihgdjI&t=212s) with six people. It was built with some

[3:35](https://www.youtube.com/watch?v=pqlWNihgdjI&t=215s) of the top engineers literally in the

[3:37](https://www.youtube.com/watch?v=pqlWNihgdjI&t=217s) company including two distinguished

[3:39](https://www.youtube.com/watch?v=pqlWNihgdjI&t=219s) engineers. So this was not just any team

[3:42](https://www.youtube.com/watch?v=pqlWNihgdjI&t=222s) of six people. These were experts in

[3:45](https://www.youtube.com/watch?v=pqlWNihgdjI&t=225s) distributed systems, experts at LLMs and

[3:48](https://www.youtube.com/watch?v=pqlWNihgdjI&t=228s) their architecture.

[3:51](https://www.youtube.com/watch?v=pqlWNihgdjI&t=231s) So this the story was amazing and it

[3:53](https://www.youtube.com/watch?v=pqlWNihgdjI&t=233s) kind of spread like wildfire across

[3:55](https://www.youtube.com/watch?v=pqlWNihgdjI&t=235s) Amazon, but it was also very

[3:57](https://www.youtube.com/watch?v=pqlWNihgdjI&t=237s) unachievable for a lot of teams. There

[3:59](https://www.youtube.com/watch?v=pqlWNihgdjI&t=239s) were a lot of questions about can this

[4:02](https://www.youtube.com/watch?v=pqlWNihgdjI&t=242s) actually be reproduced on another team?

[4:05](https://www.youtube.com/watch?v=pqlWNihgdjI&t=245s) So, another experiment that I want to

[4:07](https://www.youtube.com/watch?v=pqlWNihgdjI&t=247s) talk about is an experimental sprint

[4:10](https://www.youtube.com/watch?v=pqlWNihgdjI&t=250s) that was done in the Prime Video

[4:11](https://www.youtube.com/watch?v=pqlWNihgdjI&t=251s) organization.

[4:13](https://www.youtube.com/watch?v=pqlWNihgdjI&t=253s) They took a 10-day sprint and they did

[4:16](https://www.youtube.com/watch?v=pqlWNihgdjI&t=256s) an experiment where they put, again, six

[4:18](https://www.youtube.com/watch?v=pqlWNihgdjI&t=258s) engineers in a room and they let them go

[4:21](https://www.youtube.com/watch?v=pqlWNihgdjI&t=261s) wild with Kiro.

[4:23](https://www.youtube.com/watch?v=pqlWNihgdjI&t=263s) Uh they brought down the project

[4:26](https://www.youtube.com/watch?v=pqlWNihgdjI&t=266s) delivery time estimate from what was

[4:29](https://www.youtube.com/watch?v=pqlWNihgdjI&t=269s) going to be 90 weeks down to 24 based on

[4:32](https://www.youtube.com/watch?v=pqlWNihgdjI&t=272s) all of the progress they had made in

[4:34](https://www.youtube.com/watch?v=pqlWNihgdjI&t=274s) this 10-day sprint. And they they looked

[4:37](https://www.youtube.com/watch?v=pqlWNihgdjI&t=277s) at their commit history and they looked

[4:40](https://www.youtube.com/watch?v=pqlWNihgdjI&t=280s) at what did they used to do prior to

[4:42](https://www.youtube.com/watch?v=pqlWNihgdjI&t=282s) this 10-day sprint and how many commits

[4:44](https://www.youtube.com/watch?v=pqlWNihgdjI&t=284s) did they produce just in this 10 days.

[4:48](https://www.youtube.com/watch?v=pqlWNihgdjI&t=288s) And so, this sprint really proved that

[4:50](https://www.youtube.com/watch?v=pqlWNihgdjI&t=290s) we can achieve, again, at least

[4:53](https://www.youtube.com/watch?v=pqlWNihgdjI&t=293s) something close to what the Bedrock

[4:54](https://www.youtube.com/watch?v=pqlWNihgdjI&t=294s) Mantle team had uh had achieved with a

[4:58](https://www.youtube.com/watch?v=pqlWNihgdjI&t=298s) different set of engineers.

[5:00](https://www.youtube.com/watch?v=pqlWNihgdjI&t=300s) But again, there was a challenge with

[5:02](https://www.youtube.com/watch?v=pqlWNihgdjI&t=302s) this story, which was it was six

[5:05](https://www.youtube.com/watch?v=pqlWNihgdjI&t=305s) engineers in a room, but they had no

[5:07](https://www.youtube.com/watch?v=pqlWNihgdjI&t=307s) on-call duties, limited meetings, very

[5:10](https://www.youtube.com/watch?v=pqlWNihgdjI&t=310s) few distractions, which we all know are

[5:13](https://www.youtube.com/watch?v=pqlWNihgdjI&t=313s) regular in the lives of an engineer.

[5:16](https://www.youtube.com/watch?v=pqlWNihgdjI&t=316s) And the senior engineer on the team had

[5:19](https://www.youtube.com/watch?v=pqlWNihgdjI&t=319s) spent the previous 3 weeks creating very

[5:22](https://www.youtube.com/watch?v=pqlWNihgdjI&t=322s) detailed, small, well-scoped tasks with

[5:25](https://www.youtube.com/watch?v=pqlWNihgdjI&t=325s) detailed requirements for these

[5:28](https://www.youtube.com/watch?v=pqlWNihgdjI&t=328s) six [clears throat] engineers to just go

[5:29](https://www.youtube.com/watch?v=pqlWNihgdjI&t=329s) churn on for those 2 weeks.

[5:32](https://www.youtube.com/watch?v=pqlWNihgdjI&t=332s) So, this was again not necessarily real

[5:34](https://www.youtube.com/watch?v=pqlWNihgdjI&t=334s) life. This was a structured sprint, uh a

[5:37](https://www.youtube.com/watch?v=pqlWNihgdjI&t=337s) a point in time that they were able to

[5:39](https://www.youtube.com/watch?v=pqlWNihgdjI&t=339s) achieve this, but again, the question is

[5:42](https://www.youtube.com/watch?v=pqlWNihgdjI&t=342s) is this achievable on real teams on

[5:45](https://www.youtube.com/watch?v=pqlWNihgdjI&t=345s) day-to-day

[5:47](https://www.youtube.com/watch?v=pqlWNihgdjI&t=347s) work?

[5:48](https://www.youtube.com/watch?v=pqlWNihgdjI&t=348s) So, Amazon stores which encompasses

[5:51](https://www.youtube.com/watch?v=pqlWNihgdjI&t=351s) amazon.com, all of our retail websites,

[5:54](https://www.youtube.com/watch?v=pqlWNihgdjI&t=354s) as well as our physical stores,

[5:56](https://www.youtube.com/watch?v=pqlWNihgdjI&t=356s) did a more structured pilot. They

[5:59](https://www.youtube.com/watch?v=pqlWNihgdjI&t=359s) watched 50 teams that were totally

[6:01](https://www.youtube.com/watch?v=pqlWNihgdjI&t=361s) normal normal distribution of um early

[6:06](https://www.youtube.com/watch?v=pqlWNihgdjI&t=366s) career folks, mid-career, senior

[6:08](https://www.youtube.com/watch?v=pqlWNihgdjI&t=368s) engineers, and that worked on existing

[6:11](https://www.youtube.com/watch?v=pqlWNihgdjI&t=371s) systems. Nothing green field like the

[6:13](https://www.youtube.com/watch?v=pqlWNihgdjI&t=373s) mantle team got to build from the ground

[6:15](https://www.youtube.com/watch?v=pqlWNihgdjI&t=375s) up, but existing systems with existing

[6:17](https://www.youtube.com/watch?v=pqlWNihgdjI&t=377s) code bases.

[6:19](https://www.youtube.com/watch?v=pqlWNihgdjI&t=379s) And they they watched them for the

[6:21](https://www.youtube.com/watch?v=pqlWNihgdjI&t=381s) better part of last year, and they found

[6:24](https://www.youtube.com/watch?v=pqlWNihgdjI&t=384s) something super interesting.

[6:26](https://www.youtube.com/watch?v=pqlWNihgdjI&t=386s) They found that there was a big

[6:28](https://www.youtube.com/watch?v=pqlWNihgdjI&t=388s) difference in the productivity gains

[6:30](https://www.youtube.com/watch?v=pqlWNihgdjI&t=390s) that they saw between half of the teams

[6:32](https://www.youtube.com/watch?v=pqlWNihgdjI&t=392s) and the other half.

[6:34](https://www.youtube.com/watch?v=pqlWNihgdjI&t=394s) And in this case, they used a

[6:36](https://www.youtube.com/watch?v=pqlWNihgdjI&t=396s) productivity metric of deployment

[6:38](https://www.youtube.com/watch?v=pqlWNihgdjI&t=398s) velocity to production. So, not just

[6:40](https://www.youtube.com/watch?v=pqlWNihgdjI&t=400s) commits, how many commits are they

[6:43](https://www.youtube.com/watch?v=pqlWNihgdjI&t=403s) producing, but how quickly are we

[6:45](https://www.youtube.com/watch?v=pqlWNihgdjI&t=405s) getting changes out to customers? How

[6:47](https://www.youtube.com/watch?v=pqlWNihgdjI&t=407s) how quickly are we able to ship things?

[6:50](https://www.youtube.com/watch?v=pqlWNihgdjI&t=410s) And they saw that for half of the teams,

[6:52](https://www.youtube.com/watch?v=pqlWNihgdjI&t=412s) they achieved less than 3x increase.

[6:55](https://www.youtube.com/watch?v=pqlWNihgdjI&t=415s) And what they found that was the

[6:57](https://www.youtube.com/watch?v=pqlWNihgdjI&t=417s) difference between seeing less than 3x

[6:59](https://www.youtube.com/watch?v=pqlWNihgdjI&t=419s) productivity increase, these teams that

[7:01](https://www.youtube.com/watch?v=pqlWNihgdjI&t=421s) saw a median of 4.5x, and and in some

[7:04](https://www.youtube.com/watch?v=pqlWNihgdjI&t=424s) cases more than 10,

[7:06](https://www.youtube.com/watch?v=pqlWNihgdjI&t=426s) was how they used the tools. 90% of

[7:09](https://www.youtube.com/watch?v=pqlWNihgdjI&t=429s) these teams used Kiro, among other

[7:11](https://www.youtube.com/watch?v=pqlWNihgdjI&t=431s) internal tools that we have, and what

[7:14](https://www.youtube.com/watch?v=pqlWNihgdjI&t=434s) they found was it wasn't about the

[7:16](https://www.youtube.com/watch?v=pqlWNihgdjI&t=436s) tools, it was about the way that they

[7:18](https://www.youtube.com/watch?v=pqlWNihgdjI&t=438s) worked.

[7:19](https://www.youtube.com/watch?v=pqlWNihgdjI&t=439s) The teams that achieved step function

[7:21](https://www.youtube.com/watch?v=pqlWNihgdjI&t=441s) improvements

[7:23](https://www.youtube.com/watch?v=pqlWNihgdjI&t=443s) intentionally changed the way that they

[7:25](https://www.youtube.com/watch?v=pqlWNihgdjI&t=445s) worked, and the other simply kind of

[7:27](https://www.youtube.com/watch?v=pqlWNihgdjI&t=447s) sprinkled Kiro and some of the other

[7:29](https://www.youtube.com/watch?v=pqlWNihgdjI&t=449s) tools that we have on top of their

[7:31](https://www.youtube.com/watch?v=pqlWNihgdjI&t=451s) existing way of working. And for me at

[7:34](https://www.youtube.com/watch?v=pqlWNihgdjI&t=454s) least, this was the big aha moment. That

[7:37](https://www.youtube.com/watch?v=pqlWNihgdjI&t=457s) why I hadn't been feeling potentially

[7:40](https://www.youtube.com/watch?v=pqlWNihgdjI&t=460s) the massive gains that productive that

[7:43](https://www.youtube.com/watch?v=pqlWNihgdjI&t=463s) in in productivity that AI has promised.

[7:46](https://www.youtube.com/watch?v=pqlWNihgdjI&t=466s) It's about changing the way that we

[7:47](https://www.youtube.com/watch?v=pqlWNihgdjI&t=467s) work.

[7:49](https://www.youtube.com/watch?v=pqlWNihgdjI&t=469s) So, across this pilot, they went and

[7:51](https://www.youtube.com/watch?v=pqlWNihgdjI&t=471s) interviewed uh the teams that were

[7:53](https://www.youtube.com/watch?v=pqlWNihgdjI&t=473s) involved in the pilot as well as some of

[7:55](https://www.youtube.com/watch?v=pqlWNihgdjI&t=475s) these other teams on the Bedrock mantel

[7:56](https://www.youtube.com/watch?v=pqlWNihgdjI&t=476s) team, on uh Prime Video, and they found

[8:00](https://www.youtube.com/watch?v=pqlWNihgdjI&t=480s) five habits. And and I use the word

[8:03](https://www.youtube.com/watch?v=pqlWNihgdjI&t=483s) habits very specifically because again,

[8:05](https://www.youtube.com/watch?v=pqlWNihgdjI&t=485s) it's not about that one sprint. It's

[8:08](https://www.youtube.com/watch?v=pqlWNihgdjI&t=488s) about doing this day-to-day. And it And

[8:10](https://www.youtube.com/watch?v=pqlWNihgdjI&t=490s) what they found when they interviewed

[8:12](https://www.youtube.com/watch?v=pqlWNihgdjI&t=492s) with these teams was that it really was

[8:14](https://www.youtube.com/watch?v=pqlWNihgdjI&t=494s) habits that they had to build

[8:16](https://www.youtube.com/watch?v=pqlWNihgdjI&t=496s) day-to-day. When we change our way of

[8:18](https://www.youtube.com/watch?v=pqlWNihgdjI&t=498s) working, it's it's hard to build these

[8:21](https://www.youtube.com/watch?v=pqlWNihgdjI&t=501s) habits. It takes time to build these

[8:22](https://www.youtube.com/watch?v=pqlWNihgdjI&t=502s) habits.

[8:24](https://www.youtube.com/watch?v=pqlWNihgdjI&t=504s) So, let's go through each of these one

[8:25](https://www.youtube.com/watch?v=pqlWNihgdjI&t=505s) by one.

[8:26](https://www.youtube.com/watch?v=pqlWNihgdjI&t=506s) Habit number one is investing in agent

[8:28](https://www.youtube.com/watch?v=pqlWNihgdjI&t=508s) context. We have a lot of stuff in our

[8:32](https://www.youtube.com/watch?v=pqlWNihgdjI&t=512s) head. We tend to transfer all of that

[8:34](https://www.youtube.com/watch?v=pqlWNihgdjI&t=514s) stuff in our head to other people

[8:35](https://www.youtube.com/watch?v=pqlWNihgdjI&t=515s) through Slack conversations, through

[8:38](https://www.youtube.com/watch?v=pqlWNihgdjI&t=518s) onboarding, mentors, things like that,

[8:40](https://www.youtube.com/watch?v=pqlWNihgdjI&t=520s) through code reviews, through

[8:43](https://www.youtube.com/watch?v=pqlWNihgdjI&t=523s) stand-ups and sprint planning, and they

[8:45](https://www.youtube.com/watch?v=pqlWNihgdjI&t=525s) had to write all of that down. And the

[8:48](https://www.youtube.com/watch?v=pqlWNihgdjI&t=528s) habit that they built was every time the

[8:51](https://www.youtube.com/watch?v=pqlWNihgdjI&t=531s) agent makes a mistake or does something

[8:53](https://www.youtube.com/watch?v=pqlWNihgdjI&t=533s) not the way that you would have done it,

[8:55](https://www.youtube.com/watch?v=pqlWNihgdjI&t=535s) what am I missing in my skills files?

[8:57](https://www.youtube.com/watch?v=pqlWNihgdjI&t=537s) What am I missing in my steering files

[9:00](https://www.youtube.com/watch?v=pqlWNihgdjI&t=540s) that the agent needed?

[9:02](https://www.youtube.com/watch?v=pqlWNihgdjI&t=542s) But then, as we know, across last year,

[9:04](https://www.youtube.com/watch?v=pqlWNihgdjI&t=544s) we saw leaps and bounds in models'

[9:07](https://www.youtube.com/watch?v=pqlWNihgdjI&t=547s) abilities and their behaviors.

[9:09](https://www.youtube.com/watch?v=pqlWNihgdjI&t=549s) Uh the Sonnet 3.7 in the middle of last

[9:12](https://www.youtube.com/watch?v=pqlWNihgdjI&t=552s) year had a lot of quirks that we had to

[9:15](https://www.youtube.com/watch?v=pqlWNihgdjI&t=555s) put a lot of do nots in our uh in our

[9:17](https://www.youtube.com/watch?v=pqlWNihgdjI&t=557s) steering files, and now we don't have to

[9:19](https://www.youtube.com/watch?v=pqlWNihgdjI&t=559s) do that as much with Opus 4.5 as of last

[9:22](https://www.youtube.com/watch?v=pqlWNihgdjI&t=562s) November, and then we've had 6 months

[9:25](https://www.youtube.com/watch?v=pqlWNihgdjI&t=565s) more than 6 months of improvement since

[9:27](https://www.youtube.com/watch?v=pqlWNihgdjI&t=567s) then

[9:28](https://www.youtube.com/watch?v=pqlWNihgdjI&t=568s) uh with all of the new versions of

[9:29](https://www.youtube.com/watch?v=pqlWNihgdjI&t=569s) models that have come out since then.

[9:31](https://www.youtube.com/watch?v=pqlWNihgdjI&t=571s) And so, the question, the new habit,

[9:33](https://www.youtube.com/watch?v=pqlWNihgdjI&t=573s) again, is do I still need this in my

[9:36](https://www.youtube.com/watch?v=pqlWNihgdjI&t=576s) steering files or is this just bloating

[9:37](https://www.youtube.com/watch?v=pqlWNihgdjI&t=577s) context?

[9:39](https://www.youtube.com/watch?v=pqlWNihgdjI&t=579s) The second one is slowing down to speed

[9:41](https://www.youtube.com/watch?v=pqlWNihgdjI&t=581s) up. In almost every team that was

[9:44](https://www.youtube.com/watch?v=pqlWNihgdjI&t=584s) interviewed, they reported that their

[9:46](https://www.youtube.com/watch?v=pqlWNihgdjI&t=586s) productivity actually went down as they

[9:49](https://www.youtube.com/watch?v=pqlWNihgdjI&t=589s) intentionally adopted a new way of

[9:51](https://www.youtube.com/watch?v=pqlWNihgdjI&t=591s) working.

[9:52](https://www.youtube.com/watch?v=pqlWNihgdjI&t=592s) That's counterintuitive, right? You have

[9:55](https://www.youtube.com/watch?v=pqlWNihgdjI&t=595s) to do intentional engineering work

[9:57](https://www.youtube.com/watch?v=pqlWNihgdjI&t=597s) before you're going to see that hockey

[9:59](https://www.youtube.com/watch?v=pqlWNihgdjI&t=599s) stick curve in productivity improvement.

[10:02](https://www.youtube.com/watch?v=pqlWNihgdjI&t=602s) Because we have to do real work in our

[10:04](https://www.youtube.com/watch?v=pqlWNihgdjI&t=604s) code base first for agents to be

[10:06](https://www.youtube.com/watch?v=pqlWNihgdjI&t=606s) successful there, especially in

[10:08](https://www.youtube.com/watch?v=pqlWNihgdjI&t=608s) brownfield existing code bases. So they

[10:10](https://www.youtube.com/watch?v=pqlWNihgdjI&t=610s) had to build that agent context up. They

[10:13](https://www.youtube.com/watch?v=pqlWNihgdjI&t=613s) had to improve existing tools error

[10:15](https://www.youtube.com/watch?v=pqlWNihgdjI&t=615s) messages so that the model knew what was

[10:17](https://www.youtube.com/watch?v=pqlWNihgdjI&t=617s) going on when it failed. They built new

[10:20](https://www.youtube.com/watch?v=pqlWNihgdjI&t=620s) tools, new MCP servers for helping that

[10:23](https://www.youtube.com/watch?v=pqlWNihgdjI&t=623s) model to actually get done what it

[10:25](https://www.youtube.com/watch?v=pqlWNihgdjI&t=625s) needed to get done. A lot of teams ended

[10:27](https://www.youtube.com/watch?v=pqlWNihgdjI&t=627s) up restructuring their code base so that

[10:29](https://www.youtube.com/watch?v=pqlWNihgdjI&t=629s) agents could actually navigate it more

[10:31](https://www.youtube.com/watch?v=pqlWNihgdjI&t=631s) easily. And I've even seen drastic

[10:34](https://www.youtube.com/watch?v=pqlWNihgdjI&t=634s) changes like changing the programming

[10:36](https://www.youtube.com/watch?v=pqlWNihgdjI&t=636s) language of the code base.

[10:38](https://www.youtube.com/watch?v=pqlWNihgdjI&t=638s) Um often I've seen teams struggle with

[10:40](https://www.youtube.com/watch?v=pqlWNihgdjI&t=640s) Python, with JavaScript because they're

[10:43](https://www.youtube.com/watch?v=pqlWNihgdjI&t=643s) untyped languages. It's hard to test.

[10:46](https://www.youtube.com/watch?v=pqlWNihgdjI&t=646s) There's no compiler errors. So the model

[10:48](https://www.youtube.com/watch?v=pqlWNihgdjI&t=648s) kind of guesses and give it gives it

[10:50](https://www.youtube.com/watch?v=pqlWNihgdjI&t=650s) back to you. And so I've seen teams

[10:53](https://www.youtube.com/watch?v=pqlWNihgdjI&t=653s) moving to TypeScript. Um Rust has become

[10:56](https://www.youtube.com/watch?v=pqlWNihgdjI&t=656s) very popular inside of Amazon. The

[10:57](https://www.youtube.com/watch?v=pqlWNihgdjI&t=657s) compiler gives great error messages.

[11:00](https://www.youtube.com/watch?v=pqlWNihgdjI&t=660s) Um you don't have to do that, but I've

[11:02](https://www.youtube.com/watch?v=pqlWNihgdjI&t=662s) seen a lot of teams making those

[11:04](https://www.youtube.com/watch?v=pqlWNihgdjI&t=664s) intentional changes for the productivity

[11:06](https://www.youtube.com/watch?v=pqlWNihgdjI&t=666s) gains that they're able to see.

[11:09](https://www.youtube.com/watch?v=pqlWNihgdjI&t=669s) The third one is feeding agents, not

[11:12](https://www.youtube.com/watch?v=pqlWNihgdjI&t=672s) babysitting agents. And for me this was

[11:14](https://www.youtube.com/watch?v=pqlWNihgdjI&t=674s) one of those aha moments of why we're

[11:17](https://www.youtube.com/watch?v=pqlWNihgdjI&t=677s) seeing this step function improvement in

[11:19](https://www.youtube.com/watch?v=pqlWNihgdjI&t=679s) productivity.

[11:21](https://www.youtube.com/watch?v=pqlWNihgdjI&t=681s) If you are vibe coding, if you are

[11:23](https://www.youtube.com/watch?v=pqlWNihgdjI&t=683s) having a back-and-forth conversation

[11:25](https://www.youtube.com/watch?v=pqlWNihgdjI&t=685s) with your agent all day long, of course

[11:28](https://www.youtube.com/watch?v=pqlWNihgdjI&t=688s) you're not going to see four to five x

[11:31](https://www.youtube.com/watch?v=pqlWNihgdjI&t=691s) productivity improvements because you

[11:33](https://www.youtube.com/watch?v=pqlWNihgdjI&t=693s) are in the loop the entire time. You're

[11:35](https://www.youtube.com/watch?v=pqlWNihgdjI&t=695s) probably sitting there for 30 seconds to

[11:37](https://www.youtube.com/watch?v=pqlWNihgdjI&t=697s) a minute waiting for it to generate code

[11:40](https://www.youtube.com/watch?v=pqlWNihgdjI&t=700s) and come back to you with with the code

[11:42](https://www.youtube.com/watch?v=pqlWNihgdjI&t=702s) to review.

[11:44](https://www.youtube.com/watch?v=pqlWNihgdjI&t=704s) If you're sitting there waiting for it,

[11:46](https://www.youtube.com/watch?v=pqlWNihgdjI&t=706s) then you can't go off and do other

[11:48](https://www.youtube.com/watch?v=pqlWNihgdjI&t=708s) stuff. It's really difficult to run

[11:50](https://www.youtube.com/watch?v=pqlWNihgdjI&t=710s) agents in parallel. It's very difficult

[11:53](https://www.youtube.com/watch?v=pqlWNihgdjI&t=713s) to get to to clone yourself into

[11:55](https://www.youtube.com/watch?v=pqlWNihgdjI&t=715s) multiple agents. And so if your

[11:58](https://www.youtube.com/watch?v=pqlWNihgdjI&t=718s) conversations look a bit like this on

[12:00](https://www.youtube.com/watch?v=pqlWNihgdjI&t=720s) the left, then you're babysitting that

[12:02](https://www.youtube.com/watch?v=pqlWNihgdjI&t=722s) agent. As opposed to the right side

[12:05](https://www.youtube.com/watch?v=pqlWNihgdjI&t=725s) where you're feeding it what it needs to

[12:07](https://www.youtube.com/watch?v=pqlWNihgdjI&t=727s) do and how it can self-validate. And

[12:09](https://www.youtube.com/watch?v=pqlWNihgdjI&t=729s) that's really the key so that agents can

[12:11](https://www.youtube.com/watch?v=pqlWNihgdjI&t=731s) self-correct and only come back to you

[12:14](https://www.youtube.com/watch?v=pqlWNihgdjI&t=734s) when it meets a certain quality bar,

[12:16](https://www.youtube.com/watch?v=pqlWNihgdjI&t=736s) when it when it actually runs and

[12:18](https://www.youtube.com/watch?v=pqlWNihgdjI&t=738s) compiles and passes tests, when it's

[12:20](https://www.youtube.com/watch?v=pqlWNihgdjI&t=740s) testable, when it it actually has high

[12:23](https://www.youtube.com/watch?v=pqlWNihgdjI&t=743s) coverage. And of course the next level

[12:25](https://www.youtube.com/watch?v=pqlWNihgdjI&t=745s) is put all of this content into your

[12:27](https://www.youtube.com/watch?v=pqlWNihgdjI&t=747s) steering file so it does it every time

[12:29](https://www.youtube.com/watch?v=pqlWNihgdjI&t=749s) without you having to prompt it.

[12:33](https://www.youtube.com/watch?v=pqlWNihgdjI&t=753s) The fourth habit is to make intent

[12:36](https://www.youtube.com/watch?v=pqlWNihgdjI&t=756s) explicit. At Amazon we practice a lot of

[12:39](https://www.youtube.com/watch?v=pqlWNihgdjI&t=759s) behavior-driven development. We've built

[12:41](https://www.youtube.com/watch?v=pqlWNihgdjI&t=761s) that into the Q product and so it's very

[12:44](https://www.youtube.com/watch?v=pqlWNihgdjI&t=764s) natural for Amazon engineers to adopt it

[12:46](https://www.youtube.com/watch?v=pqlWNihgdjI&t=766s) in Q. Um what what I've typically seen

[12:50](https://www.youtube.com/watch?v=pqlWNihgdjI&t=770s) with live coding as opposed to frontier

[12:52](https://www.youtube.com/watch?v=pqlWNihgdjI&t=772s) engineering is giving a very high-level

[12:56](https://www.youtube.com/watch?v=pqlWNihgdjI&t=776s) prompt, letting the agent generate a ton

[12:59](https://www.youtube.com/watch?v=pqlWNihgdjI&t=779s) of code, and then having a

[13:01](https://www.youtube.com/watch?v=pqlWNihgdjI&t=781s) back-and-forth conversation saying, "Oh,

[13:04](https://www.youtube.com/watch?v=pqlWNihgdjI&t=784s) that's not really what I meant. That you

[13:07](https://www.youtube.com/watch?v=pqlWNihgdjI&t=787s) haven't you haven't exactly gotten the

[13:09](https://www.youtube.com/watch?v=pqlWNihgdjI&t=789s) the requirements right. No, I didn't

[13:11](https://www.youtube.com/watch?v=pqlWNihgdjI&t=791s) actually want to build it that way.

[13:12](https://www.youtube.com/watch?v=pqlWNihgdjI&t=792s) Here's a technical design." And it is

[13:15](https://www.youtube.com/watch?v=pqlWNihgdjI&t=795s) less I find less productive to iterate

[13:18](https://www.youtube.com/watch?v=pqlWNihgdjI&t=798s) with the agent on code when the intent

[13:21](https://www.youtube.com/watch?v=pqlWNihgdjI&t=801s) itself was incorrect. So often will have

[13:25](https://www.youtube.com/watch?v=pqlWNihgdjI&t=805s) will see Amazon engineers go through

[13:28](https://www.youtube.com/watch?v=pqlWNihgdjI&t=808s) this process for for ambiguous complex

[13:31](https://www.youtube.com/watch?v=pqlWNihgdjI&t=811s) features of writing the specification.

[13:34](https://www.youtube.com/watch?v=pqlWNihgdjI&t=814s) And in Kiro, of course, you don't have

[13:35](https://www.youtube.com/watch?v=pqlWNihgdjI&t=815s) to write this whole specification. You

[13:37](https://www.youtube.com/watch?v=pqlWNihgdjI&t=817s) can have the model generate it, but it's

[13:40](https://www.youtube.com/watch?v=pqlWNihgdjI&t=820s) a lot easier to to iterate with the

[13:43](https://www.youtube.com/watch?v=pqlWNihgdjI&t=823s) model in kind of a back and forth

[13:44](https://www.youtube.com/watch?v=pqlWNihgdjI&t=824s) conversation about a document than it is

[13:48](https://www.youtube.com/watch?v=pqlWNihgdjI&t=828s) about code that's code changes that are

[13:50](https://www.youtube.com/watch?v=pqlWNihgdjI&t=830s) spread across a code base.

[13:53](https://www.youtube.com/watch?v=pqlWNihgdjI&t=833s) The fifth one is shift testing left. One

[13:58](https://www.youtube.com/watch?v=pqlWNihgdjI&t=838s) of the keys here is to give the agent

[14:00](https://www.youtube.com/watch?v=pqlWNihgdjI&t=840s) that fast feedback loop.

[14:02](https://www.youtube.com/watch?v=pqlWNihgdjI&t=842s) Because that's what lets it go off for

[14:04](https://www.youtube.com/watch?v=pqlWNihgdjI&t=844s) hours at a time and self-correct. The

[14:06](https://www.youtube.com/watch?v=pqlWNihgdjI&t=846s) agent is going to make mistakes and

[14:08](https://www.youtube.com/watch?v=pqlWNihgdjI&t=848s) that's fine. But if you give it the

[14:11](https://www.youtube.com/watch?v=pqlWNihgdjI&t=851s) right signals, it can self-correct and

[14:13](https://www.youtube.com/watch?v=pqlWNihgdjI&t=853s) it can spend a while doing that.

[14:16](https://www.youtube.com/watch?v=pqlWNihgdjI&t=856s) So, I've seen teams adding linters,

[14:19](https://www.youtube.com/watch?v=pqlWNihgdjI&t=859s) adding unit tests, integration tests,

[14:21](https://www.youtube.com/watch?v=pqlWNihgdjI&t=861s) performance tests, security tests. These

[14:23](https://www.youtube.com/watch?v=pqlWNihgdjI&t=863s) are all things we all know we should

[14:24](https://www.youtube.com/watch?v=pqlWNihgdjI&t=864s) have been doing all along. This is good

[14:27](https://www.youtube.com/watch?v=pqlWNihgdjI&t=867s) engineering hygiene and practices. But

[14:29](https://www.youtube.com/watch?v=pqlWNihgdjI&t=869s) now the ROI is, I think, finally high

[14:33](https://www.youtube.com/watch?v=pqlWNihgdjI&t=873s) enough for actually us to actually

[14:34](https://www.youtube.com/watch?v=pqlWNihgdjI&t=874s) invest in it. Um one thing that I've

[14:37](https://www.youtube.com/watch?v=pqlWNihgdjI&t=877s) been seeing a lot of teams do is mock

[14:39](https://www.youtube.com/watch?v=pqlWNihgdjI&t=879s) out services. Often with integration

[14:42](https://www.youtube.com/watch?v=pqlWNihgdjI&t=882s) tests, we would test kind of end-to-end

[14:44](https://www.youtube.com/watch?v=pqlWNihgdjI&t=884s) an entire system including live

[14:46](https://www.youtube.com/watch?v=pqlWNihgdjI&t=886s) services. But we've been investing a lot

[14:49](https://www.youtube.com/watch?v=pqlWNihgdjI&t=889s) in in mock services that run entirely

[14:51](https://www.youtube.com/watch?v=pqlWNihgdjI&t=891s) locally with deterministic responses

[14:54](https://www.youtube.com/watch?v=pqlWNihgdjI&t=894s) because it lets the agent do everything

[14:57](https://www.youtube.com/watch?v=pqlWNihgdjI&t=897s) locally. Um doing everything on your

[15:00](https://www.youtube.com/watch?v=pqlWNihgdjI&t=900s) laptop without having to spin up a bunch

[15:02](https://www.youtube.com/watch?v=pqlWNihgdjI&t=902s) of other services and and connect to

[15:04](https://www.youtube.com/watch?v=pqlWNihgdjI&t=904s) cloud services makes everything a lot

[15:07](https://www.youtube.com/watch?v=pqlWNihgdjI&t=907s) faster because the the more that your

[15:10](https://www.youtube.com/watch?v=pqlWNihgdjI&t=910s) agent can get fast feedback means the

[15:13](https://www.youtube.com/watch?v=pqlWNihgdjI&t=913s) more loops that it can can do and the

[15:15](https://www.youtube.com/watch?v=pqlWNihgdjI&t=915s) more productive your own agent can be.

[15:19](https://www.youtube.com/watch?v=pqlWNihgdjI&t=919s) So, across all of these, these are some

[15:21](https://www.youtube.com/watch?v=pqlWNihgdjI&t=921s) of the habits we've seen, but of course

[15:23](https://www.youtube.com/watch?v=pqlWNihgdjI&t=923s) I would be remiss if I would tell you if

[15:26](https://www.youtube.com/watch?v=pqlWNihgdjI&t=926s) you adopt all of these habits, you will

[15:30](https://www.youtube.com/watch?v=pqlWNihgdjI&t=930s) achieve nirvana. You will be the most

[15:31](https://www.youtube.com/watch?v=pqlWNihgdjI&t=931s) productive engineering organization the

[15:34](https://www.youtube.com/watch?v=pqlWNihgdjI&t=934s) world has ever seen. Things are still

[15:36](https://www.youtube.com/watch?v=pqlWNihgdjI&t=936s) hard. We are still very much in an early

[15:38](https://www.youtube.com/watch?v=pqlWNihgdjI&t=938s) adopter phase and teams are still

[15:42](https://www.youtube.com/watch?v=pqlWNihgdjI&t=942s) figuring it out.

[15:43](https://www.youtube.com/watch?v=pqlWNihgdjI&t=943s) So, one thing that we've been seeing

[15:45](https://www.youtube.com/watch?v=pqlWNihgdjI&t=945s) across our teams just organizationally

[15:48](https://www.youtube.com/watch?v=pqlWNihgdjI&t=948s) is the risk of burnout. I did not coin

[15:51](https://www.youtube.com/watch?v=pqlWNihgdjI&t=951s) this term. I forget who did at what

[15:53](https://www.youtube.com/watch?v=pqlWNihgdjI&t=953s) conference, but flow mat is real. We've

[15:56](https://www.youtube.com/watch?v=pqlWNihgdjI&t=956s) been seeing engineers staying up late

[15:58](https://www.youtube.com/watch?v=pqlWNihgdjI&t=958s) late at night

[16:00](https://www.youtube.com/watch?v=pqlWNihgdjI&t=960s) trying to get that perfect prompt that's

[16:02](https://www.youtube.com/watch?v=pqlWNihgdjI&t=962s) going to make their agent run for hours

[16:04](https://www.youtube.com/watch?v=pqlWNihgdjI&t=964s) overnight so that they wake up in the

[16:05](https://www.youtube.com/watch?v=pqlWNihgdjI&t=965s) morning with a code change ready.

[16:08](https://www.youtube.com/watch?v=pqlWNihgdjI&t=968s) The cognitive load increases as you run

[16:11](https://www.youtube.com/watch?v=pqlWNihgdjI&t=971s) these multiple agents in parallel.

[16:13](https://www.youtube.com/watch?v=pqlWNihgdjI&t=973s) You're constantly shifting between

[16:15](https://www.youtube.com/watch?v=pqlWNihgdjI&t=975s) terminal tabs.

[16:17](https://www.youtube.com/watch?v=pqlWNihgdjI&t=977s) And then we do see that reviewing AI

[16:20](https://www.youtube.com/watch?v=pqlWNihgdjI&t=980s) output is often harder for some than

[16:22](https://www.youtube.com/watch?v=pqlWNihgdjI&t=982s) than actually writing it, especially

[16:24](https://www.youtube.com/watch?v=pqlWNihgdjI&t=984s) early in career.

[16:26](https://www.youtube.com/watch?v=pqlWNihgdjI&t=986s) Senior engineers have have already spent

[16:28](https://www.youtube.com/watch?v=pqlWNihgdjI&t=988s) a large portion of their career

[16:30](https://www.youtube.com/watch?v=pqlWNihgdjI&t=990s) reviewing others code.

[16:32](https://www.youtube.com/watch?v=pqlWNihgdjI&t=992s) But early career engineers don't have

[16:35](https://www.youtube.com/watch?v=pqlWNihgdjI&t=995s) that muscle yet and so reviewing it can

[16:38](https://www.youtube.com/watch?v=pqlWNihgdjI&t=998s) can feel like a lot more cognitive load

[16:41](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1001s) than they're used to and actually

[16:42](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1002s) writing it.

[16:44](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1004s) The other one is organizational change.

[16:47](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1007s) So, it's already hard to change the way

[16:50](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1010s) we work as engineers. The way that we

[16:51](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1011s) spend our entire day completely changes

[16:55](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1015s) when we're frontier engineers, but also

[16:57](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1017s) organizations have to change to enable

[17:00](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1020s) frontier engineering teams.

[17:02](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1022s) One that I've seen very commonly is

[17:06](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1026s) accepting slowing down to speed up.

[17:09](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1029s) And I've been guilty of this myself. My

[17:11](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1031s) my fellow leaders have been guilty of of

[17:13](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1033s) this of saying, "Well, you have the AI

[17:15](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1035s) tools now and the models are so amazing

[17:18](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1038s) now. Why are you not going faster?

[17:22](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1042s) Um and that's because you have to take

[17:25](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1045s) those two months to invest in your code

[17:27](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1047s) base, to figure out the best practices

[17:29](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1049s) for your team, to make hard habit

[17:33](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1053s) changes on your team.

[17:35](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1055s) Um and and if you're constantly

[17:37](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1057s) expecting

[17:38](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1058s) shipping features every month because

[17:40](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1060s) now we have these amazing models and

[17:42](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1062s) we're seeing um all of these these

[17:45](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1065s) companies on X saying how they're

[17:47](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1067s) shipping 20 PRs a day, um we have to

[17:51](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1071s) slow down to speed up.

[17:54](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1074s) The second one is actually going too

[17:55](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1075s) broad in the organization too fast. I

[17:58](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1078s) think that if we had um expected all

[18:02](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1082s) teams in massive organizations to be

[18:04](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1084s) frontier teams immediately, we would not

[18:07](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1087s) have had the learnings that we had from

[18:10](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1090s) the Pathfinder, from the from the sprint

[18:13](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1093s) experiment, from the pilot uh teams

[18:16](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1096s) within Amazon. And now the challenge for

[18:19](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1099s) us is how do we scale it out? And that's

[18:21](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1101s) what 2026 is about for Amazon is how do

[18:23](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1103s) we scale this out to more and more

[18:25](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1105s) teams, to the next uh 2,000 teams

[18:28](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1108s) instead of uh 50 teams.

[18:31](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1111s) Um and so I think that when you roll it

[18:33](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1113s) out too quickly, you have a lot of teams

[18:36](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1116s) who don't know what they're doing. You

[18:38](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1118s) haven't had time to find the best

[18:40](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1120s) practices for your own organizations,

[18:42](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1122s) the the context that your organization

[18:44](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1124s) needs.

[18:45](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1125s) And the last one is that you're going to

[18:47](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1127s) find new bottlenecks.

[18:49](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1129s) Previously, code writing code manually

[18:52](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1132s) was the bottleneck. Um I find that

[18:55](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1135s) within Amazon, we've found um the speed

[18:58](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1138s) of decision-making becomes a new

[19:00](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1140s) bottleneck. Um the more that you spend

[19:03](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1143s) reviewing the decision to actually build

[19:06](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1146s) a new product, the slower it is to build

[19:09](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1149s) the product now because the code only

[19:11](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1151s) takes 1 to two months to write.

[19:13](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1153s) >> [snorts]

[19:13](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1153s) >> Um all of the review processes

[19:16](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1156s) associated with the launch of a product

[19:19](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1159s) become the bottleneck. When it used to

[19:21](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1161s) take 9 to 12 months to build a new

[19:24](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1164s) product, it didn't matter so much in the

[19:27](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1167s) in the overall wash of things if it took

[19:29](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1169s) two months to make the decision to build

[19:31](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1171s) the product and then two months to

[19:32](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1172s) approve the launch. But now those are

[19:36](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1176s) the bottlenecks. Those are the long

[19:37](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1177s) pole. And so you find all of these all

[19:41](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1181s) of these things that slow you down.

[19:44](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1184s) Often I find that frontier engineering

[19:46](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1186s) teams spend more time making decisions

[19:49](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1189s) than they do writing code. And so the

[19:51](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1191s) more that you can make fast decisions,

[19:53](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1193s) especially ones that are easy to be

[19:55](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1195s) reversed, the better.

[19:57](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1197s) So my one big takeaway for for everyone

[20:00](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1200s) here is that

[20:02](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1202s) frontier engineering is about

[20:04](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1204s) intentionally changing the way that you

[20:06](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1206s) work. And that is difficult. That takes

[20:09](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1209s) time. It is forming new habits and a new

[20:12](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1212s) way of working.

[20:14](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1214s) And that goes across any engineering

[20:17](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1217s) team as well as your organization. Um so

[20:20](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1220s) I encourage you to think about

[20:23](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1223s) um how you're interacting with AI tools

[20:25](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1225s) and how that can change to free yourself

[20:29](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1229s) up from being in the loop.

[20:31](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1231s) Um thanks. I'm going to I'll hang out uh

[20:33](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1233s) a little bit if anyone has questions in

[20:35](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1235s) the back. Um but thanks for the time

[20:37](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1237s) today.

[20:54](https://www.youtube.com/watch?v=pqlWNihgdjI&t=1254s) >> [music]
