Grill-Me Design Interview
A structured interview that stress-tests your plan with one question at a time, resolving each branch of the decision tree until you reach a shared understanding.
The skill is purely conversational and performs no external actions, no permission requests, data leaks, or destructive behavior, so risk is low. However, there is no explicit confirmation mechanism (e.g., requiring user consent before key decisions) and no data-flow disclosure, and the publisher is unverified. Hence partial deductions.
Instructions are clear and follow a standard interview process, but there are no tests and no error-handling guidelines (e.g., behavior when user is unresponsive or contradictory). Static review cannot execute verification, so a moderately low score is given.
Use case is clear (stress-testing plans/designs) and trigger words are explicit ('grill me'), but non-fit scenarios and environment fit (e.g., Chinese language support) are not described, and it relies on the AI model with no environment requirements.
Documentation structure is clear, but version numbers, changelogs, maintenance responsibility are missing, and dependencies (like request_user_input tool) are not documented, examples and FAQs absent.
Core objective is clear, but no actual output examples or comparative advantage evidence provided, static review cannot verify result quality, hence low score.
No tests or execution evidence; only an AI instruction file, cannot be independently verified, so low score.
- This skill relies entirely on the AI model's conversational capability and will not work without network or AI availability.
- No explicit user confirmation is required, which may lead to decisions without explicit user consent in some scenarios.
- No guidance on handling abnormal inputs such as user refusal to answer or contradictory information.
- Publisher identity is unverified; verify before use.
What does this skill do, and when should you use it?
This skill turns the agent into a structured design interviewer. It asks one question at a time, using your answers to guide an implicit decision tree across goals, constraints, alternatives, APIs, data models, security, observability, and more. It challenges vague or contradictory assumptions and inspects the codebase when repository facts are needed rather than asking you to supply them. When the major branches are resolved, it summarizes the agreed design, remaining risks, assumptions, rejected alternatives, and next steps. The skill is designed for coding agents but can be used for any technical planning scenario.
Upon user request to 'grill me', the skill initiates a series of questions: exactly one question at a time, waiting for an answer between each. It maintains an implicit decision tree of resolved decisions, open questions, assumptions, dependencies, risks, and rejected alternatives. For each question, it includes clear answer options when appropriate, a recommended answer marked as recommended, and a brief reason for the recommendation. It uses open-ended questions when fixed options would prematurely constrain the design space, challenges vague or inconsistent assumptions, and asks follow-ups when contradictions arise. If repository facts are needed, the skill inspects the codebase instead of asking the user. It may use a user-input tool like request_user_input for short questions or present numbered lists in plain text. Finally, it summarizes the agreed design, remaining risks, assumptions, rejected alternatives, and next steps.
- A product manager or engineer who wants a rigorous architectural review of a plan before writing code.
- A developer who wants to stress-test their design assumptions to catch flaws early.
- A tech lead who wants to explore the decision space and understand trade-offs without prematurely committing to fixed options.
- A team that needs to clarify requirements, non-goals, and operational ownership (like success criteria) before building.
- An engineer who wants to compare multiple approaches and explicitly document rejected alternatives.
What are this skill's strengths and limitations?
- Provides a structured thinking partner that explicitly tracks decisions, assumptions, and risks.
- One question at a time prevents overwhelming the user and allows thoughtful answers.
- Uses clear, actionable questions with recommended options when appropriate, improving usability.
- Encourages self-sufficiency by instructing the agent to inspect the codebase instead of asking the user.
- Aims to reach a defensible design and a clear summary, useful for planning documentation.
- No public test suite or examples, so actual behavior may vary by agent implementation.
- The skill relies on the agent following instructions well; different agents may vary in adherence.
- It may feel overly thorough for very simple plans; it is best suited for complex designs.
- No provision for offline or alternative modes—strictly an interactive interview.
How do you install this skill?
This skill is part of a collection of skills bundled in the T3 Code repository at https://github.com/pingdotgg/t3code. To install the entire collection, clone the repository and navigate to the subdirectory containing the desired skill. There are no separate standalone installation instructions; refer to the repository README for T3 Code tool installation, but the skill itself can be used by placing its folder into your agent's skills directory.
How do you use this skill?
To use, simply say 'grill me' or 'help me stress-test this plan' and describe your plan or design. The skill will start asking questions. For example, you could say: "Grill me: we're planning to migrate our monolith to microservices. Here's our current approach..." Then the skill will ask relevant questions, one at a time. Alternatively, you can say 'grill me' as a follow-up instruction when discussing a proposed design in the current task.