If you work with AI agents, you've already seen it: the requirement arrives half-finished, a short sentence with no context, and almost immediately each agent returns a different solution. None is correct, but all sound confident. Adding another agent clarifies nothing; it only produces more plausible versions of the same misunderstanding.
Brooks' law was clear to begin with: adding people to a late software project makes it later. Its mutation with AI agents is subtler and faster: adding agents to a project with unclear requirements gets you to the wrong answer sooner. You don't have to wait weeks to see the failure; it appears early, but it multiplies.
The problem isn't that agents are incompetent. It's that they're optimized to complete a task, not to understand it. When the request is ambiguous, they complete the version of the task they invented themselves. And because they do it fluently, the result looks valid until someone tries to use it.
What makes this version treacherous is that the cost isn't visible in the moment. An isolated agent with a vague prompt produces a response that looks reasonable. Another agent, even when given exactly the same prompt, produces a different response because it chose different assumptions. The team loses time comparing options, testing integrations, and discovering that none of them matches what the user actually asked for.
Adding more agents to the project doesn't resolve the ambiguity; it accelerates it. Each new agent is an additional bet on a different assumption. The more agents there are, the faster the possible combinations of an incorrect interpretation get exhausted. And because they all work in parallel, the result is a set of solutions that are inconsistent with one another, but presented with the same confidence.
When requirements are vague, the bottleneck isn't the ability to generate code; it's the ability to know which code is needed. AI agents are excellent at the first part and very bad at the second if no one forces them to stop. That's why the problem isn't solved by adding another agent to interpret the same prompt; it's solved by giving each agent a control mechanism up front.
The solution isn't writing longer prompts like someone praying to get it right. It's changing the workflow so the AI checks itself before delivering anything. The Make AI check itself (prompt-pack) pattern consists of having the agent verify its own understanding and its own output. That verification isn't an extra; it's the barrier that separates speed from direction.
In practice, this means asking the agent to restate the problem in its own words and to flag ambiguities before it starts. If it can't do that, it has no basis for producing a correct answer. The task isn't to move forward; it's first to make sure the starting point exists. Once the agent has named what's missing, its work can be directed, corrected, or stopped with good judgment.
The same principle applies at the end. After generating a response, the agent must check it against its own restatement of the problem and against the requirements it could identify. It must ask itself: Does this answer the stated need, or a comfortable assumption? What part of the output depends on a choice that wasn't confirmed? That self-check turns error into an early warning, not a last-minute surprise.
This doesn't eliminate the work of clarifying requirements with the user. What it does is stop pretending the requirements are clear. Each agent, instead of imagining a response, exposes its interpretation and verifies it. The team discovers where the misunderstanding is earlier, because the misunderstanding becomes visible in the agent itself before it spreads to the code.
The difference shows up in the work cycle. Instead of receiving a final answer and discovering it doesn't fit, the agent returns a first message saying what it understood and what it needs to clarify. That message is shorter than the code, but worth more, because it prevents the wrong code from being written. Review stops being a rescue and becomes a confirmation.
The updated Brooks' law doesn't make AI agents useless. It establishes that adding agents to a project with unclear requirements gets you to the wrong answer faster. The only way to make that speed work in your favor is to force each agent to check its own understanding and its own output. The Make AI check itself (prompt-pack) pattern is exactly that: the verification that turns a bunch of fast agents into a team moving in the right direction, even when requirements still aren't clear.