# Agents, codebases, and teams: what it actually takes to ship together

Aditya Khandelwal, Amazon AGI Lab

AI Engineer World's Fair 2026

[Talk page](https://ai.engineer/talks/aeTb5BdmTTc-amazon-agi) · [Video](https://www.youtube.com/watch?v=aeTb5BdmTTc)

## Getting a team to ship together with coding agents

Personal agent setups can fail in a shared production codebase. Reliable team delivery requires discoverable context, repair loops, and a shared workflow engineers trust enough to improve.

Familiarity with coding agents, pull requests, and continuous integration will help you follow the workflow examples.

### When personal productivity meets a shared codebase

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

How do you get a whole team to ship together with agents? A developer can assemble useful skills and tune a repository until their own workflow feels productive. The trouble starts when those individual setups meet teammates, shared code, and production requirements. [Aditya Khandelwal](https://adityak6798.github.io/) encountered this gap while leading a ten-person team over several months. The practices that follow grew out of that team's attempt to make agent-assisted development work collectively.

His account of enterprise adoption starts with a few developers getting exceptional leverage from coding agents. Organizations extrapolated from those successes, mandated adoption, and encouraged maximum token use. In the sequence he describes, poor generated code and SEV 2 incidents at unnamed companies followed, prompting some retreat. Rising model prices and visible token bills then brought budgets into the picture. That is the organizational backdrop to the more personal problem: what does this experience teach an engineer to expect from an agent?

![A seven-step timeline shows coding agents taking off, individual leverage, AI mandates, AI slop, Sev2s, rising model prices, and budgets, with an image of burning money.](https://ai.engineer/api/talk-essay-media/b02655d7663ccb7b3f4c4d4e4c58ec2fcaec11137cf0362ffff6cc81d71c171d)

The recap runs from coding agents taking off to budgets being bolted on.

### Usage can rise while confidence stands still

[2:15](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=135s)

Two dimensions help explain why adoption varies: fear of replacement and confidence in using the tool. Initially, an engineer may be worried about losing their job while barely using agents. Seeing an early adopter succeed can reduce that fear: there is still a valuable role for someone who learns how to direct the work. A mandate can then increase attempted usage without increasing confidence. When poor output arrives, replacement anxiety may fall further, but so does trust in the agent.

**The adoption goal is low fear and confident, capable use.** People begin at different points and need help moving from their current position. A usage mandate alone cannot tell you whether that movement is happening.

### Instructions and skills are only the beginning

[3:49](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=229s)

Creating a `CLAUDE.md` file and adding skills is a start, but the workflow itself reveals whether the setup works. The first warning is **constant babysitting**: engineers repeatedly intervening to keep an agent on track. Another is sudden apparent loss of intelligence. Khandelwal's diagnostic advice is to inspect the harness and repository setup, especially when small harness changes disrupt the workflow, rather than immediately concluding that the model has become worse.

Context growth is another warning. Khandelwal illustrates the problem with uncomplicated tasks consuming 500K, then 750K or a million context tokens and reaching automatic compaction. These are illustrative figures, not a specified model's context limit or a measured benchmark. The practical concern is the combination of growing cost, long sessions, and repeated human intervention.

Consistently poor output makes the failure visible in the code. Looking at other organizations shipping quickly can also provoke a useful question about what is missing locally. Khandelwal invokes model companies releasing on roughly a month-and-a-half to two-month cadence as motivation to investigate the system around the agents, not as a controlled comparison of engineering productivity.

### Leadership owns the shared workflow

[5:40](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=340s)

**Making engineers effective with agents is an organizational responsibility.** Leaving everyone to discover their own approach creates uneven output and shifts costs between teammates. In Khandelwal's illustrative comparison, one engineer produces ten PRs a day while another produces one or two. Those counts are not measured results; they expose what raw output can hide.

The lower-volume contributor can inherit the review burden from the higher-volume contributor. Reviewing poor generated code consumes time they could spend shipping or learning a better agent workflow, and gives them more reasons to distrust agents. Individual productivity has created a team bottleneck and reinforced the adoption gap. Fixing that can require changing how the repository is organized—work that needs team agreement and leadership support.

![Slide titled “Whose job is this, really?” contrasts “Figure it out yourself” with “It’s a problem facing the team,” describing review burden and the power to reshape the codebase.](https://ai.engineer/api/talk-essay-media/951e99856d52a1ba92731aa21842e463489de35e0d631c7ba598f51297ba16af)

Making engineers work well with agents is the company’s job.

### Make context discoverable and close the repair loop

[7:01](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=421s)

Repository-specific **harness engineering** begins with getting the right information to the agent at the right moment. Khandelwal calls this smart prompt injection: intentional delivery of useful repository context. The repository should give the agent a map it can follow after receiving a task, without a developer continually supplying the next piece of information. For example, when code search leads an agent to a file, comments in that file can point it toward the relevant documentation. The code becomes an entry point to the knowledge needed to change it safely.

Discovery needs a corresponding repair mechanism. Some poor code will get through, so the workflow needs a pipeline that detects it, removes it, and feeds what was learned back into the system. That pipeline is ongoing engineering work. A month of setup does not finish the job when models, harnesses, and the codebase continue changing.

The human side needs the same continuing attention. Fear and frustration are real inputs to adoption. Treating the agent as merely a tool that people will figure out after a mandate leaves those obstacles untouched.

### Earn trust with one complete workflow

[8:50](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=530s)

The team's practical playbook began with the basics, especially **progressive disclosure**: make information available when the agent needs it instead of loading everything at once. They looked for the practices that made their strongest individual contributors effective, then distributed those practices through a shared setup. That required people to accept that a familiar personal configuration might be imperfect. The aim was to make effective practices available across the organization, rather than leave them isolated in individual environments.

Next, they invested in one high-value skill, **ShipIt**, covering the stretch from completed code to a PR ready for review. It opened the PR, managed descriptions and comments, handled merge-related comments, and worked through CI failures in correction loops. Its endpoint was review readiness, not automatic production deployment.

![“What we did” slide shows two populated steps: “Do the basics, right” and highlighted “Build one high-value skill,” followed by three empty timeline markers.](https://ai.engineer/api/talk-essay-media/7904c901525886f4ce408454b3e1a38445495f40ac921d4f63e11c31fc5ac367)

Build one high-value skill: ship-it opens a PR, runs a review, and handles AI-review comments.

Khandelwal reports that ShipIt often ran for more than an hour, which initially worried users. Once engineers saw it complete useful work without constant supervision, the long run became evidence that they could hand off a meaningful part of the job. Trust came from a complete workflow delivering practical value.

### Connect the repository to feedback and its users

[10:32](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=632s)

To close the loop, the team connected issues and boards to the repository, added CI/CD and agentic reviews, and ran a nightly **code gardener** to inspect code organization. These mechanisms supplied feedback beyond the original coding session. The gardener's definition of correct organization depended on the codebase; it was checking local expectations, not a universal repository layout.

The next step was to get skeptics involved. Dismissing a skeptical engineer as fearful avoids the harder question of whether the system actually serves them. A stronger sign of adoption is that they begin editing and experimenting with the shared setup. That participation gives the team a way to turn dissatisfaction into a better workflow.

Continuous improvement also needs time. Engineers have to accept that the setup will never reach permanent perfection, and leadership has to reserve some contributor capacity for maintaining it. Khandelwal does not prescribe a fixed percentage. The investment may not immediately produce feature PRs, but it supports the work that does.

### Use operational failures to improve the shared system

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

The first version was far from smooth. Khandelwal reports that the repository accumulated roughly 400–500 issues within a couple of weeks. Multiple agents were creating issues without being wired together correctly. At the same time, disagreement about expected behavior made it easy for engineers to abandon the shared workflow and return to supervising their own agents. The response was to bring that feedback into the skill and improve it.

Other problems required different expectations or boundaries:

- **Long runs:** A trustworthy agent can work while the engineer does something else. Khandelwal draws an analogy with reasoning systems benefiting from more thinking time, but elapsed time alone does not establish that a repository workflow produces better code.
- **Merge conflicts:** More concurrent changes create integration friction. He acknowledges the problem without supplying a merge-management solution.
- **Experimental code:** Explicitly identify prototypes that are not intended to ship and exempt those experiments from the full rigor applied to production code. The exemption depends on keeping that non-shipping boundary clear.

People also move around the adoption spectrum from day to day. Ask what changed in their experience: a model, the harness, or something in the setup that needs revisiting. Replace general complaints about model intelligence with a question the team can act on: how can the shared environment make the agent more effective? The object of improvement is the team's setup, not just one person's configuration.

Khandelwal closes the main talk with learning to ski. For him, the difficult step was committing to movement instead of continually trying to brake; only then could he learn how turning felt. Its role here is a learning analogy: commit enough to discover how the workflow works, accept that some attempts will fail, and retain the ability to recover. **Recovery makes the willingness to fail useful.**

### Q&A: make progressive disclosure observable

[14:41](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=881s)

The audience question returns to implementation: which progressive-disclosure strategies worked best? The answer starts with the entry points an agent encounters:

1. **Keep the skill entry file small.** The team used an approximately 100-line limit for `SKILL.md`, treating the skill as a folder with supporting material rather than one large instruction file. That was a team convention, not a platform limit.
2. **Leave directions where code search lands.** If a file needs a runbook, its comments should point to that runbook. An agent that discovers the code through `grep` can then discover the operating context too.
3. **Use repository instructions as a thin index.** Keep `CLAUDE.md` or [`AGENTS.md`](https://agents.md/) focused on directing the agent to relevant files rather than embedding every detail in the initial context.

The distinction between a pointer and an import matters when applying this advice today. [Current Claude Code loading rules](https://code.claude.com/docs/en/memory) read `CLAUDE.md`, not `AGENTS.md` directly, and expand `@` imports eagerly; importing `AGENTS.md` through `CLAUDE.md` is a documented sharing mechanism. Splitting a large instruction file into eagerly imported files therefore does not defer the context cost. The thin-index principle depends on the agent following relevant pointers when needed, with loading behavior determined by its harness.

Finally, inspect what happens after the first prompt. Does the agent know where relevant information lives, or does it immediately launch into broad searching? How much context does it add before doing useful work? Khandelwal estimates that his setup already used roughly 20–25K startup tokens and treats growth to 40–50K as a warning to investigate. Those figures describe his diagnostic expectations, not universal thresholds. Watch navigation and context growth together, then adjust the disclosure boundaries and repeat.

## Resources

- [Skill authoring best practices](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices) — Practical patterns for concise skill instructions, supporting files, progressive disclosure, and evaluation.
- [How Claude remembers your project](https://code.claude.com/docs/en/memory) — Current guidance for shared CLAUDE.md instructions, imports, and rules that load only for relevant files.
- [How Claude Code works](https://code.claude.com/docs/en/how-claude-code-works) — Explains the agent loop, context usage, automatic compaction, and context inspection.
- [AGENTS.md](https://agents.md/) — An open Markdown convention for repository instructions used by coding agents.
- [Learning to reason with LLMs](https://openai.com/index/learning-to-reason-with-llms/) — OpenAI's original o1 report, including reasoning benchmarks and the effects of additional test-time computation.

## Slides

### Agents, codebases, and teams

Aditya Khandelwal shares what he learned leading a team of ten: agent setups that work for individual repositories can break down in a team’s production environment.

[0:23](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=23s) [Title slide for Aditya Khandelwal’s talk on shipping together with agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/73d60de2057b2e0c84e19840bfb2f1d6f7b53ab7057f0d3f1c4a8c75b35f4b9e.webp)

Amazon AGI Lab

Agents, codebases, and teams
What it actually takes to ship together

Aditya Khandelwal · AI Engineer World’s Fair 2026

© 2026 Amazon.com, Inc. or its affiliates

### Let’s recap: coding agents and individual leverage

A seven-step timeline starts with coding agents taking off and a few individual contributors gaining massive leverage. The remaining steps are unlabeled in this build.

[0:59](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=59s) [A seven-step timeline begins with coding agents taking off and a few individual contributors gaining leverage.](https://assets.ai.engineer/sites/aiecode2025/sha256/55597ae5481005745248a9899bf49e1d1841b563d2b7e8decb7e842d6ee6bb44.webp)

Let’s recap

01 Coding agents take off
02 A few ICs get massive leverage
03
04
05
06
07

3
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### Let’s recap: early reactions

As coding agents took off, a few individual contributors gained massive leverage. The speaker recalls people asking whether this was AGI, illustrated by a butterfly meme.

[1:11](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=71s) [The first two timeline points appear beneath an illustration of a person gesturing at a butterfly.](https://assets.ai.engineer/sites/aiecode2025/sha256/65d5733ae04a3d9c7e0e8a7ccfe566741426ab4f792d06c976abcdf1122a3ed2.webp)

Let’s recap

01 Coding agents take off
02 A few ICs get massive leverage
03
04
05
06
07

3
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### Let’s recap: company AI mandates

After a few individual contributors gain leverage from coding agents, companies mandate AI and push token-maxxing more broadly. A glowing brain illustrates the speaker’s “galaxy brain moment.”

[1:26](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=86s) [The timeline adds companies mandating AI and token-maxxing, with an image of a glowing brain.](https://assets.ai.engineer/sites/aiecode2025/sha256/d20864e79d8bf4f29061c2728647a586abf30b6906ed73cb64c5791a1390bc9c.webp)

Let’s recap

01 Coding agents take off
02 A few ICs get massive leverage
03 Companies mandate AI + token-maxxing
04
05
06
07

4
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### Let’s recap: AI slop and Sev2s

The speaker traces AI mandates and token-maxxing to AI slop and Sev2s. Homer retreating into a hedge illustrates people pulling back.

[1:36](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=96s) [The timeline adds AI slop shipping and Sev2s, above an image of Homer Simpson retreating into a hedge.](https://assets.ai.engineer/sites/aiecode2025/sha256/eb645f4af0b24e390231a7d937f5f11769f46ec7f1281dea84d5c1f82e821df2.webp)

Let’s recap

01 Coding agents take off
02 A few ICs get massive leverage
03 Companies mandate AI + token-maxxing
04 AI slop ships
05 Sev2s
06
07

6
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### Let’s recap: model prices and budgets

The recap traces an enterprise journey from coding-agent adoption and AI mandates through AI slop and Sev2s to rising model prices and budgets, illustrated by burning cash.

[1:56](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=116s) [The completed timeline adds rising model prices and budgets, alongside an image of burning money.](https://assets.ai.engineer/sites/aiecode2025/sha256/38b729624d6fdaaedb25d75260056f439227378db438b85dff4d98dbd3540f42.webp)

Let’s recap

01 Coding agents take off
02 A few ICs get massive leverage
03 Companies mandate AI + token-maxxing
04 AI slop ships
05 Sev2s
06 Model prices climb (someone pays for the tokens)
07 Budgets get bolted on

8
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### Now zoom into one developer

High confidence can coexist with fear: the chart calls that developer an anxious power-user. With low fear and high confidence, developers trust and parallelize agents.

[2:01](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=121s) [A four-quadrant chart maps developer fear against confidence in using agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/5287030a89eb5dbc3db4d05ca5b13fdebddc82b742f5d45d704e0508bdcdbc4f.webp)

Now zoom into one developer

Same curve — but lived one person at a time.

Two axes:
Confidence: how much they trust agents to run unsupervised, in parallel.
Fear: “is this coming for my job?”

↑ FEAR
“coming for my job”
“a handy tool”

Top left: Hesitant resister
Top right: Anxious power-user
Bottom left: Quietly opted out
Bottom right: Trusts & parallelizes

CONFIDENCE · utilization & parallelization →
low   high

9
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### Coding agents take off

Coding agents start in the high-fear, low-utilization corner: impressive demos draw a wary team, and people are unsure how to use them.

[2:38](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=158s) [Stage 1 places coding agents taking off at high fear and low utilization.](https://assets.ai.engineer/sites/aiecode2025/sha256/b5f481f6e3690e670c1dda5a6a4f39dcbdde17ee1efd79ee9a654da23fa577ec.webp)

“What is this? Is this the end? Am I needed?”

STAGE 1
Coding agents take off

Impressive demos.

Most of the team watches warily — “neat, but it’s not touching my codebase.”

high fear · low utilization

↑ FEAR
“coming for my job”
Coding agents take off
“a handy tool”
CONFIDENCE · utilization & parallelization →
Confidence endpoints: low, high

10
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### A few ICs get outsized leverage

Early adopters quietly ship 2–3×, making the gap visible. As others see them use coding agents, some become curious and try them too; the chart moves toward higher utilization and lower fear.

[2:49](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=169s) [Stage 2 shows early adopters gaining leverage at medium fear and medium utilization.](https://assets.ai.engineer/sites/aiecode2025/sha256/ff237c72b93dbf47557c3344ec321749225cc50ca58ca5391502707651dcd864.webp)

“Hmm, it needs me and I can use it”

STAGE 2
A few ICs get outsized leverage

Early adopters quietly ship 2–3×.

The gap becomes visible. Some are curious, others feel the ground shift under them.

medium fear · medium utilization

Chart:
↑ FEAR
“coming for my job”
“a handy tool”
A few ICs get outsized leverage
CONFIDENCE · utilization & parallelization →
low   high

11
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### Mandates and token-maxxing

As leadership mandates AI and dashboards reward tokens burned, usage spikes while trust lags and fear remains high.

[3:03](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=183s) [Stage 3 shows mandated AI use and high utilization while fear remains high.](https://assets.ai.engineer/sites/aiecode2025/sha256/08f0eefc43d5cc97099cd5ec3718a4c07e9796620f670b5c294f82e25bbb0083.webp)

“Tokens go brr...”

STAGE 3
Mandates + token-maxxing

Leadership mandates AI.

Dashboards reward tokens burned, not judgment applied.

Usage spikes; trust hasn’t caught up.

still-high fear · high utilization

Chart:
↑ FEAR
“coming for my job”
“a handy tool”
Mandates + token-maxxing
CONFIDENCE · utilization & parallelization →
low    high

12
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### Then the Sev2s

Slop merges, incidents follow, and prices climb. Confidence craters as people retreat to low, careful utilization; the chart places the Sev2s at low fear and low utilization.

[3:13](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=193s) [Stage 4 plots incidents and a return to low fear and low utilization.](https://assets.ai.engineer/sites/aiecode2025/sha256/f49b304b8878e005e4ad8e62015f03ad51067515c36f939e46546d31f7fafd7b.webp)

“Eh, nvm. Costs too much and makes my life tougher.”

STAGE 4
Then the Sev2s

Slop merges. Incidents follow. Prices climb.

Confidence craters and people retreat to old habits — back to low, careful utilization.

low fear · low utilization

Chart:
↑ FEAR
“coming for my job”
“a handy tool”
The Sev2s
CONFIDENCE · utilization & parallelization →
Low to high

13
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### Low fear, high utilization

The chart asks how teams can move from the Sev2s’ low-confidence crater to low fear and high utilization. The speaker frames this as the challenge of helping teams adopt good AI usage patterns.

[3:30](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=210s) [The chart traces the earlier stages and asks how to move from the crater to low fear and high utilization.](https://assets.ai.engineer/sites/aiecode2025/sha256/84cef2ab986aa4114d0c47a343567d796ccc83c2ff51e13d08836805ead6dc88.webp)

“This is awesome, I can ship 10x more!”

How do we get from the crater to low fear, high utilization?

That’s the rest of this talk.

↑ FEAR
“coming for my job”
“a handy tool”

Coding agents take off
A few ICs get outsized leverage
Mandates + token-maxxing
The Sev2s
?
Low fear, high utilization

CONFIDENCE · utilization & parallelization →
low    high

14
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### What does it take?

Creating a CLAUDE.md and adding skills does not finish the job; the speaker says real-world AI adoption is messier.

[3:47](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=227s) [A three-step sequence moves from CLAUDE.md to skills to “Done?” The slide answers no: real life is messier.](https://assets.ai.engineer/sites/aiecode2025/sha256/0ea4c64f0c3a4cd63ecdd23de12d057e6f00c6344fa2b0855b14ebb63ff4e389.webp)

“So, what does it take?”

STEP 1
CLAUDE.md
→
STEP 2
Skills
→
STEP 3
Done?

No.
Real life is far messier.

15
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### Why doesn’t this work?

The speaker identifies babysitting your agent as a sign that the setup isn’t working.

[4:07](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=247s) [The first sign of an inadequate setup is babysitting your agent.](https://assets.ai.engineer/sites/aiecode2025/sha256/c13e962236a7ca0e1bdef75c1261fc24bde2268b6ce0d06b79cf087bcb88bd3f.webp)

“Why doesn’t this work? It’s what most teams and people do...”

1 Babysitting your agent

16
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### Why doesn’t this work?

The speaker lists signs of a struggling agent setup: constant supervision, wasted context and money, poor output, and slow shipping. Even a simple task can consume hundreds of thousands of context tokens.

[5:13](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=313s) [Six signs of an inadequate agent setup, from babysitting and wasted context to poor output and slow shipping.](https://assets.ai.engineer/sites/aiecode2025/sha256/44d9945ae38cac630fd22714b6b6d491e88e246ef1637d36dc306c0252020ccd.webp)

“Why doesn’t this work? It’s what most teams and people do...”

1 Babysitting your agent
2 Is “<Insert Model>” being extra dumb today?
3 Silently burning context (and money)
4 Long sessions needing constant intervention
5 Constant slop factory
6 “How are others shipping so fast?”

16
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### How do we solve it correctly?

The speaker turns to how teams can solve their agent workflow problems.

[5:33](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=333s) [Orange text on a dark background asks how to solve the problem correctly.](https://assets.ai.engineer/sites/aiecode2025/sha256/e6101174c931957d7df46fe9d4f9573e0771c7b602f12dc805e72cf24888227d.webp)

Ok, so how do we solve it correctly?

17
© 2026 Amazon.com, Inc. or its affiliates

### Whose job is this, really?

When engineers figure out agents alone, uneven productivity gains can leave colleagues with review work. The speaker argues that leadership and team buy-in enable codebase changes that help engineers trust their agents.

[5:38](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=338s) [The slide says making engineers work well with their agents is the company’s job.](https://assets.ai.engineer/sites/aiecode2025/sha256/3cd9a684a4c0c176686ed424032ee437a3112236ae4ac529369c4de2007d87c4.webp)

1. Whose job is this, really?

Making engineers work well with their agents is the company’s job — not each IC fending for themselves.

18
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

[6:37](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=397s) [The slide contrasts leaving individual engineers to figure out agents with treating agent adoption as a team problem.](https://assets.ai.engineer/sites/aiecode2025/sha256/015cb72ac24f3de82e1c64181ff6836126b10d476b8f146929d7f5ac00041d6e.webp)

1. Whose job is this, really?

Making engineers work well with their agents is the company’s job — not each IC fending for themselves.

“Figure it out yourself”
Individual ICs gain outsized productivity, others get stuck with review load or shipping worse code.

“It’s a problem facing the team”
Engineers get the power to reshape the codebase and the confidence to trust the agent.

18
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### Harness engineering per codebase

Per-codebase harnesses give models the right context, close the loop to detect and remove slop, and keep evolving as conditions change.

[8:17](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=497s) [Three cards describe smart prompt injection, closing the loop, and continuous iteration.](https://assets.ai.engineer/sites/aiecode2025/sha256/f6ba76d2034ef2e321d2092f13c41a220ea8f776a27a317c6aeb9858a402f013.webp)

2. This needs harness engineering. Per Codebase.

Smart Prompt Injection
Design the system so the model gets the right context at the right moment.

Close the loop
Design for a self-healing system. Constant de-slopification.

Continuous Iteration
No one setup is perfect. Even your own setup last month isn’t good enough for today.

19
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### Treat it like a human problem

The speaker urges recognizing developers’ fear rather than mandating adoption. The chart sketches a question-marked path from “The Sev2s” toward high confidence and low fear.

[8:31](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=511s) [A chart plots fear against confidence in agent utilization, alongside a reminder that human emotions are real and adoption cannot simply be mandated.](https://assets.ai.engineer/sites/aiecode2025/sha256/3b2f670c6eb2f77a510bb3858a83558dd2066e29d60723bd60227093cc0d2cdc.webp)

3. Treat it like a human problem.

Most devs are somewhere on this graph.
Fear is real. Human emotions are real.
You can’t mandate your way through this.

↑ FEAR
“coming for my job”
“a handy tool”

Coding agents take off
A few ICs get outsized leverage
Mandates + token-maxxing
The Sev2s
?

CONFIDENCE · utilization & parallelization →
low    high

20
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### What’s the playbook?

The speaker moves from principles to the team’s playbook, offering a rough account that others can adapt.

[8:49](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=529s) [Dark slide asking, “Ok, enough ‘gyan’. What’s the playbook?”](https://assets.ai.engineer/sites/aiecode2025/sha256/65e1bdcacef9c23118787c54dd34be2921cbfad8c6b09fb4ff681879368fe91b.webp)

Ok, enough “gyan”.
What’s the playbook?

21
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### What we did

Amazon’s playbook pairs a ship-it skill that opens and reviews PRs with CI/CD and agentic reviews. People invest by editing the shared setup, which the team keeps iterating.

[10:52](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=652s) [Five-step playbook: do the basics right, build a high-value skill, close the loop, get people invested, and iterate constantly.](https://assets.ai.engineer/sites/aiecode2025/sha256/d8d9ac794f445f6f9f17b69d01be350a1e79b06ce89105683e1b82b9cd96228f.webp)

What we did

1. Do the basics, right
Setup your codebase for progressive disclosure.
Copy best practices - then watch how your top engineers actually work and get the best from their setups.

2. Build one high-value skill
Ours is ship-it: opens a PR, runs an opinionated review, handles the AI-review comments. Make it easy, then earn adoption.

3. Close the loop
Wire issues + boards into the repo. CI/CD + agentic reviews keep it self-healing. De-slopify relentlessly.

4. Get people invested. Win over the skeptics.
Contribution = investment. When people start to edit and play with the shared setup, you know it’s working.

5. Iterate. Constantly.
Encourage iteration. Hardest for engineers, since it means no setup is ever perfect. Do it nonetheless.

22
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### Was it perfect? No.

Each step has its own iteration loop. The speaker treats problems as feedback and calls for spending engineering time improving the setup, even without immediate PRs.

[11:41](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=701s) [Dark slide saying every step had its own iteration loop and that the loop should be treated as a first-class entity.](https://assets.ai.engineer/sites/aiecode2025/sha256/c84db55af91c379f22513b5eca44886863b21c2acde1dd03504386d7e59f7a28.webp)

Was it perfect? No.

Every step had its own iteration loop. Treat that as a first-class entity.

23
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### Problems we hit (it wasn’t clean)

Issue volume made auto-triage and PR-generation bots necessary. Parallel agents created merge work; experiments needed different quality gates, and teams needed conversations to build agreement.

[11:51](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=711s) [Problems slide identifying too many issues and the need for automated triage and pull-request generation.](https://assets.ai.engineer/sites/aiecode2025/sha256/61dd83e64f2789f5571aacf9666a4ca043a28f78ced213eebfc90b4854079cdc.webp)

Problems we hit (it wasn’t clean)

1 Too many issues
So many that auto-triage + PR-gen bots stopped being optional.

24
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

[13:13](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=793s) [Six challenges: issue volume, agreement, agent wait times, merge conflicts, experimental code quality, and varied attitudes toward agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/5bcf8ae8b1098e0040d11c6b51a5c51cd7b13ca9a371b01889a64c5b68fa62fe.webp)

Problems we hit (it wasn’t clean)

1 Too many issues
So many that auto-triage + PR-gen bots stopped being optional.

2 Lack of agreement
Fear sends people back to old habits. It’s a human problem — meet it with empathy and the why.

3 “Agents take too long”
Expectation-setting and regular conversations, not silence.

4 Merge hell
Ten parallel agents means ten parallel diffs. Plan for it.

5 Slop during experiments
Speed vs. quality. Let “experimental” code opt out of strict gates — enforced by CI, not vibes.

6 People vary on the spectrum
From “taking my job” to “I’m an L9.” Pick a superpower-dev owner; win the most skeptical person first.

24
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### Make the model smarter

Khandelwal reframes model frustration as a question of how to improve it. The crossed-out “my” points to investing in the shared setup.

[13:31](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=811s) [A prompt to ask how to make the model smarter and improve the shared setup.](https://assets.ai.engineer/sites/aiecode2025/sha256/9ff2ceddf4444b86dd52aacd2c62458e8ff3853aea88a9874c39489acf8e1aa3.webp)

Instead of saying

“The Model is so dumb”,

ask

“How can I make it smarter?
How can I edit my [struck through] our setup”

It’s a mindset. Go full send.

25
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

### About Me

Khandelwal connects building trust in coding agents through changes to the codebase and workflow with learning to ski: commit to speed, accept falls, and recover.

[13:53](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=833s) [Aditya Khandelwal describes building trust in coding agents alongside a skiing meme about committing to speed and accepting falls.](https://assets.ai.engineer/sites/aiecode2025/sha256/d51e49c3e2943834842a1f6baa63d78757621a0344ef6c1bc4e47cd31a5126ad.webp)

About Me

I helped a fast-moving engineering team actually trust coding agents — not by mandate, but by reshaping the codebase and the workflow around them.

This talk was the report.

You can’t ski well until you trust the speed.
Pizza-braking only gets you so far.
Be okay with falling.
Steer into the skid.

Aditya Khandelwal
Member of Technical Staff, Amazon AGI Lab

26
© 2026 Amazon.com, Inc. or its affiliates
Amazon AGI Lab

## Full transcript

[0:00](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=0s) [upbeat music] Today, I'm gonna be talking about agents, codebases, and teams.

[0:16](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=16s) Essentially, how do you get your team to actually ship together with agents? And, like, I think for the longest time, like, the one thing that's bugged me is, like, there's so much content about, you know, how do you set up your own codebase to, like, work well with agents?

[0:29](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=29s) You know, like, what skills do you add? You know, this skill's better, that setup's better. But it all seems to break the moment you, like, actually try to use it with your team in your actual production setup.

[0:39](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=39s) And, like, for individual repos, it kind of makes sense. But the moment you actually try to use it with your own, like, team setup, it tends to break. And, like, I think over the past few months, I've figured out how to make it work, um, with a team of, uh, folks.

[0:53](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=53s) So like, I was leading a team of, like, ten people over the last few months, and I think we found, like, a good solution, and I want to share that with you guys.

[1:00](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=60s) But before we get into that, I just want to recap, like, you know, what's been the journey that we've been on, right? So we started, you know, code-coding agents took off, and a few people got really, really good leverage, right?

[1:12](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=72s) And I think all of us were kind of asking, like, "Is this AGI?" You know? Like, did we achieve it? Then, you know, companies took that and said, "Well, if one person can do so well, let's just get everyone and let's mandate it and, like, token max," right?

[1:27](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=87s) And that was clearly a, a ga- a galaxy brain moment, right? And then the inevitable happened, you know, AI slop shipped, and there was a bunch of SEV 2s.

[1:36](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=96s) I'm not [chuckles] gonna name which companies. But, you know, essentially you saw people kind of retracting. They said, "I don't think, [chuckles] I don't think this is the best option here."

[1:45](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=105s) And eventually, model prices cl-- you know, climbed. We saw, you know, people figured out that tokens have to be paid for. Like, you just can't token max your way through life.

[1:55](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=115s) And budgets got bolted on, and, you know, essentially money is being lit on fire, and the money has to come from somewhere. So given this journey, I wanna actually, like...

[2:04](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=124s) This is the enterprise journey, right? And what does that do for a single developer? And I think this is an important framing 'cause it really talks about people as a part of a team, right?

[2:15](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=135s) And I wanna look at it for, like, two axes. So there is the fear axis, where people li-lie on the spectrum, right? They're coming-- It's like, is it coming from my job?

[2:24](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=144s) Like, am I gonna be out of a job? Or it's, like, a really handy tool, and they're really-- you know, they're not that fearful. Versus, like, the confidence they have in how much they're executing it.

[2:32](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=152s) So they can either use it a lot or they can use it, you know, not that much because they don't really know how to use it that well. Now, when we started, like, people said, "Oh, you know, what is this?

[2:43](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=163s) Is this the end?" Like, "Am I needed?" And fear was pretty high, utilization was pretty low 'cause people didn't really know how to use it. And then when a few people got outsized leverage, you saw, you know, early adopters.

[2:55](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=175s) Basically, people saw them, and people said, "Okay, well, it looks like I'm still kind of needed if I figure out how to use this thing, so let me actually try using it," right?

[3:04](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=184s) And then we saw, you know, mandates and token maxing, and people kind of got a little skeptical. Like, confidence stayed the same, but people tried to use it a lot more, right?

[3:14](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=194s) And then we realized, ah, you know, there's a bunch of slop shipping, there are SEV 2s, and

[3:19](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=199s) I-- you know, it's like, I'm not really that scared 'cause, you know, it just slip-- it just ships slop. Like, I'm gonna still be needed. And they don't even know how to use it that well 'cause, like, now the confidence is cratered, right?

[3:29](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=209s) And so you gotta figure out how to get people from all the way, wherever they are on the spectrum, to where they're not fearful, and they're actually using it a whole lot more.

[3:39](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=219s) And this is the framing that I wanna, like, I want everyone to keep in mind as they're actually trying to get a team to adopt good, like, AI usage and good AI patterns, right?

[3:49](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=229s) And so the question is, you know, what does it take? Step one, create a CLAUDE.md. Step two, add some skills. Is that it? Did we, like, solve it?

[4:00](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=240s) You know, [chuckles] I think we all know. Like, you guys are here because, like, clearly, life's not that simple, and, like, stuff's messy, right? And I think a few people might ask, you know, why doesn't this work?

[4:11](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=251s) Like, isn't that what, like, everyone does? And I wanna, like, just talk about a few things you might see that actually indicate that, yeah, like, this isn't working.

[4:22](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=262s) So the first thing is, if you're babysitting your agents, it's not the right setup, right? And you gotta realize that. If you're seeing people in your team babysitting their agents, something's wrong.

[4:34](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=274s) Is-- You know, one of the things that I heard a lot was, is, you know, insert whatever latest model there is being really dumb today. The model didn't change, right?

[4:42](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=282s) The harness may have changed underneath. But if it's really, like, that's, that's susceptible to, like, small changes in the harness, clearly your own codebase isn't set up well.

[4:54](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=294s) It's silently burning context and money. Like, you don't realize it. You know, you go-- You blow through, like, 500K context. You might go to, like, 750K, a million and hit auto compact even though you're not doing, like, a really complicated task.

[5:06](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=306s) Clearly, something's wrong. You know, if you have long-ass sessions needing constant intervention, there's still something that's wrong.

[5:15](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=315s) If you're getting a constant slop factory, [chuckles] you obviously know, like, things are, things are not good. And if you're asking-- If you find yourself asking, you know, how are these other companies shipping so fast?

[5:25](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=325s) Like, how are model companies releasing models at, like, a month-and-a-half, two-month cadence? Clearly they, they have something which we don't, right?

[5:34](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=334s) And so I guess everyone's kind of thinking, "So, you know, how do we solve this correctly?"

[5:40](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=340s) And so I think the first thing to realize is we need to frame it correctly, right? It isn't really an IC's job. It's a job for leadership. It's a job for the company, right?

[5:51](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=351s) Making engineers work well with their agents is truly at-- the most impactful thing you could do as an organization because that's gonna enable, you know, your engineers to ship faster and with confidence and avoid, you know, a lot of incidents.

[6:06](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=366s) If we live in this f- figure-it-out-for-yourself paradigm, like, people are gonna get outsized productivity, some people aren't, and, like, the people who are generating, like, 10 PRs a day are gonna, like, look like, you know, gods compared to people who are shipping, like, one to two.

[6:20](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=380s) And the one-to-two PR people are actually gonna get left with the review burden, and that's actually a really, really bad thing. 'Cause now not only can they not ship, they're gonna actually see bad code and then curse the agents and hence not be able to get onto the, "Let's ship 10 PRs," right?

[6:36](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=396s) And so it's really important to do this. If it's a problem facing the team, there's a few things you can do, right? The most impactful things that you can do to set up your code base to, like, make it work well require team buy-in.

[6:49](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=409s) You can't just, like... If you wanna change the way your code base is organized, you can't do that as an IC, right? And if you treat it as a leadership problem, then you can do things like this.

[7:01](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=421s) So the other thing this needs is harness engineering, right? Per code base. And I think there's a lot of content on this, so I just wanna talk about a few principles.

[7:10](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=430s) But I don't wanna, like, make this talk about that because there's a lot of smart people. You're at AI Engineer. Like, this, this conference is all about people telling you how to u- best set up, you know, your code base to make things function well.

[7:21](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=441s) So I don't wanna talk too much about this, but there's a few key principles here. Smart prompt injection is one of them. You wanna treat your entire code base as one way to that so that you're able to, like, smartly prompt inject the model with just the right context at just the right time without you needing to

[7:37](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=457s) do it, and that's the framing. You wanna be able to say, "Okay, I've set it off on this task." It has, like, a map of how to find the things it needs at the time it needs it.

[7:48](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=468s) If it's looking at some code and that code has, let's say, some documentation, it-- the documentation needs to live in the comments so if it ever grepped into that code, it reads the comment, goes to that file, finds all the information about it.

[8:01](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=481s) That's just one example. The second is close the loop, right? You've gotta make a self-healing system 'cause slop is inevitable. There is going to be some slop that's going to seep in, but you need to have a pipeline and a way to close the loop to remove the slop, to detect it, and to be able to, like,

[8:17](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=497s) self-heal the system. And then you need to iterate continuously, and I can't emphasize this enough. Like, you can't assume that you do this for a month and you're done.

[8:26](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=506s) Like, things are gonna change constantly underneath, so you need to keep this as one of the things that you have to do as an organization. And the third most important thing is treat it like a human problem, guys.

[8:36](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=516s) Like, this isn't-- it's not, you know, oh, it's this tool. Like, people will figure it out. Let's just mandate our way through life. Like, that's just not gonna work.

[8:44](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=524s) So treat it like a human problem. Fear is real. Human emotions are real. We should recognize it.

[8:50](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=530s) So, you know, enough gyaan or as, like-- It's more like the Hindi way to say, like, you know, " Enough prof--" Like, I'm kinda giving you sermons, but, like, how do you really do this, right?

[9:00](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=540s) Like, these are our principles. What's the real playbook? So here's what we did, and here's, like-- I'm not gonna over, like, emphasize on this is the exact way to do it, but this is, like, roughly how we did it, and you can take from it what you choose.

[9:14](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=554s) The first thing is do the basics, right? You gotta do them right. Progressive disclosure, I can't emphasize this enough, is really, really powerful, right? Find your best ICs and find what-- how they're making the code base work for them.

[9:27](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=567s) Take those practices and pass them org-wide. People can't live in their own practices, and this is really hard for engineers to do. It's basically accepting that my setup is imperfect and, like, engineers don't like to hear that.

[9:39](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=579s) But you gotta figure out a way to find those best practices and ship them across, make sure that that's kind of a shared setup.

[9:47](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=587s) The second thing we did was there's one high-value skill that we invested in. In our case, it was this thing called ShipIt. What it did was the moment you're done with your code, it takes care of everything from code done to PR ready for review, which means you gotta open a PR, figure out your opinions, handle the--

[10:05](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=605s) handle all the comments, you know, handle all the PR descriptions, the merge comments, everything, right? It handles CI failures. It basically runs through these loops. And what this meant was often the skill was running for over an hour, and that scared people.

[10:19](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=619s) But once you actually figure out, once they saw the value, they get invested, right? Because it's one skill which tells them, "Okay, this AI thing can actually work for me.

[10:28](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=628s) I don't need to constantly babysit it. I can trust it."

[10:32](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=632s) The third thing, and really important, is to close the loop, right? So we wired issues and boards into the repo. Like, we added CI/CD. We added agentic reviews. We have, like, a code gardener that actually goes back and looks through a whole bunch of, like-- Every night it'll run and look at the code and check if something,

[10:46](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=646s) like, not organized correctly. What does correct organization mean will depend on your code base.

[10:53](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=653s) Get people invested, and I can't emphasize this enough. You have to win over the skeptics. It's really easy to say, like, the skeptic is just someone who's scared. It's really hard to get them to buy in, but if you can get them to buy in, you know you're doing something right.

[11:07](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=667s) You have to get them to be able to edit and play with the shared setup 'cause that's the true way you know that they're actually invested, right? And this is where you gotta it- ensure you're iterating constantly.

[11:19](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=679s) If people are-- Like, and this is the hardest thing for engineers, again, 'cause you're basically saying, "I'm never gonna, like, get to perfection in my setup." But you've gotta be okay with that.

[11:29](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=689s) You have to do it, and you have to treat it like, you know, X percent of your IC time is probably gonna be spent on iterating on this thing, which is not gonna lead to, like, meaningful PRs, like, upfront, but it's useful and it's worth it.

[11:42](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=702s) And, you know, I don't wanna say this is perfect, right? Like, we faced a ton of issues while doing this, and I'm just gonna walk you through some of them.

[11:49](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=709s) But it's an iteration loop, so you've gotta treat it like a piece of feedback. So what are the problems we hit, right? There are too many issues. Like, when we started, like, we blew up to, like, four or five hundred issues, uh, without, like, you know, just I think within, like, a couple of weeks, which is a

[12:03](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=723s) crazy number for, like, a repo. And then, you know, there's so many, like, different agents all trying to create issues 'cause they've not been wired correctly. There's a lack of agreement.

[12:12](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=732s) People-- You know, as soon as people saw like, "Oh, this isn't working perfectly or the way I expected it," they're-- it's super easy for them to say, "You know what?

[12:19](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=739s) I'm just gonna go back to babysitting my agent." You don't want that. You wanna actually take their feedback and put it back into the skill and improve the skill.

[12:28](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=748s) Agents are taking too long. This is actually one of those expectation-setting things. It's good if agents take too long. That means you can actually go off and do other things, and you have confidence that they're doing the right thing.

[12:38](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=758s) At the end of the day, like, the moment we hit this reasoning paradigm, the longer the agent, like, thought, the better its output. You can create like a s-- It's almost like a similar mindset for your entire code base and for your skills.

[12:51](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=771s) There's going to be merge hell, and, like, we just have to deal with it. We have to figure out a way to deal with this.

[12:57](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=777s) There is going to be slop when you're gonna write experiments. Treat it like its own thing, right? What we said was, "Okay, people are generating this code, but it's not relevant.

[13:06](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=786s) It's not gonna be shipped." It's just an-- It's a prototype. Treat it like one. Get it to opt out of all the rigorous other standards you've got across your code base.

[13:15](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=795s) And realize people vary on the spectrum, right? And depending on the day, depending on, like, what they're going through, they're gonna vary on the spectrum. You have to be able to talk to them and figure out, "Hey, okay, why, why are you facing this?"

[13:27](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=807s) Like, is it if the model changed, the harness changed? Again, you need to go revisit something. Figure that out.

[13:34](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=814s) And I think the biggest, like, the easiest way to say this is instead of saying like, "The model is so dumb," like, we have to ask, "How can I make it smarter?"

[13:42](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=822s) Or, "How can I edit?" Like, and not... This is why I've, like, crossed out the my. It's not a personal setup. It's the shared setup that you have to invest in.

[13:51](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=831s) And it's a mindset, right? You have to go full send.

[13:55](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=835s) And, like, I wanna end you-- I wanna end with this. Like, I learned skiing, like, a couple years back, and the fir-- like, the hardest thing for me was you actually have to commit to it.

[14:05](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=845s) If you're pizza braking, you're gonna crash, like, no matter what. You have to commit to the speed in order to actually get and feel like, "Okay, that's how I can turn, and that's how I can truly ski."

[14:15](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=855s) And so I'm gonna leave you with this. Like, just be okay with fa-- be okay with failing. You have to, you know, go full send and be okay with falling.

[14:24](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=864s) It's fine. The point is to be able to recover from that, and that'll allow you to truly feel the AGI.

[14:32](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=872s) Yeah. Well, that's, that's me, and I'm happy to take any questions. [audience applauding]

[14:41](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=881s) Yep. Strategies that you found best for progressive disclosure. Uh, so the-- I'm gonna repeat the question for the recording. Uh, strategies that you found best for progressive disclosure. So I think a couple things, right?

[14:53](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=893s) Uh, the first thing is, even in your SKILL.md files, don't overload it. Like, we've kinda set a hard limit for, like, a hundred lines in your SKILL.md 'cause your skill is really a folder.

[15:04](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=904s) So that's step one. Make sure, and I think I spoke about this during the talk, but

[15:09](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=909s) when you have, like, some code that requires, like, a runbook, make sure the runbook is reflected in the comments so that if a code-- if somehow the code, like, the agent figures its way into, like, grepping into the code base and find that file, it knows I need to go look at this for, like, all the description

[15:26](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=926s) of how this is relevant, right? You have to organize. And I think this is why I talk about harness engineering because your entire code base can be set up to encourage progressive disclosure.

[15:36](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=936s) Don't overload your CLAUDE.md or your AGENTS.md file into, like, one big thing. You wanna make sure that, like, it's a thin index that can point through the right files, and that's what the agent gets in its, like, first prompt 'cause that's what gets loaded when it starts to work.

[15:50](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=950s) So these are, like, some really powerful strategies that... And the way you know this is working is when you give it a prompt. When you give it the first prompt, see what it's doing.

[15:59](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=959s) Is it grepping, or does it know where to go? Or how much context is it burning when it, like, immediately? So is it like... I think, like, twenty, twenty-five K tokens get taken anyway.

[16:08](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=968s) But, like, how much more is getting added? If you're coming to, like, forty K, fifty K, like, something's wrong. That's not really progressive disclosure. So you have to figure out these boundaries, and then, like, based on this, it's an iteration cycle.

[16:31](https://www.youtube.com/watch?v=aeTb5BdmTTc&t=991s) All right. Well, if there, there aren't any other questions, feel free to find me. Happy to talk about harness engineering in general or, like, anything else. But yeah, thank you for listening. [outro music]
