# Coding Agents Don't Scale Themselves. Neither Do Your Teams.

Patrick Debois, Tessl | AI Engineer | 22:06

Source: https://www.youtube.com/watch?v=zCJtYuqwm7E
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/coding-agents-dont-scale-themselves-neither-do-your-teams
Published: 2026-08-22
Tags: agents, coding-agents, context-engineering, harness-engineering, team-adoption

## TL;DR
- The main obstacle to autonomous software work is organizational readiness, rather than the agent technology itself.
- Teams should stop repairing each generated code result and improve the context, harnesses, loops, and engineering practices that produce results.
- The useful scaling metrics are the number of human touches needed for a correct result and how much each improvement is reused across the team.

## Summary
Patrick Debois argues that coding agents will become increasingly commoditized, perhaps even as a service from a frontier lab. The organizational design around them will matter more. Developers who dislike becoming prompt managers can regain a technical role by building harnesses, loops, context systems, tests, and other tooling for agents. Debois asks teams to improve the system instead of repeatedly fixing its output. Retrospectives should examine where an agent gets stuck, while planning should separate well-scoped work that can be handed to an agent from work that still needs human discussion. He recommends tracking human touches and reuse across the team. At the organizational level, platform teams need to provide owned, maintained, testable paved roads for shared context and agent tooling, while making spend visible. Leaders should give teams a mandate rather than rely on generic champions programs. Debois is candid that hiring, team size, risk, and measurement remain unsettled.

## Key ideas
### Resistance to autonomous work often signals organizational unreadiness
[00:36](https://www.youtube.com/watch?v=zCJtYuqwm7E&t=36s)
Debois compares the current reaction to dark factories with the reaction he heard about continuous delivery in 2009. When people say, "It will not work here," he reads that as evidence that the organization is not prepared yet. He expects loops, harnesses, and related agent technology to become commodities, possibly offered as a service by a frontier lab. That means the differentiator will be the way the team, platform, and wider organization work around the agents. He frames the talk around those changes rather than around improving one developer's prompting technique.

### Harnesses give developers a technical role around agents
[02:50](https://www.youtube.com/watch?v=zCJtYuqwm7E&t=170s)
The idea that developers become conductors or orchestrators creates friction because many developers did not sign up to write better prompts and specifications. Debois says harnesses and loops opened a technical path back into the work. Developers began building tooling for the agent, which let them apply their engineering knowledge programmatically. He also recommends involving skeptical developers in context and harness work. People who complain about poor output often have the knowledge and motivation to improve the system that produced it.

### Teams should improve the system instead of repeatedly fixing its output
[05:27](https://www.youtube.com/watch?v=zCJtYuqwm7E&t=327s)
Debois's main advice to developers is to stop fixing the code produced by the agent and improve the system. That means working on reusable context, harnesses, loops, tests, documentation, and guidelines. He connects this to the idea of building the thing that builds the thing. Engineering practices still matter when agents are involved. Teams should require agents to use tests and update documentation rather than accept an unreviewed result from a casual prompt.

### Retrospectives should track repeated agent failures
[07:04](https://www.youtube.com/watch?v=zCJtYuqwm7E&t=424s)
Team rituals change when agents do more of the work. In a retrospective, the question becomes where the agent repeatedly hit the same problem and how the system can be changed to prevent it. Planning also divides into two kinds of work. Well-defined tasks can go directly to agents, while poorly scoped tasks still need team conversation. Team leads set the pace by turning one-off prompts into reusable context and by imposing constraints instead of telling everyone to experiment independently.

### Agent output can create a downstream bottleneck
[08:56](https://www.youtube.com/watch?v=zCJtYuqwm7E&t=536s)
As a team produces more, people downstream may struggle to keep up. Debois names go-to-market teams and users, and says their automation may need to improve too. Requirements gathering can also become a bottleneck if input does not arrive fast enough for the development team. The agent harness therefore cannot stop at code generation. The surrounding workflows need to handle the increased rate of production and the demand for requirements.

### Human touches and shared improvements measure team scaling
[09:38](https://www.youtube.com/watch?v=zCJtYuqwm7E&t=578s)
Debois focuses on two measures. The first is how many human touches are still needed before the agent produces the right result. That number should fall as the harness, context, and guidelines improve. The second is how much an improvement is shared. A shared system lets one fix benefit everyone, unlike a single person becoming a 10x developer. Teams can begin by sharing context and harnesses in a repository, then extend those shared components across the organization.

### Platform teams need an owner and maintained paved roads
[10:29](https://www.youtube.com/watch?v=zCJtYuqwm7E&t=629s)
Scaling beyond one repository brings platform and developer experience teams into the work. Debois lists skill registries, evaluation systems for context, guardrails for coding agents, and identities as areas that need attention. Someone must own the program, even if the ownership sits between existing teams. Shared context, authentication, linters, security tools, and harnesses can become reusable platform components. Without ownership, teams create overlapping skills, forks, and unmaintained repositories. A small catalog of maintained paved roads may work better than forcing every team into one shared approach.

### Leaders should mandate shared systems and make spend visible
[12:12](https://www.youtube.com/watch?v=zCJtYuqwm7E&t=732s)
Debois rejects a familiar transformation pattern of hackathons, lunch-and-learns, success stories, shared chat channels, and a champions program. He also rejects simply handing out licenses and letting a thousand flowers bloom. Team leads and platform teams need a mandate to do the work. The platform team should show what agents cost and where iterations are being spent. Visible costs create a chance to reduce unnecessary runs, choose a suitable model, and improve context or harnesses instead of imposing a blanket spending cap.

### Hiring and risk decisions need several separate skills
[15:36](https://www.youtube.com/watch?v=zCJtYuqwm7E&t=936s)
New titles such as AI product engineer, agentic engineer, and AI engineer do not prove a person's maturity or ability. Debois describes an interview approach that lets candidates use AI on an exercise, then asks them to explain what happened and why their choices were good. The interview also tests collaboration and willingness to share. These skills do not have to exist in one person. At the other end of the organization, a dim factory needs explicit risk decisions. Teams can choose where autonomous approval is acceptable and invest in provenance, auditing, verifiers, and situational awareness for higher-risk work.

## Notable quotes
- "What they're actually signaling to me is we're not ready yet." (00:36)
- "Stop fixing the code that the agent produced, but improve the system." (05:27)
- "One change that optimizes the agents has an impact on all the people." (10:02)
- "You shouldn't say, 'Let's limit all the spends.' Your reflex should be, 'Let's optimize the spend.'" (18:34)
- "It's not the solo player that will win the game. It's at the different levels how we improve our organizations." (21:37)

## Tools & references mentioned
- continuous delivery
- dark factory
- Conway's law
- Claude Code
- coding agents
- context engineering
- harnesses
- loops
- MCP gateway
- skill registries
- evaluation systems
- guardrails
- AI product engineer
- agentic engineer
- AI engineer

## Who should watch
- Your developers are producing agent output but still spend most of their time repairing individual results.
- You are deciding whether platform or developer experience should own shared context, harnesses, registries, and guardrails.
- Your organization is considering autonomous approval and needs a way to connect engineering practices, cost, reuse, and risk.

## Related talks

- [AI Coding Agents Are Breaking Big Codebases](https://aietalks.com/talks/ai-coding-agents-are-breaking-big-codebases) (Dan Adler, Sourcegraph, 12:23)
- [Software Development Agents: What Works and What Doesn't](https://aietalks.com/talks/software-development-agents-what-works-and-what-doesnt) (Robert Brennan, OpenHands, 16:46)
- [Agentic Engineering: Working With AI, Not Just Using It](https://aietalks.com/talks/agentic-engineering-working-with-ai-not-just-using-it) (Brendan O'Leary, Kilo Code, 27:03)
- [Self Coding Agents](https://aietalks.com/talks/self-coding-agents) (Colin Flaherty, Augment Code, 17:23)
- [Agents, codebases, and teams](https://aietalks.com/talks/agents-codebases-and-teams) (Aditya Khandelwal, Amazon AGI Lab, 16:57)
