Use when reviewing a DataFusion Comet pull request that adds or changes a Spark expression, its Scala serde, its protobuf message, or its native Rust implementation. Load alongside review-comet-pr, which covers the parts of the review that apply to every PR.
Expression-specific review for Comet PR #$ARGUMENTS.
REQUIRED BACKGROUND: Use review-comet-pr for PR metadata, existing comments, CI, the review
bar, and the output format. This skill only covers what is specific to expressions.
The benchmark workflow and the no-regression rule, for PRs that change an existing kernel
docs/source/contributor-guide/timezones.md
The timestamp label rule, where the session timezone comes from, and how to test it, for datetime expressions, casts, and anything that returns a timestamp
Hold the diff against these. If the PR does something a guide says to do differently, either the PR
is wrong or the guide is out of date, and you need to say which.
1. Read the Spark Source
For any PR that adds or modifies an expression, you must read the Spark source to understand the
canonical behavior. This is the authoritative reference for what Comet must match. Do not review
an expression PR from the diff alone.
Clone Spark into /tmp/spark if it is not already there, using a shallow clone, then find the
expression class under sql/catalyst/src/main/scala by searching for its case class declaration.
Read the Spark implementation carefully. Pay attention to:
eval and doGenCode / nullSafeEval. These define the exact behavior.
inputTypes and dataType. These define which types Spark accepts and what it returns.
Null handling. Does it use nullable = true? Does nullSafeEval handle nulls implicitly?
Special cases, guards, and require assertions.
ANSI mode branches, usually SQLConf.get.ansiEnabled or failOnError.
Behavior differences across the Spark versions Comet supports. If the expression changed between
3.5 and 4.0, the serde needs a shim, not a single implementation.
Then read the Spark tests for the expression, under the test source trees in sql/.
Compare Spark's behavior against the PR and identify edge cases Spark tests that the PR does not,
types Spark supports that the PR does not handle, and behavioral differences that should be marked
Incompatible.
All child expressions converted via exprToProtoInternal
Return type correctly serialized
getSupportLevel reflects true compatibility rather than the happy path
Serde lives in the appropriate file (datetime.scala, strings.scala, arithmetic.scala, and so on)
ANSI and fail_on_error handling matches the constraints in adding_a_new_expression.md
A change that routes a whole class of expressions to the JVM codegen dispatcher lists the new
shapes it admits and tests one of each, including decimal results whose scale differs from the
declared type and boolean inputs from sliced batches (#6424, #6425)
A timezone-aware expression serializes CometTimeZone.nativeId(expr.timeZoneId), the
timezone Spark stamped on it in a form native code can parse, rather than
SQLConf.get.sessionLocalTimeZone or the JVM default, and returns
CometTimeZone.supportLevel from getSupportLevel when nativeId gives None
Registration in QueryPlanSerde.scala
Added to the correct map (temporal, string, arithmetic, and so on)
No duplicate registrations
Import statement added
Return type collisions with DataFusion built-ins
If the PR registers a Spark function whose name is also defined by datafusion-functions, such as
levenshtein, concat, coalesce, sha2, or regexp_replace, check that the serde sets the
return type explicitly via scalarFunctionExprToProtoWithReturnType rather than
scalarFunctionExprToProto or the bare CometScalarFunction(name) shortcut.
Without an explicit return type the native planner consults DataFusion's UDF registry first for
type resolution, and any arity or input-type difference between the Spark and DataFusion versions
fails native execution with Error from DataFusion: Function 'X' expects N arguments but received M. The Comet UDF is only swapped in after DataFusion's signature validation passes. See "When to
set the return type explicitly" in adding_a_new_expression.md.
3. Rust Implementation
Location: native/spark-expr/src/, registered in comet_scalar_funcs.rs.
Matches DataFusion and Arrow conventions
Null handling is correct, including nulls inside nested types
No panics. Use Result.
Batch operations rather than row-by-row where a kernel exists
Invalid UTF-8 going into a native StringType goes through decode_utf8_spark_lossy
An aggregate merges partial states in Spark's order of operations, not just with Spark's
buffer layout. A different floating-point order fails Spark's exact checks, such as m2 == 0,
when a constant is merged from several partitions (#6423).
Comparisons, grouping and set operations treat -0.0 and 0.0, and NaN payloads, as Spark
does, including inside arrays and structs. Where a DataFusion kernel treats them differently,
the serde falls back (#5507, #5701).
A TimestampType result is labelled "UTC", in return_type() or data_type() and in the
arrays the kernel builds. Not the session timezone, and not None.
Local-time work uses the session timezone from the proto. DataFusion's own datetime functions
take the timezone from the input's label, so wiring one in for a timezone-aware Spark
expression evaluates it in UTC unless the session timezone is passed explicitly.
A UTC fast path matches a fixed list of UTC aliases, as is_utc_timezone in
extract_date_part.rs does, and sends every other timezone ID down the general path
Before accepting a hand-written kernel, ask whether the function already exists upstream in
DataFusion or the datafusion-spark crate. Comet prefers wiring an upstream function over carrying
its own copy.
4. Tests
Expression tests should use Comet SQL Tests (CometSqlFileTestSuite) where possible. The
framework runs each query through both Spark and Comet and compares results, with no Scala code.
Fall back to Comet Scala Tests in CometExpressionSuite only when the SQL framework cannot express
the test, for example complex DataFrame setup or programmatic data generation.
Test location: spark/src/test/resources/sql-tests/expressions/<category>/, with categories
aggregate/, array/, string/, math/, struct/, map/, datetime/, hash/, and others.
statement
CREATE TABLE test_crc32(col string, a int, b float) USING parquet
statement
INSERT INTO test_crc32 VALUES ('Spark', 10, 1.5), (NULL, NULL, NULL), ('', 0, 0.0)
-- default mode: verifies native Comet execution and that the result matches Spark
query
SELECT crc32(col) FROM test_crc32
-- compares results without requiring native execution
query spark_answer_only
SELECT crc32(cast(a as string)) FROM test_crc32
-- allows numeric variance for floating-point results
query tolerance=0.0001
SELECT cos(v) FROM test_trig
-- asserts fallback to Spark occurs
query expect_fallback(unsupported expression)
SELECT unsupported_func(v) FROM test_table
-- verifies both engines throw matching exceptions
query expect_error(ARITHMETIC_OVERFLOW)
SELECT 2147483647 + 1
-- skip a query with a known bug, with the issue link
query ignore(https://github.com/apache/datafusion-comet/issues/NNNN)
SELECT known_buggy_expr(v) FROM test_table
Run the whole suite with -Dsuites="org.apache.comet.CometSqlFileTestSuite" -Dtest=none, or a
single file by appending a substring of its name to the suite argument.
Verify all test requirements, whichever framework is used:
Basic functionality tested against column data, not only literals
Both literal and column arguments tested, in every combination for multi-argument
expressions. They take different code paths.
Timestamp and datetime expressions are tested as "Testing timezone-sensitive code" in
timezones.md describes. That means several session timezones through ConfigMatrix,
including Etc/UTC and a zone with DST, both TIMESTAMP and TIMESTAMP_NTZ inputs, and a
result that is compared or fed to another expression rather than only projected.
SQL syntax gated with MinSparkVersion when it only parses on newer Spark
For a function from another project, such as an Iceberg transform, the expected values come
from that project's Java implementation, which is what Spark runs, not from iceberg-rust
(#6426)
A query ignore(...) for a result that differs from Spark comes with a fallback for that
case, so the divergence doesn't ship natively by default (#5701)
expect_error patterns substring-match what both Spark and Comet actually throw
For PRs that add a new native expression, performance is not optional. The point of a native
implementation is to be faster than Spark's codegen. If it is not faster, it may not be worth
carrying.
Does the PR description contain benchmark numbers comparing Comet against Spark? If not, ask for
them.
Does the PR add a benchmark under spark/src/test/scala/org/apache/spark/sql/benchmark/?
Are the benchmarks representative, with realistic data sizes and the data shapes that break
optimizations, such as nulls, dictionaries, and wide strings?
Does the Rust implementation allocate or copy more than it needs to, process row by row where a
kernel exists, redo type conversions, or revalidate UTF-8 repeatedly?
If a benchmark shows Comet slower than Spark, flag it. The PR needs to explain why that is
acceptable or include a plan to fix it.
For PRs optimizing an existing kernel, optimizing_expressions.md defines the no-regression rule
and the requirement to record a performance audit. Hold the PR to both.
6. Documentation
Generated, review the source instead
GenerateDocs fills in the expression compatibility tables and the config tables when the docs are
built, and CI rebuilds and publishes the docs when a merge changes their inputs. The Generated Content section of
docs/source/contributor-guide/style_guide.md says exactly which text is generated. Never ask the
contributor to hand-edit that text. Check what feeds it:
Expression marked Incompatible(Some("...")) but getIncompatibleReasons() is empty, so the
compat page shows it as supported with no caveats.
Unsupported(Some("...")) for specific types or argument shapes with no
getUnsupportedReasons() to surface the limitation.
Reason strings that drift from the notes passed to Compatible / Incompatible /
Unsupported. They need not match exactly, but consistency helps.
Reason strings too terse to be useful in user-facing docs: a single word, no context, no link to
a tracking issue when behavior is known to differ.
Hand-edited, the PR should update these
docs/source/user-guide/latest/expressions.md, the supported-expressions list. A new expression
belongs here.
Other latest/compatibility/ pages such as floating-point.md, regex.md, operators.md.
Does the PR make the contributor guide stale?
Check adding_a_new_expression.md against the diff. It goes stale when a PR:
Changes the CometExpressionSerde interface, the support-level API, or the
getIncompatibleReasons / getUnsupportedReasons contract
Adds or renames an expression map in QueryPlanSerde.scala, since the guide names them
Changes how the return type is resolved, which would invalidate the "when to set the return type
explicitly" section
Changes the shimming pattern or adds a Spark version to the set the guide lists
Changes how scalar functions are registered in comet_scalar_funcs.rs
Check sql-file-tests.md when the PR adds, renames, or changes a test directive. The directive
reference in that doc is the only place they are documented.
Common Expression Review Findings
Incomplete type support, Spark supports types the PR does not handle
Tests in the wrong framework, Scala tests where a SQL file test would do
Missing getSupportLevel, divergences left undeclared rather than marked Incompatible
Version-specific Spark behavior implemented once, with no shim or version check, or with a
protobuf field, native argument, or native function named for the Spark version
(spark_420_plus) instead of the behavior (wrap_second_millisecond_overflow)
Name collides with a DataFusion built-in and no explicit return type
Timestamp result mislabelled, with the session timezone or no timezone instead of "UTC".
It only shows once the result is compared or fed to another expression.
1---2name: review-comet-expression-pr3description: Use when reviewing a DataFusion Comet pull request that adds or changes a Spark expression, its Scala serde, its protobuf message, or its native Rust implementation. Load alongside review-comet-pr, which covers the parts of the review that apply to every PR.4argument-hint: <pr-number>5metadata:6 source: https://skillmd.com/skills/apache/review-comet-expression-pr7---89<!--10Licensed to the Apache Software Foundation (ASF) under one11or more contributor license agreements. See the NOTICE file12distributed with this work for additional information13regarding copyright ownership. The ASF licenses this file14to you under the Apache License, Version 2.0 (the15"License"); you may not use this file except in compliance16with the License. You may obtain a copy of the License at1718 http://www.apache.org/licenses/LICENSE-2.01920Unless required by applicable law or agreed to in writing,21software distributed under the License is distributed on an22"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY23KIND, either express or implied. See the License for the24specific language governing permissions and limitations25under the License.26-->2728Expression-specific review for Comet PR #$ARGUMENTS.2930**REQUIRED BACKGROUND:** Use `review-comet-pr` for PR metadata, existing comments, CI, the review31bar, and the output format. This skill only covers what is specific to expressions.3233## Read the Contributor Guide First3435| Doc | What you need from it |36| ---------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |37| `docs/source/contributor-guide/adding_a_new_expression.md` | The serde contract, support levels, when to set the return type explicitly, shimming |38| `docs/source/contributor-guide/sql-file-tests.md` | The test framework expression PRs are expected to use, and every directive it supports |39| `docs/source/contributor-guide/optimizing_expressions.md` | The benchmark workflow and the no-regression rule, for PRs that change an existing kernel |40| `docs/source/contributor-guide/timezones.md` | The timestamp label rule, where the session timezone comes from, and how to test it, for datetime expressions, casts, and anything that returns a timestamp |4142Hold the diff against these. If the PR does something a guide says to do differently, either the PR43is wrong or the guide is out of date, and you need to say which.4445## 1. Read the Spark Source4647**For any PR that adds or modifies an expression, you must read the Spark source to understand the48canonical behavior.** This is the authoritative reference for what Comet must match. Do not review49an expression PR from the diff alone.5051Clone Spark into `/tmp/spark` if it is not already there, using a shallow clone, then find the52expression class under `sql/catalyst/src/main/scala` by searching for its `case class` declaration.5354Read the Spark implementation carefully. Pay attention to:5556- `eval` and `doGenCode` / `nullSafeEval`. These define the exact behavior.57- `inputTypes` and `dataType`. These define which types Spark accepts and what it returns.58- Null handling. Does it use `nullable = true`? Does `nullSafeEval` handle nulls implicitly?59- Special cases, guards, and `require` assertions.60- ANSI mode branches, usually `SQLConf.get.ansiEnabled` or `failOnError`.61- Behavior differences across the Spark versions Comet supports. If the expression changed between62 3.5 and 4.0, the serde needs a shim, not a single implementation.6364Then read the Spark tests for the expression, under the test source trees in `sql/`.6566Compare Spark's behavior against the PR and identify edge cases Spark tests that the PR does not,67types Spark supports that the PR does not handle, and behavioral differences that should be marked68`Incompatible`.6970## 2. Scala Serde7172Location: `spark/src/main/scala/org/apache/comet/serde/`7374- [ ] Expression class correctly identified75- [ ] All child expressions converted via `exprToProtoInternal`76- [ ] Return type correctly serialized77- [ ] `getSupportLevel` reflects true compatibility rather than the happy path78- [ ] Serde lives in the appropriate file (`datetime.scala`, `strings.scala`, `arithmetic.scala`, and so on)79- [ ] ANSI and `fail_on_error` handling matches the constraints in `adding_a_new_expression.md`80- [ ] A change that routes a whole class of expressions to the JVM codegen dispatcher lists the new81 shapes it admits and tests one of each, including decimal results whose scale differs from the82 declared type and boolean inputs from sliced batches (#6424, #6425)83- [ ] A timezone-aware expression serializes `CometTimeZone.nativeId(expr.timeZoneId)`, the84 timezone Spark stamped on it in a form native code can parse, rather than85 `SQLConf.get.sessionLocalTimeZone` or the JVM default, and returns86 `CometTimeZone.supportLevel` from `getSupportLevel` when `nativeId` gives `None`8788### Registration in `QueryPlanSerde.scala`8990- [ ] Added to the correct map (temporal, string, arithmetic, and so on)91- [ ] No duplicate registrations92- [ ] Import statement added9394### Return type collisions with DataFusion built-ins9596If the PR registers a Spark function whose name is also defined by `datafusion-functions`, such as97`levenshtein`, `concat`, `coalesce`, `sha2`, or `regexp_replace`, check that the serde sets the98return type explicitly via `scalarFunctionExprToProtoWithReturnType` rather than99`scalarFunctionExprToProto` or the bare `CometScalarFunction(name)` shortcut.100101Without an explicit return type the native planner consults DataFusion's UDF registry first for102type resolution, and any arity or input-type difference between the Spark and DataFusion versions103fails native execution with `Error from DataFusion: Function 'X' expects N arguments but received104M`. The Comet UDF is only swapped in after DataFusion's signature validation passes. See "When to105set the return type explicitly" in `adding_a_new_expression.md`.106107## 3. Rust Implementation108109Location: `native/spark-expr/src/`, registered in `comet_scalar_funcs.rs`.110111- [ ] Matches DataFusion and Arrow conventions112- [ ] Null handling is correct, including nulls inside nested types113- [ ] No panics. Use `Result`.114- [ ] Batch operations rather than row-by-row where a kernel exists115- [ ] Invalid UTF-8 going into a native `StringType` goes through `decode_utf8_spark_lossy`116- [ ] An aggregate merges partial states in Spark's order of operations, not just with Spark's117 buffer layout. A different floating-point order fails Spark's exact checks, such as `m2 == 0`,118 when a constant is merged from several partitions (#6423).119- [ ] Comparisons, grouping and set operations treat `-0.0` and `0.0`, and NaN payloads, as Spark120 does, including inside arrays and structs. Where a DataFusion kernel treats them differently,121 the serde falls back (#5507, #5701).122- [ ] A `TimestampType` result is labelled `"UTC"`, in `return_type()` or `data_type()` and in the123 arrays the kernel builds. Not the session timezone, and not `None`.124- [ ] Local-time work uses the session timezone from the proto. DataFusion's own datetime functions125 take the timezone from the input's label, so wiring one in for a timezone-aware Spark126 expression evaluates it in UTC unless the session timezone is passed explicitly.127- [ ] A UTC fast path matches a fixed list of UTC aliases, as `is_utc_timezone` in128 `extract_date_part.rs` does, and sends every other timezone ID down the general path129130Before accepting a hand-written kernel, ask whether the function already exists upstream in131DataFusion or the `datafusion-spark` crate. Comet prefers wiring an upstream function over carrying132its own copy.133134## 4. Tests135136**Expression tests should use Comet SQL Tests (`CometSqlFileTestSuite`) where possible.** The137framework runs each query through both Spark and Comet and compares results, with no Scala code.138Fall back to Comet Scala Tests in `CometExpressionSuite` only when the SQL framework cannot express139the test, for example complex `DataFrame` setup or programmatic data generation.140141Test location: `spark/src/test/resources/sql-tests/expressions/<category>/`, with categories142`aggregate/`, `array/`, `string/`, `math/`, `struct/`, `map/`, `datetime/`, `hash/`, and others.143144```sql145statement146CREATE TABLE test_crc32(col string, a int, b float) USING parquet147148statement149INSERT INTO test_crc32 VALUES ('Spark', 10, 1.5), (NULL, NULL, NULL), ('', 0, 0.0)150151-- default mode: verifies native Comet execution and that the result matches Spark152query153SELECT crc32(col) FROM test_crc32154155-- compares results without requiring native execution156query spark_answer_only157SELECT crc32(cast(a as string)) FROM test_crc32158159-- allows numeric variance for floating-point results160query tolerance=0.0001161SELECT cos(v) FROM test_trig162163-- asserts fallback to Spark occurs164query expect_fallback(unsupported expression)165SELECT unsupported_func(v) FROM test_table166167-- verifies both engines throw matching exceptions168query expect_error(ARITHMETIC_OVERFLOW)169SELECT 2147483647 + 1170171-- skip a query with a known bug, with the issue link172query ignore(https://github.com/apache/datafusion-comet/issues/NNNN)173SELECT known_buggy_expr(v) FROM test_table174```175176Run the whole suite with `-Dsuites="org.apache.comet.CometSqlFileTestSuite" -Dtest=none`, or a177single file by appending a substring of its name to the suite argument.178179**Verify all test requirements, whichever framework is used:**180181- [ ] Basic functionality tested against column data, not only literals182- [ ] Null handling tested183- [ ] Edge cases tested: empty input, overflow, boundary values, negative values184- [ ] Both literal and column arguments tested, in every combination for multi-argument185 expressions. They take different code paths.186- [ ] Timestamp and datetime expressions are tested as "Testing timezone-sensitive code" in187 `timezones.md` describes. That means several session timezones through `ConfigMatrix`,188 including `Etc/UTC` and a zone with DST, both `TIMESTAMP` and `TIMESTAMP_NTZ` inputs, and a189 result that is compared or fed to another expression rather than only projected.190- [ ] SQL syntax gated with `MinSparkVersion` when it only parses on newer Spark191- [ ] For a function from another project, such as an Iceberg transform, the expected values come192 from that project's Java implementation, which is what Spark runs, not from iceberg-rust193 (#6426)194- [ ] A `query ignore(...)` for a result that differs from Spark comes with a fallback for that195 case, so the divergence doesn't ship natively by default (#5701)196- [ ] `expect_error` patterns substring-match what both Spark and Comet actually throw197- [ ] One expression per SQL file198- [ ] Comet Scala literal tests disable constant folding:199200```scala201withSQLConf(SQLConf.OPTIMIZER_EXCLUDED_RULES.key ->202 "org.apache.spark.sql.catalyst.optimizer.ConstantFolding") {203 checkSparkAnswerAndOperator("SELECT func(literal)")204}205```206207## 5. Performance208209**For PRs that add a new native expression, performance is not optional.** The point of a native210implementation is to be faster than Spark's codegen. If it is not faster, it may not be worth211carrying.2122131. Does the PR description contain benchmark numbers comparing Comet against Spark? If not, ask for214 them.2152. Does the PR add a benchmark under `spark/src/test/scala/org/apache/spark/sql/benchmark/`?2163. Are the benchmarks representative, with realistic data sizes and the data shapes that break217 optimizations, such as nulls, dictionaries, and wide strings?2184. Does the Rust implementation allocate or copy more than it needs to, process row by row where a219 kernel exists, redo type conversions, or revalidate UTF-8 repeatedly?2205. If a benchmark shows Comet slower than Spark, flag it. The PR needs to explain why that is221 acceptable or include a plan to fix it.222223For PRs optimizing an existing kernel, `optimizing_expressions.md` defines the no-regression rule224and the requirement to record a performance audit. Hold the PR to both.225226## 6. Documentation227228### Generated, review the source instead229230`GenerateDocs` fills in the expression compatibility tables and the config tables when the docs are231built, and CI rebuilds and publishes the docs when a merge changes their inputs. The **Generated Content** section of232`docs/source/contributor-guide/style_guide.md` says exactly which text is generated. Never ask the233contributor to hand-edit that text. Check what feeds it:234235- Expression marked `Incompatible(Some("..."))` but `getIncompatibleReasons()` is empty, so the236 compat page shows it as supported with no caveats.237- `Unsupported(Some("..."))` for specific types or argument shapes with no238 `getUnsupportedReasons()` to surface the limitation.239- Reason strings that drift from the `notes` passed to `Compatible` / `Incompatible` /240 `Unsupported`. They need not match exactly, but consistency helps.241- Reason strings too terse to be useful in user-facing docs: a single word, no context, no link to242 a tracking issue when behavior is known to differ.243244### Hand-edited, the PR should update these245246- `docs/source/user-guide/latest/expressions.md`, the supported-expressions list. A new expression247 belongs here.248- Other `latest/compatibility/` pages such as `floating-point.md`, `regex.md`, `operators.md`.249250### Does the PR make the contributor guide stale?251252Check `adding_a_new_expression.md` against the diff. It goes stale when a PR:253254- Changes the `CometExpressionSerde` interface, the support-level API, or the255 `getIncompatibleReasons` / `getUnsupportedReasons` contract256- Adds or renames an expression map in `QueryPlanSerde.scala`, since the guide names them257- Changes how the return type is resolved, which would invalidate the "when to set the return type258 explicitly" section259- Changes the shimming pattern or adds a Spark version to the set the guide lists260- Changes how scalar functions are registered in `comet_scalar_funcs.rs`261262Check `sql-file-tests.md` when the PR adds, renames, or changes a test directive. The directive263reference in that doc is the only place they are documented.264265## Common Expression Review Findings2662671. **Incomplete type support**, Spark supports types the PR does not handle2682. **Missing edge cases**, null, overflow, empty string, negative values2693. **Wrong return type**, it must match Spark exactly2704. **Tests in the wrong framework**, Scala tests where a SQL file test would do2715. **Missing `getSupportLevel`**, divergences left undeclared rather than marked `Incompatible`2726. **Version-specific Spark behavior implemented once**, with no shim or version check, or with a273 protobuf field, native argument, or native function named for the Spark version274 (`spark_420_plus`) instead of the behavior (`wrap_second_millisecond_overflow`)2757. **Name collides with a DataFusion built-in** and no explicit return type2768. **Timestamp result mislabelled**, with the session timezone or no timezone instead of `"UTC"`.277 It only shows once the result is compared or fed to another expression.
Run npx get-skill add apache/review-comet-expression-pr in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.
Use when reviewing a DataFusion Comet pull request that adds or changes a Spark expression, its Scala serde, its protobuf message, or its native Rust implementation. Load alongside review-comet-pr, which covers the parts of the review that apply to every PR. It is listed under Coding & Dev Tools on SkillMD.
This skill has not completed SkillMD's automated safety review yet. Capability flags: docs only. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.
This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.
Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.
apache (@apache) published this skill. Their other Agent Skills are listed on their SkillMD profile.