## The problem I kept hitting a case where dependent questions got asked in the same batch. Worst was five at once, and answering Q1 made the next four moot or changed their scope. "The whole frontier" was being read loosely enough that decisions whose fate still hung on an open answer slipped in. On top of that, the agent kept asking obvious things such as variable names, trivial choices that I want agent to infer. Grilling should only ask about decisions where a wrong guess forces rework or reshapes the tree, not surface-level stuff the model can infer fine. ## Proposed fix Add **frontier** as an explicit gate and **pivots** as the ordering within a round. One mechanism, one job each: - **Frontier (gate)**: only ask decisions whose prerequisites are already settled. Within a round, batch only questions that would still need asking no matter how the open answers resolve, if one question's answer could change whether another belongs at all, ask it to a later round. - **Pivot (order)**: within the safe-to-ask set per round, ask tree-reshaping decisions first, details later. A pivot is a decision whose answer could reshape the tree. ## Other improvements Tested over a few sessions in personal projects. These all shipped in one patch, happy to split if useful. - Incremental question numbering that never reuses or skips, so long sessions don't drift across rounds. Resets only on explicit session restart. - Swapped sub-agent "exploration" for mechanism-agnostic "fact-finding", I personally dont like to use sub agents for exploration, word explore unnecessary triggering subagent every rounds. - Made the no-act gate explicit: acting covers planning, summarizing, and implementing; confirmation isn't silence, partial answers, or answering a question. The old "do not act until the user confirms" read as implication too often. - Rebuilt the question template with stacked (A)/(B)/(C) options on their own lines. The old single-line option block kept collapsing into one paragraph. - Added "for trivial decisions, assume your recommended answer" to cut the variable-name-tier noise. It's a model judgment call, which I'm not fully comfortable with, but the noise reduction is worth it. Open to a better wording. - ## some more improvements - Question template reworked: - added ==== separators around each question based on recent PR. - question body must now be short/simplified - detailed explanation moved to its own paragraph slot (options details, solution tradeoffs), one per line (explicit new rule). - Trivial assumptions transparency: recommended answers for trivial decisions must now be briefly summarized with the user instead of silently assumed. - Explicit exit gate: Session end now requires a plan summary and explicit user typed "confirmed" before implementation, as my test model sometimes exits by self-confirming. - Guardrails dropped (from repo ending): the enumeration of "acting" (planning/summarizing/implementing), the "confirmation is not silence/partial answers" clause, and "when in doubt, ask". As I felt its quit unnecessary after adding explicit exit gating. # This Skill was recently updated, see https://github.com/mattpocock/skills/issues/895#issuecomment-6039544803 ## Suggested Skill Content ``` Interview the user relentlessly until you reach a shared understanding. Map this as a **design tree**: every decision branches into the decisions that hang off it. Work the tree in **rounds**. The **frontier** is every decision whose prerequisites are already settled: the questions you can ask _now_ without guessing at answers you haven't heard yet. Ask **pivot** first within the frontier; defer minor details to later rounds. A pivot is a decision whose answer could reshape the tree. Within each round, batch only questions that would still need asking no matter how the open answers resolve; if one question's answer could change whether another belongs at all, defer it to a later round. Then wait for the user's answers before the next round. Number questions `Q` and assumptions `A` each in incremental order, never reusing or skipping a number; reset both counts only when the user restarts the session. Ask each question as the template below. Options are bullet points, each on its own line, for example: /``` ==== ## Q1 - "question topic": simplified question body ... detailed question body and examples if any ... **A.** - option 1 **B.** - option 2 ... more such options if any ... > **Recommended: X.** - reason for you option choice ... ==== /``` Never ask for anything you can look up or research yourself. Run fact-finding in parallel, including web search, and never block a round on it. Never rely on your own knowledge alone. Assume your recommended answer for minor or obvious decisions, or any non-pivotal decision whose answer does not reshape the design tree. Surface every such assumption in the same round as a numbered bullet, so the user can veto any of them regardless of any round, for example: /``` ==== ## Assumptions: **A1.** - assumption 1 **A2.** - assumption 2 ... more assumptions ... ==== /``` The grilling session ends when every frontier decision is settled and mutual understanding is achieved. Summarize all the decisions and the assumptions you made, then wait for the user's typed `confirmed`. DO NOT proceed to implementation or execution until the user's explicit "confirmed" after grilling end. DO NOT assume "confirmed" yourself. ``` *Remove `/` around template, it's just to prevent the code block from breaking here* ## Example output:
