Skip to content

rse/ase / plugin/skills/ase-meta-compat

ase-meta-compat

Verified

Self-test the LLM's ability to execute ASE's core interpreter machinery (control flow, XML placeholders, regex matching, arithmetic) and report an overall compatibility rating. Use when the user wants to check how well the current model/harness is compatible with ASE, or asks to "test ASE compatibility" or "check ASE compatibility".

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

If $1 (the first token of the skill arguments) is equal to -h or --help, you MUST once output the following output and then IMMEDIATELY STOP the further skill processing:

Self-Test ASE Compatibility

Objective

Self-test how faithfully the current LLM (and its harness) executes the four core interpreter primitives that every ASE skill silently relies on -- control flow, XML placeholders, regex matching, and arithmetic -- and report an overall 0%…100% compatibility rating.

This skill is unusual: it is both the test definition and the system under test. Each probe is a pure ASE construct that you execute, recording its actual result. The expected values are never shown to you: only STEP 6 submits all actual results to the ase_compat MCP tool, which grades them. Do not fabricate passes: the grading of the tool is final.

Notice that this skill intentionally does not strictly follow the ASE skill format; in particular, it does not include the usual meta skill information.

Procedure

IMPORTANT: Execute all of the following steps in one go: you MUST NOT end your turn before the final verdict of STEP 7 is output.

  1. STEP 1: Initialize Self-Test

    Initialize the running map of actual probe results (set to empty) -- every probe in STEPs 2-5 stores its result here as a <category/>/<probe-name/> entry with its actual computed value.

    Initialize the running list of failed probes (set to empty) -- this is populated only in STEP 6 from the grading of the actuals.

    IMPORTANT: Do NOT call the ase_compat MCP tool now. It is called exactly once, in STEP 6, after all probes of STEPs 2-5 have been executed and recorded in .

    IMPORTANT: Do NOT output anything in this step: and are internal state only. Continue directly with STEP 2 without ending your turn.

  2. STEP 2: Probe XML Placeholders

    Execute all of the following XML-placeholder probes (in the given order). For each probe, record the actual result in under the key xml-placeholders/<probe-name/>. Do not compare to any expected value here.

    1. get-and-set: Set 42, then get . Record actual result for xml-placeholders/get-and-set.

    2. self-ref: Set 42, then set <v>pre_<v/></v>, then get . Record actual result for xml-placeholders/self-ref.

    3. overwrite: Set 42, then set <v>99</v>, then get . Record actual result for xml-placeholders/overwrite.

    4. indexed: Set <eval-1-2>+1</eval-1-2> and <eval-2-1>-1</eval-2-1>, then get and via <eval-1-2/>,<eval-2-1/>. Record actual result for xml-placeholders/indexed.

    5. nested-attr: With 20, build the value of an XML attribute width="<w/>" and read the attribute width back. Record actual result for xml-placeholders/nested-attr.

    6. entity: Evaluate the XML entity &#x29BF; and get the rendered Unicode character. Record actual result for xml-placeholders/entity.

    Set to the number of XML-placeholder probes above.

  3. STEP 3: Probe Control Flow

    Execute all of the following control-flow probes (in the given order). For each probe, record the actual result in under the key control-flow/<probe-name/>. Do not compare to any expected value here.

    1. branch: Set 3, then evaluate <if condition="<a/> is greater than 5">big</if> <elseif condition="<a/> is greater than 2">mid</elseif> <else>small</else>. Record actual result for control-flow/branch.

    2. while-sum: Set 0 and 1, then evaluate <while condition="<i/> is less than or equal to 5"> set <s/> to <s/> + <i/>, set <i/> to <i/> + 1 </while>. Record as actual result for control-flow/while-sum.

    3. for-order: Set , then evaluate <for items="x y z"><s><s/>-<item/></s></for>. Record as actual result for control-flow/for-order.

    4. while-break: Set 1 and , then evaluate <while condition="<i/> is less than or equal to 9"> if <i/> equals 4 set <hit/> to <i/> and <break/>, else set <i/> to <i/> + 1 </while>. Record as actual result for control-flow/while-break.

    5. step-skip: A <step condition="[...]">[...]</step> either expands to its body (if condition evaluates to true) or to the empty string, so what does <step condition="42 is greater than 7">X</step> expand into? Record the result of this construct for control-flow/step-skip.

    6. expand-subst: With <define name="foo">[<arg1/>:<content/>]</define>, evaluate <expand name="foo" arg1="K">V</expand>. Record actual result for control-flow/expand-subst.

    Set to the number of control-flow probes above.

  4. STEP 4: Probe Regex Matching

    Execute all of the following regex probes (in the given order). For each probe, record the actual result in under the key regex/<probe-name/>. Do not compare to any expected value here.

    1. getopt-dash: Does the string -l foo match the regexp (^|\s)-? Record yes or no as actual result for regex/getopt-dash.

    2. getopt-nodash: Does the string foo match the regexp (^|\s)-? Record yes or no as actual result for regex/getopt-nodash.

    3. anchored-int: Does 123 fully match ^\d+$, and does 12a fully match ^\d+$? Report as <yes-or-no/>,<yes-or-no/>. Record actual result for regex/anchored-int.

    4. alternation: Does thorough match ^(basic|standard|thorough)$? Record yes or no as actual result for regex/alternation.

    5. capture: Apply ^--(\w+).+ to --foo-bar-quux. Record the first capture group as actual result for regex/capture.

    6. whitespace: Does -x (leading space then dash) match (^|\s)- (the \s alternative)? Record yes or no as actual result for regex/whitespace.

    7. complex: Does --level=(low|high)... match ^--([A-Za-z][A-Za-z0-9-]*)(?:\|-([A-Za-z]))?(?:=(\((.*)\)(\.\.\.)?|.*))?$? Record yes or no as actual result for regex/complex.

    Set to the number of regex probes above.

  5. STEP 5: Probe Arithmetic

    Execute all of the following arithmetic probes (in the given order). For each probe, record the actual result in under the key arithmetic/<probe-name/>. Do not compare to any expected value here.

    1. increment: With 7, compute + 2. Record actual result for arithmetic/increment.

    2. product-sum: Compute 4.00 * 1.00 + 2.00 * 0.50. Record actual result (as X.XX) for arithmetic/product-sum.

    3. percentage: Compute 3 / 7 rounded to 2 decimal places. Record actual result (as 0.XX) for arithmetic/percentage.

    4. bar-width: With 13, compute 67 - <title-len/>. Record actual result for arithmetic/bar-width.

    5. threshold: Is 0.095 less than 0.10? Record yes or no as actual result for arithmetic/threshold.

    6. round-half: Round 2.5 to the nearest integer (round half up). Record actual result for arithmetic/round-half.

    Set to the number of arithmetic probes above.

  6. STEP 6: Grade Actual Results and Score

    Precondition: holds the actual results of all 25 probes of STEPs 2-5. If any probe is still missing, first execute it and record its actual result.

    Call...

    ase_compat(actuals: { "<category/>/<probe-name/>": "<actual/>", [...] })

    ...of the ase MCP server, passing all entries of , with an internal programmatic MCP tool call (and NOT with an external shell command) and set to the text content of the response.

    If the tool responds with an error listing missing probes, execute exactly these probes, record their actual results in , and call the tool again with all entries of .

    Parse by splitting on newlines; for each non-empty line of the form <id/>: <grade/>:

    • If is pass, count the probe as pass.
    • Else ( is fail), count the probe as fail and append <id/> to .

    Tally pass counts per category:

    • Set to the number of xml-placeholders/* probes that passed.
    • Set to the number of control-flow/* probes that passed.
    • Set to the number of regex/* probes that passed.
    • Set to the number of arithmetic/* probes that passed.
  7. STEP 7: Compute and Report Compatibility

    Compute each category's pass-rate (a value in 0.0…1.0) by dividing its passes by its total:

    set to / , set to / , set to / , set to / .

    Compute the overall compatibility as a weighted average of the four pass-rates, where XML placeholders carry weight 4.00 (the backbone of every skill), control flow carries weight 3.00, regex matching carries weight 2.00, and arithmetic carries weight 1.00. Use the ase_decision_matrix MCP tool with a single "compatibility" alternative column, one matrix row per category of the form [ <weight/>, <rate/> ]:

    Call...

    ase_decision_matrix(matrix: [ [ 4.00, <xml-rate/> ], [ 3.00, <cf-rate/> ], [ 2.00, <re-rate/> ], [ 1.00, <arith-rate/> ] ])

    ...of the ase MCP server with an internal programmatic MCP tool call (and NOT with an external shell command) and set to the single numerical value of the returned array.

    The product-sum is the sum over the four rows of <weight/> * <rate/>, so dividing by the sum of weights (4.00 + 3.00 + 2.00 + 1.00 = 10.00) yields the weighted-average compatibility on 0.0…1.0:

    Set to / 10.00. Set to round( * 100) (an integer percentage).

    Also compute each category's display percentage:

    Set to round( * 100), and likewise , , .

    Determine the from :

    1. If is greater than or equal to 90: Set ✓ FULLY COMPATIBLE.

    2. Else if is greater than or equal to 60: Set ⚠ PARTIALLY COMPATIBLE.

    3. Else: Set ✘ INCOMPATIBLE.

    4. If is not empty: Append to the suffix (failed: <failures/>).

    Finally, output the compatibility report:

    RESULTS:

    ⦿ Capability⚖ Weight✓ Passed⚑ Rate
    XML Placeholders4.00/%
    Control Flow3.00/%
    Regex Matching2.00/%
    Arithmetic1.00/%
    OVERALL%

    VERDICT:

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: 197kUpdated Claude CodeCodexVerifiedInstall