AI Agent Hub
Back to skills
Grill Me: Structured Design Interview icon

Grill Me: Structured Design Interview

AI Agent Updated 2026.08.30

Paste the following prompt into your AI chat to install this skill:

Please refer to https://skillhub.cn/install/skillhub.md to install @user_9ea429aa/grill-me.

About this skill

The Core Problem: "False Consensus" and "Hidden Dependencies" in Design Decisions

In engineering design discussions, a common pitfall is reaching a "false consensus": the team nods at a high-level plan, only for unforeseen implementation details, technical trade-offs, and dependency chains to surface later. This renders design documents inert and leads to rework during implementation. Another issue is "decision silos": individual technical choices (e.g., database, communication protocol) are made in isolation, without systematically mapping their complex interplay and prerequisites.

The "Grill Me" skill is designed to combat this. It simulates a rigorous but structured technical interviewer, using relentless, systematic questioning to force the transformation of vague intuitions into clear, validated decisions, ensuring all branches and dependencies are explored before coding begins.

How the Skill Works: A Four-Phase Structured Grilling

The core of the skill is a four-phase interview process driven by the AskUserQuestion tool, with decision tree status maintained in real-time via TaskCreate/TaskUpdate. Its workflow is as follows:

  1. Deep Pre-heating (Phase 0): Before any questioning, the skill executes a parallel deep dive. It calls mcp__cloud_brain__cb_retrieve_memories and mcp__note__search_wiki to search historical decisions and knowledge bases, while simultaneously scanning the codebase. It only poses questions to the user when it identifies aspects concerning intent, trade-offs, or unimplemented parts.

  2. Structured Questioning (Phases 1-4): The flow progresses from Goal Alignment (defining what is in and out of scope) to Architectural Decisions (tech selection, module boundaries), then to Boundaries & Risks (error handling, concurrency), and finally Implementation Details (algorithms, API design). During the critical Architectural Decisions phase, the skill must generate Mermaid diagrams to visualize the relationships under discussion.

  3. Depth-First & Conflict-First Strategies: The questioning strategy is "depth-first," digging deep along the most critical branch before backtracking; it is also "dependency-first," resolving prerequisite issues that other decisions hinge upon. When a user presents a new idea or concern, it adopts a "conflict-first" approach to prioritize that discussion.

  4. Intelligent Termination & Memory Persistence: Grilling stops when all decision tasks are complete, the user explicitly terminates, or the user consecutively selects recommended options without adding comments. The skill then outputs a decision summary and uses mcp__cloud_brain__cb_write_memory to persist key decisions (e.g., rationale for selections, leftover risks) as project memory, allowing them to be directly referenced in future discussions.

Application Boundaries and Considerations

  • Positioning: This is a deep-dive alignment and verification tool, best suited for greenfield design or major refactoring. It is not a replacement for all lightweight design reviews; its value lies in thoroughly untangling complex, highly interdependent plans.
  • Interaction Prerequisite: It relies on user interaction via the AskUserQuestion tool's UI. Recommended options (tagged (Recommended)) provide clear guidance, but require active user participation.
  • Visualization Constraints: Generated Mermaid diagrams are limited to basic graph syntax for simplicity. More complex architecture diagrams may need manual adjustment or alternative tools.
  • Memory System: Its "memory" functionality depends on the mcp__cloud_brain backend. Without this service, the decision tree state and summary are retained, but cross-session decision continuity will be lost.

Use Cases

  • When a team needs to design a new technical solution involving multiple modules (e.g., frontend framework, backend service, database choice), this skill is used for structured grilling to sequentially resolve inter-module dependencies and unclarified decision points, ensuring a comprehensive design.
  • In a remote team collaboration, leverage the skill's interactive Q&A and decision tree visualization to asynchronously conduct multiple rounds of in-depth reviews on a complex architectural proposal, clearly recording consensus and disagreements at each stage.
  • Before personally initiating a complex project (e.g., refactoring a core system), use the four-phase interview simulated by the skill to systematically self-check all potential risks, boundary conditions, and implementation details, avoiding major design oversights after starting work.
  • When needing to explain or justify a complex technical plan to non-technical stakeholders (e.g., product managers, management), use the Mermaid diagrams and structured decision summaries generated by the skill to clearly and visually present technical trade-offs and dependencies.

Best For

  • A Tech Lead responsible for system architecture design, needing to ensure the team reaches deep consensus on all tech selections, module boundaries, and exception handling.
  • A PM leading cross-functional projects, needing to transform vague technical discussions into a structured project plan with clear decisions and risk assessments.
  • A senior developer planning a major system refactoring, hoping to thoroughly clarify all potential design flaws and dependencies through structured self-review before coding.
  • An architect needing to report a technical plan and demonstrate its rationale to stakeholders, requiring intuitive diagrams and clear decision paths to aid communication.