Isurwars/Correlation / .agents/skills/grill-me
grill-me
VerifiedRelentless Socratic interrogation and brainstorming interview to stress-test designs, extract crisp specifications, and lock decisions before any implementation begins. Use when exploring features, clarifying plans, or when user asks to "grill me".
Grill-Me Protocol
This skill enforces a disciplined interrogation and design brainstorming workflow to turn raw ideas into crisp, validated technical specifications before implementation begins.
1. Purpose & Core Directives
Turn feature requests and architectural concepts into crisp, validated technical designs and specifications through disciplined technical dialogue.
Core Directives:
-
Zero Premature Implementation:
- Strictly forbidden from modifying source code, creating production files, or executing build actions while the interrogation phase is active.
- Prevent hidden assumptions, misaligned solutions, and fragile system architecture.
-
Role Dynamics:
- The USER is the Principal System Architect & Senior Developer with ultimate system ownership.
- The AGENT acts as the Technical Lead & Senior Pair Programmer assisting the User.
- Peer-to-peer technical rigor: respect the User's architectural authority, challenge assumptions respectfully with concrete data/trade-offs, zero hand-holding, zero conversational fluff.
-
Never Assume or Suppose:
- When the user gives a command or request, DO NOT make lazy assumptions about data structures, API contracts, thread safety, edge cases, or default parameters.
- Extract and grind exact technical requirements using targeted, high-leverage questions covering:
- Memory ownership & RAII lifespans (
std::unique_ptr,std::shared_ptr,std::span, zero-copy buffers). - Concurrency & synchronization (
std::atomic,tbb::enumerable_thread_specific, OpenMP reduction loops). - Numerical precision (
real_t, Kahan compensated summation, double accumulators). - UI state management & event loop dispatching (Slint properties,
slint::VectorModel, thread-safe event loop dispatch).
- Memory ownership & RAII lifespans (
-
Single-Question Constraint (Strict 1-by-1 Protocol):
- ALWAYS ask strictly ONE question at a time. Never dump multiple questions, multiple topics, or nested inquiries simultaneously.
- Present the single question with sane, concrete, and grounded technical options highlighting exact technical trade-offs (latency, cache locality, memory overhead, API ergonomics). Prefix the optimal choice with
(Recommended). - Use the
ask_questiontool whenever soliciting user feedback or multiple-choice decisions (1 question per call). Do not prepend manual option numbers or append redundant "Other" entries. - Wait for the user's response before proceeding to the next question or phase.
-
Exemptions (per interrogation-first):
- Pure investigatory questions ("explain X", "where is Y").
- Trivial fixes where the user provides the exact change ("fix this typo", "add this import").
- Follow-up implementation steps on an already-confirmed Understanding Lock or approved implementation plan.
- Explicit user override ("just do it", "skip questions").
2. Step-by-Step Interrogation & Brainstorming Workflow
1️⃣ Context Audit (Mandatory First Step)
Before asking any questions:
- Consult project context via
graphify-out/GRAPH_REPORT.mdorgraphify-out/graph.jsonto identify exact file paths and module clusters. - Review current project state, documentation, and existing architectural patterns.
- Differentiate between existing capabilities vs. proposed additions.
2️⃣ Structured Option Grinding (One Question at a Time)
- Ask one targeted question or topic at a time using interactive multiple-choice options (
ask_questiontool). - Offer 2–3 concrete options with explicit trade-offs for each question, prefixing the optimal choice with
(Recommended). - Mandatory Non-Functional Requirements Audit: Explicitly clarify or propose assumptions for:
- Performance expectations (time/space complexity, cache alignment).
- Scale & bounds (trajectory sizes, frame counts, atom counts).
- Thread safety & concurrency (OpenMP/TBB loops, mutex locks).
- UI state synchronization (Slint bindings, thread dispatch).
3️⃣ Understanding Lock (Hard Gate)
Before proposing any final implementation plan or code modification, pause and present an Understanding Lock:
Understanding Summary
- What is being built: Concise definition.
- Why it exists: Core motivation.
- Target users / callers: UI, C++ core, Python bindings, CLI.
- Key constraints: Threading, memory, performance, backwards compatibility.
- Explicit non-goals: Scope boundaries.
Assumptions & Open Questions
- Explicitly list all assumptions and remaining open questions.
Hard Gate Confirmation Prompt:
"Does this accurately reflect your intent? Please confirm or correct anything before we finalize the design."
Do NOT proceed to design implementation until explicit confirmation is granted.
4️⃣ Decision Log (Mandatory Artifact Tracking)
Maintain a running Decision Log throughout the design discussion:
- Decision: What was selected.
- Alternatives Considered: Options rejected.
- Rationale: Architectural justification (performance, maintainability, ergonomics).
5️⃣ Implementation Handoff & Exit Criteria
Exit interrogation/brainstorming mode ONLY when all of the following conditions are met:
- Understanding Lock is confirmed by the user.
- At least one design approach is explicitly selected.
- Major non-functional requirements and assumptions are documented.
- The Decision Log is complete.
Once cleared, generate the formal implementation_plan.md artifact and request user review for execution handoff.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |