This idea originates from Fred Brooks.

When you have more than one person working on something, there is some idea or invisible theory. Good systems are guided by a coherent underlying idea shared by the people building them. In agentic programming, the agent needs access to that concept before it starts generating implementation details.

The Design Tree

The traditional "rational model" assumes a complete design tree (a tree of decisions) can be drawn upfront, which Brooks argues is rarely true for novel systems.

Unlike routine design, original design involves evolving, interconnected constraints where the "desiderata" (desired outcomes) change, making it difficult to fully map the tree of choices.

Instead of fully mapping a decision tree beforehand, design is a process of co-evolution, where the problem and the solution are understood more deeply through constant iteration.

This is what you want to do during the first stage of coding anything with an agent: you need to co-design it and try to come up with better and better versions of the decision tree.

Fix 1: /grill-me

The idea of using this skill is that it forces a shared design concept to exist before implementation.

Just using plan mode is not enough: you really need to put in a lot of effort to get the details communicated to the agent and ensure that there is not details that you leave for the agent to figure out itself.

• Implementation: Before any code is written, the agent must run a grill-me sub-task where it critiques its own proposed plan.
• Criteria: The review must evaluate the plan for:
  • Reliability: How will it handle tool failures or ambiguous LLM outputs?
  • Context Management: Is the plan efficient with token usage and state persistence?
  • Security: Does it protect credentials and system integrity?
  • Scalability: How does the design hold up as task complexity increases?
• Outcome: The agent cannot proceed until it has answered its own "grilling" questions and updated the design tree accordingly.