Frontier Rounds
Interview the user until you reach a shared understanding. Map the work 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 have not heard yet. Ask the whole frontier in one round. Then wait.
Each answer reshapes the tree: settled decisions push the frontier outward and unblock questions that depended on them. Recompute the frontier and ask the next round. A question whose answer depends on another question still open in this round belongs to a later round, not this one.
Question format
❓ **Q1** — **<short title>**: <the question, including options where they exist>
➡️ <your recommended answer, and the reason in a clause>
Number every question. Give a recommendation on every one — a question without a recommendation makes the user do work you could have done. If you genuinely have no view, say which fact would give you one.
Facts are your job, never the user's
When a frontier question turns on something the environment can answer — what a file contains, what a command prints, what version is installed, whether a path exists — go and find out. Never ask the user for something you could look up.
A running lookup is an unsettled prerequisite, not a blocker on the round. Only the questions downstream of it wait; ask the rest of the frontier now.
Dispatching a sub-agent for these lookups is authorised for this skill only, and only for
read-only environment facts whose answer is checkable. Pass model: haiku and low effort —
this is mechanical work. Never dispatch a sub-agent to decide, design, draft, review, or answer
on the user's behalf: the decisions are the user's, and putting them to the user is the
entire point.
What to consult
When a frontier question is a design decision rather than a preference, reach into the
software-design-rules skill for the vocabulary — keyed to the question, not to a role, because
the frontier changes every round:
| The question turns on | Read |
|---|---|
| a boundary, or what depends on what | rules/clean-architecture.nano.md |
| whether a module earns its interface | rules/a-philosophy-of-software-design.nano.md |
| consistency, schema change, retention | rules/designing-data-intensive-applications.nano.md |
| what can hang, retry, or fan out | rules/release-it.nano.md |
| whether this is over-built | rules/refactoring.nano.md (Speculative Generality) |
Use the nano tier during rounds. An interview runs long and an 800-word mini on every
design question bloats the session least able to afford it. Step up to mini only when a single
question is genuinely the whole decision.
Ask how it will be verified
Before the session ends, settle how the work will be checked, because the answer picks the strategy and it is far cheaper to choose here than to argue with a plan template later:
- Deterministic pure logic → TDD. Red-green per task, the way
superpowers:writing-plansspecifies it. - An enumerable parameter space → combinatorial coverage. A space you can list is one where a hole is a real bug and hand-picked cases will miss it.
- Prose, a prompt, or a skill → an ablation. There is no failing test for a markdown file; the question is whether removing it changes behaviour, and that is measured, not asserted.
- A network boundary → neither. Decide what is faked and what is probed live, and say which.
The session is done when the frontier is empty
Every branch visited, nothing left silently assumed. Do not act on it until the user confirms you have reached a shared understanding, and do not drift into building — this skill produces settled decisions, not deliverables. The pull to start work is the signal to hand off.
Relationship to superpowers
This sits beside superpowers:brainstorming, and never modifies it. Superpowers is an
independent plugin — the cache carries more than one version, so an edit would be wiped on
upgrade and would fork someone else's work besides.
The difference is the algorithm, not the goal. Brainstorming asks one question per message, strictly sequential, which is right for an idea that has no shape yet. This asks the whole frontier per round, which is right for a design that already exists: it stops serialising questions that were never dependent on each other.
Provenance
The design-tree / frontier / rounds algorithm, the recommended-answer-per-question format, and
the "finding facts is your job, never the user's" rule are from Matt Pocock's grilling skill
(github.com/mattpocock/skills, MIT, commit 9c9f36c), vendored for reference at
docs/vendor/writing-for-agents/. Adapted here in two ways: sub-agent dispatch is scoped to
read-only environment facts rather than left open, and the design-rules table and
verification-strategy step are additions.
Design rules content belongs to the software-design-rules skill, which credits its own sources.
