Skip to content

rse/ase / plugin/skills/ase-task-grill

ase-task-grill

Verified

Interview 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".

FileKindSize
SKILL.mdskill md22.5 KB
help.mdmarkdown12.4 KB
---
name: ase-task-grill
argument-hint: "[--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: >
    Interview 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".
user-invocable: true
disable-model-invocation: false
effort: high
---

@${CLAUDE_SKILL_DIR}/../../meta/ase-control.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-skill.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-dialog.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-getopt.md

<purpose name="ase-task-grill">
Iteratively Grill a Task Plan
</purpose>

<expand name="getopt"
    arg1="ase-task-grill"
    arg2="--rounds|-r=1 --until|-u=(MUST|SHOULD|MAY) --perspective|-p= --ground|-G --auto|-a --focus|-f=(all|SPECIFICATION|SPEC|WHAT|DESIGN|DES|HOW|VERIFICATION|VERIFY|VER|WHEN)... --force|-F --quiet|-q --diff|-d --next|-n=(none|DONE|GRILL|EDIT|IMPLEMENT|DRAFT)... --int-reuse-task --int-interactive"
    arg3="colon-or-bare">
    $ARGUMENTS
</expand>

<objective>
Interview the user relentlessly about every essential aspect of the
task plan until reaching a shared understanding.
</objective>

@${CLAUDE_SKILL_DIR}/../../meta/ase-format-task.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-common-task.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-common-ground.md
@${CLAUDE_SKILL_DIR}/../../meta/ase-common-grill.md

<expand name="task-plan-only"/>

Procedure
---------

1.  **Determine Task:**

    1.  Set <instruction><getopt-arguments/></instruction> initially, with any
        leading and trailing whitespace stripped.
        Inherit the always existing <ase-task-id/> from the current context.
        Inherit the always existing <ase-session-id/> from the current context.
        Do not output anything.

    2.  If <getopt-option-rounds/> is not a positive integer,
        only output the following <template/> and then immediately
        *STOP* processing the entire current skill:

        <template>
        ⧉ **ASE**: ☻ skill: **ase-task-grill**, ▶ ERROR: invalid `--rounds` value: **<getopt-option-rounds/>**
        </template>

    3.  Resolve the plan sections under focus:

        <expand name="task-focus" arg1="ase-task-grill"></expand>

        Each section in <sections/> selects its *focus areas* of the
        grilling: `SPECIFICATION` selects `DOMAIN` and `INTERFACE`,
        `DESIGN` selects `ARCHITECTURE` and `IMPLEMENTATION`, and
        `VERIFICATION` selects `REGRESSION` and `CONFIRMATION`. Do not
        output anything.

        As the severity follows from the focus area, the focused
        sections yield at most the severity `MUST` (`SPECIFICATION`)
        resp. `SHOULD` (`DESIGN`, `VERIFICATION`). Hence, step 3.2 below
        caps the `--until` severity at the highest severity the
        remaining sections can yield, so a grilling of only `DESIGN`
        or `VERIFICATION` does not stop before asking anything.

    4.  React on task id:

        <expand name="task-react-id" arg1="ase-task-grill"></expand>

2.  **Determine Task Plan:**

    1.  Determine the current task plan content:

        <expand name="task-load-content"></expand>

    2.  <if condition="<task-content/> is empty">
        Complain and tell the user to use the `ase-task-edit` skill
        first to create a task plan. Then immediately stop processing
        this skill.
        </if>

        <if condition="<getopt-option-diff/> is equal `true`">
        Set <body-before/> to the *body* of <task-content/>: its lines
        from the `#   TASK:` title line up to, but excluding, the `---`
        line opening its first backmatter block (or up to its end, if it
        has none), i.e., without its frontmatter and backmatter. This
        remembers the plan *before* all rounds for step 4. Do not output
        anything.
        </if>

    3.  Determine the *grilling scope* of each section in <sections/>,
        in order to grill an *already grilled* section again *only* where
        questions are still *open*:

        -   If <getopt-option-force/> is `true`, *ignore* any
            `grilled:<section/>` tag: the scope of *every* section is the
            *entire* section, so already grilled sections are *re-grilled*
            completely. Skip the following two cases.

        -   If the `Tags:` frontmatter key of <task-content/> carries
            the tag `grilled:<section/>` (with <section/> being the
            *lower-case* name of the section) and the section contains
            *no* bullet-point in checkbox state `[?]`, the section is
            *already grilled* and nothing is open: *remove* it from
            <sections/> and only output the following <template/>:

            <template>
            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **section <section/> already grilled -- skipped (use `--force` to re-grill)**
            </template>

        -   If the `Tags:` frontmatter key carries the tag
            `grilled:<section/>` and the section contains *at least one*
            bullet-point in checkbox state `[?]`, *restrict* the scope of
            the section to *exactly* these `[?]` bullet-points, so the
            grilling re-asks only the *still open* questions.

        -   Otherwise, the scope of the section is the *entire* section.

        Independent of the scope, bullet-points in checkbox state `[-]`
        (cancelled) or `[>]` (deferred) are *inert*: they are *never*
        subject of a question and their checkbox is *never* changed.

        <if condition="<sections/> is empty afterwards">
        Skip the entire step 3 below -- the plan is *neither* updated
        *nor* saved -- and continue directly with step 4.
        </if>

3.  **Iterate Over Task Plan Aspects:**

    1.  Understand what "grilling" is about:

        <expand name="grill-understanding"
            arg1="the task plan in <task-content/>"
            arg2="<getopt-option-perspective/>"
            arg3="<getopt-option-ground/>"></expand>

        <if condition="<getopt-option-ground/> is equal `true`">
        Ground the grilling, where <dimensions/> lists, in the order of
        <sections/>, `WHAT` for `SPECIFICATION`, `HOW` for `DESIGN`, and
        `WHEN` for `VERIFICATION`:

        <expand name="ground"
            arg1="the task plan in <task-content/>"
            arg2=""
            arg3="<dimensions/>"></expand>
        </if>

    2.  <if condition="the frontmatter of <task-content/> carries a `Created: <text/>` key">
        Set <timestamp-created><text/></timestamp-created> (set
        timestamp-created to extracted text).
        </if>

        Set <grill-until/> to <getopt-option-until/>, but lowered to
        `SHOULD` if it is `MUST` and <sections/> does *not* contain
        `SPECIFICATION`, as only `SPECIFICATION` yields questions of
        severity `MUST`. Do not output anything.

    3.  Perform *at most* <getopt-option-rounds/> grilling *rounds*,
        numbered <m/> (1-<getopt-option-rounds/>) -- the round count is
        a *maximum* only, as every round can *stop* the grilling *early*
        in its item 2 below.

        Set <grill-auto/> to <getopt-option-auto/>, so a dialog answer
        `AUTO GRILLING` (see item 3 below) switches only the remaining
        rounds of the *current* grilling to automatic answering, and is
        *not* forwarded on a re-grilling in step 5. Do not output
        anything.

        For each round:

        1.  INITIALIZE ROUND:

            Explicitly start *from scratch* from *only* the *current*
            <task-content/> -- as updated by all previous rounds -- and
            *forget* all questions and answers gathered in previous
            rounds -- except the grounding facts <ground-facts/>. Set
            <round-id/> to
            `GRILLING ROUND <m/>/<getopt-option-rounds/>` if
            <getopt-option-rounds/> is greater than 1, or to
            `GRILLING` otherwise (a single round needs no round
            numbering). Do not output anything.

        2.  DETERMINE QUESTIONS:

            <expand name="grill-questions"
                arg1="<grill-until/>"
                arg2="◉ task: **<ase-task-id/>**"
                arg3="file and directory paths, identifiers, symbols, types, commands, options, configuration keys, and literal values"
                arg4="the <task-content/>, the code base,"
                arg5=", and *finally* by the decision tree order, which *overrides* the impact order wherever a decision has to be asked *after* the decisions it depends on">
                Focus *only* on the *Focus Areas* selected by
                <sections/> -- the *themes* of the focused sections,
                *within* the *grilling scope* of each section as
                determined in step 2.3, while the *entire*
                <task-content/> stays the context -- and check the
                mentioned *Indicators*. For a section restricted to its
                `[?]` bullet-points, derive the questions from *exactly*
                these bullet-points only. Never raise a question about a
                `[-]` or `[>]` bullet-point. Create a decisions/questions
                tree for the questions, capturing the dependencies
                between the decisions.

                For each question, set <items-N/> to the bullet-points of
                <task-content/> the question is about -- possibly *none*,
                if the question concerns an aspect the plan does not
                cover yet.
            </expand>

            If <grill-stop/> is `true`, skip the items 3, 4, and 6 of
            this round, perform item 5 of this round (tagging only the
            focused sections without any open point as grilled), then
            skip all remaining rounds and continue with step 4.

        3.  INTERACTIVE DIALOG:

            <if condition="<grill-auto/> is equal `true`">
            Answer the questions without any dialog:

            <expand name="grill-auto"
                arg1="◉ task: **<ase-task-id/>**"></expand>

            Treat <result/> as the combined free-text answers to all
            questions of the round and continue with item 4 below.
            </if>
            <else>
            In the following, you *MUST* *NOT* use your built-in
            <user-dialog-tool/> tool! Instead, you *MUST* just show a
            custom dialog according to the expanded `custom-dialog`
            definition. You *MUST* closely follow this definition. The
            dialog below carries the two fixed answer options
            `AUTO GRILLING` and `SKIP GRILLING`, dispatched as follows:

            -   If a <result/> is `AUTO GRILLING`, set
                <grill-auto>true</grill-auto>, so all remaining rounds
                are answered without any dialog, too, and answer the
                questions of this round like under `--auto`:

                <expand name="grill-auto"
                    arg1="◉ task: **<ase-task-id/>**"></expand>

                Treat <result/> as the combined free-text answers to all
                questions of the round and continue with item 4 below.

            -   If a <result/> is `SKIP GRILLING`, ask no further
                questions -- *all* questions of this round stay
                *unanswered* --, continue with items 4 to 6 below
                (updating and saving the plan with the answers of the
                previous rounds), and afterwards skip all remaining
                rounds and continue with step 4.

            -   If a <result/> is `CANCEL`, only output the following
                <template/> and then immediately *STOP* processing the
                entire current skill, *not* updating the plan with the
                current round (the plan updates saved by previous
                rounds are kept):

                <template>
                ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **grilling stopped**
                </template>

            Show a custom dialog. Its only answer options are the two
            fixed ones, so the user normally answers all aspects in
            *one* free-text reply:

            <expand name="custom-dialog" arg1="--other">
                <round-id/>: What is your (combined) answer to all (or a subset) of the above questions? (keywords or `nX` short responses are sufficient)
                AUTO GRILLING: auto-choose the recommended answers of this and all remaining rounds
                SKIP GRILLING: skip all remaining grilling and continue with the plan update
            </expand>

            Dispatch `AUTO GRILLING`, `SKIP GRILLING`, and `CANCEL` as
            defined above.
            Otherwise, strip any leading `OTHER: ` prefix from
            <result/> and treat the remainder as the combined free-text
            answers to all questions of the round.
            </else>

        4.  MERGE ANSWERS INTO PLAN:

            Merge all gathered answers in <result/> of the round -- the
            combined reply -- *exclusively* back into <task-content/>.

            <expand name="grill-short-responses"></expand>

            A question *not* addressed by the combined reply accepts its
            answer marked with `★` (the recommendation) if one exists, and
            otherwise stays *unanswered*. On `SKIP GRILLING`, *no* `★`
            answer is accepted, so *all* questions of the round stay
            *unanswered*. Additionally, record the
            *open* questions in the checkboxes of the body
            bullet-points, changing *only* checkboxes in state `[ ]` or
            `[?]` and leaving every `[/]`, `[x]`, `[-]`, and `[>]`
            checkbox *untouched*:

            -   For each *answered* question, set the checkbox of every
                bullet-point in <items-N/> to `[ ]`, as the question is
                resolved now.

            -   For each *unanswered* question, set the checkbox of every
                bullet-point in <items-N/> to `[?]`, as the question is
                still open. If <items-N/> is *empty*, *add* a new `[?]`
                bullet-point to the section of the question's focus area
                <context-N-focus/>, with the corresponding <type/>, a
                <summary/> derived from <context-N-topic/>, and a <text/>
                stating the open <question-N-text/>, so a later grilling
                can re-ask it.

            Set <changes/> to all bullet-points of <task-content/> which
            were changed or added in this round. Do not output anything,
            except for the following warning:

            <if condition="<getopt-option-focus/> is not equal `all` and <changes/> contains a bullet-point of a section *not* in <sections/>">
            An answer required a *foreign change* outside of the focus,
            which is applied nevertheless. Set <foreign/> to the
            comma-separated names of these sections and only output the
            following <template/>:

            <template>
            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ WARNING: changed sections outside of focus: **<foreign/>**
            </template>
            </if>

        5.  SAVE PLAN:

            For each section in <sections/>, *set* the tag
            `grilled:<section/>` -- with <section/> being the
            *lower-case* name of the section (`specification`,
            `design`, or `verification`) -- in the `Tags:` frontmatter
            key of <task-content/>: keep an already present identical
            tag as is, otherwise append it, keeping all other already
            present tags (including `grilled:` tags of other sections)
            and *creating* the whole key at its position in the key
            order of the plan <format/> if the plan carries none. A
            fully grilled plan hence carries the tags
            `grilled:specification, grilled:design,
            grilled:verification`.

            If <grill-stop/> is `true`, set the tag *only* for the
            sections of <sections/> for which item 2 determined *no*
            question of their focus areas at all, as the questions of a
            severity below <grill-until/> stay unasked and unrecorded,
            and a tag would make every later run skip their section
            (see step 2.3), even with a lower `--until` severity.

            <if condition="neither the body nor the `Tags:` key of <task-content/> changed in this round">
            Skip the saving, as there is nothing to persist, and only
            output the following <template/>:

            <template>
            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan unchanged**
            </template>
            </if>
            <else>
            <expand name="task-save-content" arg1="plan updated"></expand>
            </else>

        6.  SHOW PLAN CHANGES:

            <if condition="<getopt-option-quiet/> is not equal `true`">
            Set <round-suffix/> to
            ` round <m/>/<getopt-option-rounds/>` if
            <getopt-option-rounds/> is greater than 1, or to empty
            otherwise, and only output the following <template/>, which
            shows every bullet-point of <changes/> in its plan format
            `-   <box/> <type/>: **<summary/>**: <text/>`, grouped below
            a `**<SECTION>**:` line per plan section, where an empty
            <changes/> renders as `(none)` -- this intentionally closes
            *every* round, so the intermediate plan changes stay
            visible:

            <template>
            <ase-tpl-head title="PLAN CHANGES" subtitle="after grilling<round-suffix/>"/>

            <changes/>

            <ase-tpl-foot title="PLAN CHANGES" subtitle="after grilling<round-suffix/>"/>
            </template>
            </if>

4.  **Show Plan Diff:**

    <if condition="<getopt-option-diff/> is equal `true`">
    Set <body-after/> to the *body* of the current <task-content/> -- as
    saved by the last round, or unchanged if no round saved it --
    determined exactly like <body-before/> in step 2.2. Call the
    `ase_text_diff(before: "<body-before/>", after: "<body-after/>",
    label: "<ase-task-id/>")` tool of the `ase` MCP server and set
    <diff/> to the `text` output field of this tool call. You *MUST*
    *NEVER* compose the diff yourself.

    If <diff/> is empty, set <diff-block>(none)</diff-block>. Otherwise,
    set <diff-block/> to <diff/>, emitted *verbatim*, inside a fenced
    code block with the info string `diff`, whose fence is one backtick
    longer than the longest backtick run within <diff/> (and at least
    three backticks long).

    Then only output the following <template/>, which shows the
    cumulative change of all rounds -- *independent* of
    <getopt-option-quiet/> and of <ase-project-boxing/>, whose exposure
    rules are explicitly *overridden* here, as the user explicitly
    requested the diff:

    <template>
    <ase-tpl-head title="PLAN DIFF" subtitle="after grilling"/>

    <diff-block/>

    <ase-tpl-foot title="PLAN DIFF" subtitle="after grilling"/>
    </template>
    </if>

5.  **Decide Next Step:**

    1.  *Determine next step*:

        <expand name="task-next-select"
            arg1="ase-task-grill"
            arg2="DONE|GRILL|EDIT|IMPLEMENT|DRAFT">
            Next Step: How would you like to proceed with the plan?
            DONE: Stop processing.
            GRILL: Re-grill the plan again.
            EDIT: Hand off plan to editing.
            DRAFT: Hand off plan to implementation drafting.
            IMPLEMENT: Hand off plan to implementation.
        </expand>

    2.  Check the tool <result/> and dispatch accordingly:

        -   If <result/> is `DONE` or `CANCEL`:
            Only output the following <template/> and then *STOP*,
            without output of any further information.

            <template>
            ⧉ **ASE**: ◉ task: **<ase-task-id/>**, ▶ status: **plan updated -- done**
            </template>

        -   If <result/> is `GRILL`:
            Set <grill-args>--force --rounds <getopt-option-rounds/> --until <getopt-option-until/> --focus <getopt-option-focus/></grill-args>.
            <if condition="<getopt-option-perspective/> is not empty">
                Set <grill-args><grill-args/> --perspective <getopt-option-perspective/></grill-args>,
                with the value shell-quoted if it contains spaces or special characters.
            </if>
            <if condition="<getopt-option-ground/> is `true`">
                Set <grill-args><grill-args/> --ground</grill-args>.
            </if>
            <if condition="<getopt-option-auto/> is `true`">
                Set <grill-args><grill-args/> --auto</grill-args>.
            </if>
            <if condition="<getopt-option-quiet/> is `true`">
                Set <grill-args><grill-args/> --quiet</grill-args>.
            </if>
            <if condition="<getopt-option-diff/> is `true`">
                Set <grill-args><grill-args/> --diff</grill-args>.
            </if>
            <if condition="<getopt-option-int-interactive/> is `true`">
                Set <grill-args><grill-args/> --int-interactive</grill-args>.
            </if>
            <expand name="task-next-handoff" arg1="ase-task-grill"
                arg2="plan updated -- hand-off to re-grilling"
                arg3="<grill-args/>"></expand>

        -   If <result/> is `EDIT`:
            Set <edit-args></edit-args> (empty).
            <if condition="<getopt-option-quiet/> is `true`">
                Set <edit-args><edit-args/> --quiet</edit-args>.
            </if>
            <if condition="<getopt-option-int-interactive/> is `true`">
                Set <edit-args><edit-args/> --interactive</edit-args>.
            </if>
            <if condition="<getopt-option-focus/> is not equal `all`">
                Set <edit-args><edit-args/> --focus <getopt-option-focus/></edit-args>.
            </if>
            <if condition="<getopt-option-ground/> is `true`">
                Set <edit-args><edit-args/> --ground</edit-args>.
            </if>
            <expand name="task-next-handoff" arg1="ase-task-edit"
                arg2="plan updated -- hand-off to edit"
                arg3="<edit-args/>"></expand>

        -   If <result/> is `DRAFT`:
            <expand name="task-next-handoff" arg1="ase-task-implement"
                arg2="plan updated -- hand-off to implementation draft"
                arg3="--draft"></expand>

        -   If <result/> is `IMPLEMENT`:
            <expand name="task-next-handoff" arg1="ase-task-implement"
                arg2="plan updated -- hand-off to implementation"></expand>

finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the workStars: 322kUpdated Claude CodeCodexVerifiedInstall
systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixesStars: 322kUpdated Claude CodeCodexVerifiedInstall
test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation codeStars: 322kUpdated Claude CodeCodexVerifiedInstall
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: 198kUpdated Claude CodeCodexVerifiedInstall