rse/ase / plugin/skills/ase-task-grill
ase-task-grill
VerifiedInterview the user relentlessly about the task plan until reaching a shared understanding, resolving each branch of the question decision tree. Use when the user wants to stress-test a plan, get grilled on their plan, or mentions "grill me" or "grill plan".
help.md
View on GitHub
## NAME
`ase-task-grill` - Iteratively Grill a Task Plan
## SYNOPSIS
`ase-task-grill`
[`--help`|`-h`]
[`--rounds`|`-r` *n*]
[`--until`|`-u` `MUST`|`SHOULD`|`MAY`]
[`--perspective`|`-p` *perspective*]
[`--ground`|`-G`]
[`--auto`|`-a`]
[`--focus`|`-f` *section*[,...]]
[`--force`|`-F`]
[`--quiet`|`-q`]
[`--diff`|`-d`]
[`--next`|`-n` *option*[,...]]
[*id*]
## DESCRIPTION
The `ase-task-grill` skill *relentlessly interviews* the user about
every *essential aspect* of an existing *task plan* until a *shared
understanding* is reached and no decisions or questions are left open.
The skill identifies the essential aspects of the plan and raises up to
10 questions per round which resolve its open points. Each question
carries a `FOCUS-AREA` -- `DOMAIN` (domain-specifics, must be
clarified), `INTERFACE` (externally observable behavior or UI/API
interfaces, must be clarified), `ARCHITECTURE` (structure, wiring,
placement, or dependencies, should be clarified), `IMPLEMENTATION`
(inner technical details, can be clarified), `REGRESSION` (what must
not break, should be clarified), or `CONFIRMATION` (what proves the
specified behavior, should be clarified) -- and a 1-3 word `TOPIC`
hint. The focus areas are selected by the plan sections under focus
(`--focus`): `SPECIFICATION` selects `DOMAIN` and `INTERFACE`, `DESIGN`
selects `ARCHITECTURE` and `IMPLEMENTATION`, and `VERIFICATION` selects
`REGRESSION` and `CONFIRMATION`. The questions are sorted
by descending focus area importance, then by descending individual
impact, and finally by the decision tree of their dependencies, so each
decision is asked after the decisions it depends on. It honors checks
for *fuzzy language*, *conflicting terminology*, *conflicting code*,
*non-concrete scenarios*, *unspecified architecture patterns*, and
*unspecified dependencies*.
As with `ase-code-edit --grill`, all questions of a round are announced
together below a `GRILLING ROUND K/L` line (plain `GRILLING` for a
single round) as a `QUESTION`/`ANSWERS` table with one row per
question, each row carrying two to three *grounded* answer alternatives
(the one reflecting the current plan marked with `⚑`, and the one
critically judged best, if any, marked with `★` as the recommendation,
whose rationale shows up in the hover card of every answer). They are then
asked in *one* batch via a single interactive dialog, whose only answer
options are the fixed `AUTO GRILLING` (answer this and all remaining
rounds like `--auto`, which is not forwarded on a re-grilling) and
`SKIP GRILLING` (skip the remaining grilling, but still update the plan
with the answers of the previous rounds), plus free-text input. The questions are numbered `1`, `2`, etc. and their
answer alternatives are lettered `A`, `B`, etc., so the free-text input
can cherry-pick answers with short responses matching `\d+[a-zA-Z]`
(like `1A 2c`), freely mixed with keyword text. A question not
addressed by the reply accepts its `★` answer, if one exists.
Cancelling the dialog stops the skill without updating the plan with
the current round. After every round, the plan is updated and
persisted, its `Tags:` frontmatter key records each grilled section as
its own tag `grilled:`*section* (lower-case, kept alongside the tags of
previously grilled sections, e.g. `grilled:specification,
grilled:design`), and a `PLAN CHANGES` box shows the bullet-points
changed by the round (unless `--quiet` is given). Finally, the user is offered a complete
re-grilling (with the same grilling options), or a hand-off to editing,
implementation, or draft.
The *open* questions are recorded in the checkboxes of the plan's
bullet-points: a bullet-point whose question stayed *unanswered*
(because the grilling was skipped, or the reply did not address a
question the plan offers no answer for) is marked `[?]`, an unanswered
question the plan does not cover yet is added as a new `[?]`
bullet-point, and an *answered* question resets its bullet-points to
`[ ]`. When a section is grilled *again* (its `grilled:`*section* tag
is already present), only its `[?]` bullet-points are re-asked, and a
section without any `[?]` bullet-point is skipped entirely, unless
`--force` is given. Bullet-points
in state `[-]` (cancelled) or `[>]` (deferred) are never questioned.
A round which stops early tags only the sections without any open
point as grilled, so a section with open points below the `--until`
severity is still grilled by a later run with a lower severity.
## OPTIONS
- `--rounds`|`-r` *n*:
The *maximum* number of grill rounds to apply (default: `1`). Each
round starts from scratch from only the current plan, as updated and
saved by all previous rounds, and re-derives its questions from it,
forgetting all questions and answers of previous rounds. With more than one
round, each round is announced as `GRILLING ROUND K/L`. The grilling
stops early -- announced by a `grilling finished early` status line
-- once a round, even the first one, finds the open points clear
enough according to `--until`.
- `--until`|`-u` `MUST`|`SHOULD`|`MAY`:
Grill until at least all open points of the given severity or
higher are clear (default: `MUST`), where the severity follows from
the focus area: `MUST` (`DOMAIN`, `INTERFACE`), `SHOULD`
(`ARCHITECTURE`, `REGRESSION`, `CONFIRMATION`), and `MAY`
(`IMPLEMENTATION`). Without `SPECIFICATION` in the `--focus`, the
severity `MUST` is lowered to `SHOULD`, as no other section yields
`MUST` points. Independent of this, every open point is rated
with an individual impact (`HIGH`, `MEDIUM`, or `LOW`), which
decides which points are raised as questions and in which order
within a focus area.
- `--perspective`|`-p` *perspective*:
Grill exclusively from the logical *perspective* -- a keyword or
short hint like `domain`, `performance`, or `security`. The
perspective acts as an exclusive lens: only open points relevant from
this perspective are raised as questions, while every question still
carries its focus area, severity, and impact. The active perspective
is shown in the announcement line, like `GRILLING (security)`.
Without a perspective, the grilling is holistic.
- `--ground`|`-G`:
Ground the grilling in facts instead of the world knowledge of the
model alone: once before the first round, each dimension of the
sections under `--focus` -- `WHAT` (`SPECIFICATION`), `HOW`
(`DESIGN`), and `WHEN` (`VERIFICATION`) -- is grounded in parallel.
Its artifacts (`SPEC` and `DOCS` for `WHAT`, `CODE` and `INFR` for
`HOW`, and the test and CI files for `WHEN`) are scanned for the
project facts relevant to the plan, and the Internet/Web is searched
iteratively, with at most 5 searches per dimension, for the
established practices, standards, patterns, and pitfalls about it.
Both focus especially on the special and less known terms and
concepts and on the aspects which potentially could be outdated in
the model knowledge, judging every Web fact by its date or version.
These facts serve all rounds, both for raising the questions and for
preferably deriving their answer alternatives. The grounding is shown
in the announcement line, like `GRILLING (security, grounded)`. If
no usable facts are found, a warning is shown and the grilling falls
back to model knowledge. It is forwarded on a re-grilling and on a
hand-off to `ase-task-edit`, but not on a hand-off to another skill.
- `--auto`|`-a`:
Answer the questions automatically instead of asking the user via
the interactive dialog: every question gets its `★` recommended
answer, while a question without a recommendation stays unanswered
(and hence `[?]`), like a question skipped in an interactive reply.
The questions table is still shown, followed by a status line naming
the auto-chosen answers, like `auto-chosen answers 1A 3B`. It is
forwarded on a re-grilling.
- `--focus`|`-f` *section*[,...]:
Grill only the given plan *section*(s), in the given order. Each
*section* is one of `SPECIFICATION` (also `SPEC` or `WHAT`), `DESIGN`
(also `DES` or `HOW`), or `VERIFICATION` (also `VERIFY`, `VER`, or
`WHEN`), matched case-sensitively, or the sentinel `all` (default),
which expands to `SPECIFICATION,DESIGN,VERIFICATION`. The questions
are derived from the themes of the focused sections only, while the
entire plan stays the context, and an answer requiring a change
outside of the focus is applied nevertheless and reported by a
warning. An unknown, empty, or duplicate *section* token aborts the
skill. It is forwarded on a re-grilling and on a hand-off to
`ase-task-edit`, but not on a hand-off to another skill.
- `--force`|`-F`:
Re-grill already grilled sections completely, i.e., ignore their
`grilled:`*section* tags instead of skipping them resp. re-asking
only their `[?]` bullet-points.
- `--quiet`|`-q`:
Do not print the `PLAN CHANGES` box of the bullet-points changed by
a round. The status lines and the dialogs stay. It is forwarded on a
re-grilling and on a hand-off to `ase-task-edit`, but not on a
hand-off to another skill.
- `--diff`|`-d`:
Show how the grilling actually changed the plan: once after all
rounds, right before the next-step dialog, a `PLAN DIFF` box shows
the cumulative change of the plan body (title and sections, without
frontmatter and attachments) between the plan as loaded at the start
and the final plan as a unified diff, or `(none)` if nothing
changed. This is especially useful together with `--auto`, to review
the auto-chosen answers. The diff is always shown in full, also
together with `--quiet`, and not when the dialog is cancelled. It
is forwarded on a re-grilling.
- `--next`|`-n` *option*[,...]:
Automatically answer the user dialog for the next step (at the end
of this skill). *option* is a single token or a *comma-separated
chronological list* of tokens; the *first* token is consumed by
this skill and any remaining tokens are *forwarded* (via `--next`)
to the downstream skill on hand-off so an entire pipeline can be
pre-scripted in one shot. Recognized tokens at this skill: `none`
(default, interactive answer required), `DONE` (no next step),
`GRILL` (re-grilling via `ase-task-grill --force` with the same
grilling options), `EDIT` (hand-over to `ase-task-edit`),
`IMPLEMENT` (hand-over to `ase-task-implement`), or `DRAFT`
(hand-over to `ase-task-implement --draft`).
## ARGUMENTS
- *id*:
Grill the task with the unique identifier *id* (default: the current task).
The skill accepts *only* an optional *id* argument and never a
free-text instruction.
## SCENARIOS
- You want to be interviewed about your plan until it is watertight
- You want the open decisions of a plan resolved question by question
- You want fuzzy language and conflicts flushed out of a plan
- You want shared understanding before the implementation starts
## EXAMPLES
Grill the current task plan:
```text
❯ /ase-task-grill
```
Grill the task plan under id `hello`:
```text
❯ /ase-task-grill hello
```
Grill the current task plan in two rounds:
```text
❯ /ase-task-grill --rounds 2
```
Grill the current task plan exclusively from the performance
perspective, grounded in the project artifacts and the Internet/Web:
```text
❯ /ase-task-grill --perspective performance --ground
```
Grill only the `DESIGN` and then the `SPECIFICATION` section of the
current task plan:
```text
❯ /ase-task-grill --focus DES,SPEC
```
Grill the current task plan with automatically chosen recommended
answers:
```text
❯ /ase-task-grill --auto
```
Grill the current task plan with automatically chosen recommended
answers and review the resulting plan changes as a unified diff:
```text
❯ /ase-task-grill --auto --diff
```
Re-grill the already grilled current task plan completely:
```text
❯ /ase-task-grill --force
```
Grill the current task plan and then hand off to editing:
```text
❯ /ase-task-grill --next EDIT
```
## SEE ALSO
[`ase-task-edit`](../ase-task-edit/help.md), [`ase-task-reboot`](../ase-task-reboot/help.md),
[`ase-task-implement`](../ase-task-implement/help.md), [`ase-task-view`](../ase-task-view/help.md), [`ase-task-list`](../ase-task-list/help.md),
[`ase-task-rename`](../ase-task-rename/help.md), [`ase-task-delete`](../ase-task-delete/help.md), [`ase-code-edit`](../ase-code-edit/help.md).
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 |