AI Engineer World's Fair 2026

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

Loading slides…

Read the talk

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.

From a talk by Aditya Khandelwal

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

When personal productivity meets a shared codebase

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 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.Open full source frame
The recap runs from coding agents taking off to budgets being bolted on.
0:160:29
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:16 · section reference included

Usage can rise while confidence stands still

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.

2:152:24
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:15 · section reference included

Instructions and skills are only the beginning

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.

3:494:00
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

3:49 · section reference included

Leadership owns the shared workflow

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.Open full source frame
Making engineers work well with agents is the company’s job.
5:405:51
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

5:40 · section reference included

Make context discoverable and close the repair loop

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.

7:017:10
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

7:01 · section reference included

Earn trust with one complete workflow

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.Open full source frame
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.

8:509:00
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:50 · section reference included

Connect the repository to feedback and its users

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.

10:3210:46
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

10:32 · section reference included

Use operational failures to improve the shared system

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.

11:4211:49
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

11:42 · section reference included

Q&A: make progressive disclosure observable

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 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 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.

14:4114:53
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

14:41 · section reference included

Resources

From the talk

Updates since the talk

Transcript download
Full transcript

Loading transcript…