Getting Humans Out of the Way: How to Work with Teams of Agents

The central philosophy for working effectively with AI agents is to stop micromanaging them and instead design systems where they can work autonomously and in parallel. The human’s role shifts from being a hands-on coder or reviewer to an orchestrator and a designer of processes. As models improve, developers can step back to higher levels of abstraction—from managing autocomplete, to pair programming, to line management, and now to managing entire teams of agents.

Automated QA with Feature Walk-throughs

A significant bottleneck in agent-based development is the human-in-the-loop verification process. Manually clicking through an app to test a new feature is an inefficient use of a developer’s time. A more effective approach is to require the agent to “manage up” by providing clear, easily digestible proof of its work.

This can be implemented through a “feature walk-through doc”:

• The agent is tasked with creating a document that includes a sequence of screenshots illustrating the new functionality.
• Each screenshot is cropped to focus on the relevant part of the UI.
• Accompanying text explains what is happening in each step.
• Crucially, a second sub-agent reviews this walk-through doc to verify that the screenshots accurately represent the intended functionality, catching errors before they reach the human.

This process provides three key benefits:

1. Automated Verification: It catches bugs and incorrect implementations automatically. The primary agent is instructed to keep iterating until the feature walk-through is successfully verified by the sub-agent.
2. Efficient Human Review: The developer can quickly scan the visual document to approve the work and merge the code, often without needing to run the application locally.
3. Visual Regression Testing: Before a release, all feature walk-through scripts can be re-run. The system can then perform a pixel-match on the screenshots or use an agent to analyze the diffs and flag any unexpected visual changes for human review.

Getting the Human Out of the Loop

The primary role of the human is to define what “good” looks like by creating robust validation processes. Anytime you find yourself manually correcting an agent or spotting a recurring issue, the goal should be to create an automated process to catch it in the future.

• Custom Lint Rules: Agents are excellent at writing custom lint rules. If you notice agents writing code in a style you dislike (e.g., long functions, improper use of CSS), you can have an agent write a lint rule to enforce your preference. This allows for a very tightly defined and consistent coding style.
• Exhaustive Testing: You can enforce extremely high standards for unit test coverage, as agents are proficient at writing comprehensive tests.
• Agent-Centric Documentation: The way agents navigate a codebase is primarily through search. To improve their efficiency, the codebase should be thoroughly documented. A good practice is to enforce lint rules requiring:
  • A comment block at the top of every file explaining its purpose, design decisions, and relationship to other files.
  • A README.md in every folder that describes the folder’s purpose and summarizes the function of each file within it.

This level of rigor, which would be tedious for humans, is trivial for agents. The result is that well-managed, agent-written code can often be of higher quality—better documented, more thoroughly tested, and more consistent—than human-written code.

Managing Agents in Parallel

Working with multiple agents simultaneously is key to maximizing leverage. While this introduces challenges like merge conflicts, these are largely solvable problems for agents.

• Automated Merging: An agent can be given a skill to handle merges by pulling the latest from main, reviewing the incoming changes to understand their “philosophical” intent, and intelligently resolving both syntactic and semantic conflicts. This transforms merging from a painful human task into an automated process.
• Experimentation: You can spin up multiple agents to tackle the same task with different approaches. By reviewing their final validation reports and design decisions, you can simply pick the best outcome and discard the rest—a strategy that is socially unacceptable with humans but highly effective with agents.
• Constant Refactoring: Humans often avoid refactoring because it’s time-consuming. Agents, however, can be tasked with constantly refactoring the codebase to maintain its elegance and extensibility, preventing the gradual decay common in human-managed projects.

The New Role of the Human: Orchestrator and Tool-Smith

As agents take over coding, testing, and documentation, the human’s role evolves. You become a manager focused on enabling your agent workforce.

• Management by Walking Around: While you shouldn’t micromanage, it’s beneficial to periodically check in on what agents are doing. Observing their patterns helps you identify system-level improvements.
• Ask the Agent What’s Hard: A powerful technique is to simply ask the agent what it’s spending its time on or what parts of a task are difficult. The agent’s response is a direct signal for where to invest in improvements.
• Build (or Have Agents Build) Tools: If an agent finds a task laborious (e.g., meticulously comparing a UI component to a Figma design), you can have it build a script or tool to automate that specific task. Just as you give humans tools like compilers and calculators, you should equip agents with specialized tools to make their work easier and more efficient.

Ultimately, the most valuable human skills in this new paradigm are identifying which problems to solve and clearly articulating the desired outcome. The leverage comes from spotting newly solvable problems in a rapidly changing technological landscape and effectively deploying teams of agents to execute the solution.

• Tags:
• AI Agents
• Software Development
• Code Generation
• MLOps
• Automation
• Broomy
• QA
• Visual Regression