# Agents, codebases, and teams — Aditya Khandelwal, Amazon AGI Lab

## Executive summary

The adoption of AI agents in software development is presented as primarily a leadership and organizational challenge, not merely an individual contributor (IC) problem. Successful implementation requires systemic changes—specifically 'harness engineering'—to manage codebase complexity and ensure reliable agent performance across teams. Key strategies include implementing progressive disclosure, establishing high-value skills like 'ship it,' and creating self-healing CI/CD pipelines to mitigate inevitable AI 'slop.'

## Key takeaways

- Agent Adoption is a Leadership Problem: The speaker argues that making engineers work well with agents requires organizational buy-in (leadership action) rather than individual effort. Relying on ICs to restructure the codebase alone will fail, leading to uneven productivity and increased review burden for those who are not early adopters.
- Symptoms of a Poor Setup: Warning signs that an agent setup is failing include: engineers 'babysitting' agents, the system silently burning context (e.g., blowing through 500k context units), or requiring constant manual intervention for simple tasks.
- Harness Engineering Principles: Effective agent integration requires three principles: Smart prompt injection (treating the codebase as a single unit to inject context), closing the loop (creating self-healing pipelines to detect and remove 'slop'), and continuous iteration, treating the process like an ongoing organizational improvement effort.
- Progressive Disclosure Best Practices: To manage context overload, implement strict boundaries. For example, a hard limit of approximately 100 lines is suggested for files like `skill.md` to ensure the agent receives only necessary context in its initial prompt.

## Technical details

- Codebase Organization & Context Management: The concept of progressive disclosure is critical: the codebase must be structured so that agents are only given the minimum necessary context (e.g., documentation living in code comments) to complete a task, preventing massive context burns.
- The 'Ship It' Skill: A high-value skill that automates the entire process from 'code done' to 'PR ready for review.' This includes handling PR descriptions, managing merge comments, and running through CI failures, often taking over an hour.
- System Reliability & Feedback Loops: The system must be designed to close the loop, creating a self-healing pipeline that detects and removes 'slop' (suboptimal or irrelevant code/output) generated during experimentation. This requires integrating issues and boards directly into the repository.

## Practical implications

- Treat AI agent integration as a systemic, organizational process (harness engineering) rather than an individual coding task.
- Implement strict architectural controls like progressive disclosure and context limits (e.g., limiting `skill.md` size to ~100 lines).
- Develop automated skills that manage the entire development lifecycle, from code completion through CI/CD failure resolution.
- Establish a continuous feedback loop mechanism to detect and correct 'slop' in agent-generated output.

## Topics

AI Agents, Codebase Architecture, Build Engineering, CI/CD Pipelines, Progressive Disclosure, Generative AI Adoption, Aditya Khandelwal, GitHub Profile

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