CtrlK
BlogDocsLog inGet started
Tessl Logo
SkillPublic

authoring-language-sdk-tasks

The language-neutral foundation for Airflow language SDKs — implement task logic in a non-Python language while the DAG stays in Python. Use when the user wants to run an Airflow task in another language (Java, Kotlin, Go, or other JVM/native languages), asks how the Python `@task.stub` pairs with native task code, how task/DAG IDs must match across the two sides, how data passes via XCom as JSON, or which language SDKs exist. This skill owns the shared Python-stub pattern and conceptual model; for a specific language's native API, build, and runtime, use that language's skill (e.g. authoring-java-sdk-tasks, authoring-go-sdk-tasks).

75

Quality

94%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

Passed

No findings from the security scan

SKILL.md
Quality
Evals
Security

Quality

Content

86%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

A well-executed shared-foundation skill: a runnable stub example, precise rules with enforcement details (AST check, ValueError on retry_policy), a clean JSON contract table, and rigorous delegation of language-specific content to named sibling skills. The only flaws are minor: the queue-to-coordinator rule is repeated three times and there are no explicit pre-deploy validation checkpoints.

Suggestions

State the queue_to_coordinator requirement once (e.g., in the rules list) and drop the duplicate mention in the prose above the example and the inline code comment.

Add a short pre-deploy validation step in the pitfalls section, e.g. 'before deploying, confirm the native task/DAG IDs exactly match the stub function and @dag names — mismatches only surface at runtime as "no DAGs" or missing-XCom errors'.

DimensionReasoningScore

Conciseness

The body is lean and assumes competence — no space is spent on what Airflow, JSON, or subprocesses generically are; sections like 'The model' deliver dense, skill-specific facts. However, the queue-routing point ('the same string must appear in queue_to_coordinator') is made three times (prose at the top of the Python-side section, the code comment, and the rules bullet), which is trimmable repetition. Not 5: the anchor-5 example has zero redundancy; not 3: the rest is efficient with only these minor over-explanations.

4 / 5

Actionability

The Python stub example is complete and copy-paste ready (imports, decorators, dependency wiring, an ordinary downstream task), and the pitfalls section gives executable specifics: 'only pass, ..., or a docstring is allowed in the body', '@task.stub raises ValueError' for retry_policy, and mismatch symptoms ('no DAGs' or missing-XCom errors). The native half is deliberately delegated to named per-language skills, which is an explicit, justified scope split rather than a gap. Not 4: there is no missing detail within the skill's declared scope.

5 / 5

Workflow Clarity

This is a conceptual/shared-foundation skill rather than a multi-step procedure, and its explanatory sequence is coherent (model → two-sided pattern → data contract → what lives elsewhere → pitfalls), with error-symptom feedback ('mismatches surface as "no DAGs" or missing-XCom errors'). Not 5: there is no explicit validation checkpoint (e.g., 'verify stub and native IDs match before deploying') or validate-then-proceed loop, which the anchor-5 example requires. Not 3: the failure modes and their symptoms are stated, so validation guidance is more than implicit.

4 / 5

Progressive Disclosure

No bundle files exist (no references/, scripts/, or assets/), and none are needed: the body stays at overview level and pushes per-language detail to clearly named one-level-deep sibling skills ('authoring-java-sdk-tasks', 'authoring-go-sdk-tasks', 'configuring-airflow-language-sdks', deploy skills), each listed with a one-line scope summary under 'Per-language skills' and 'Related Skills'. Navigation is easy and the split is exactly along the shared/language-specific boundary. Not 4: every out-of-scope topic has a clearly signaled destination, with no buried references or inlined content that belongs elsewhere.

5 / 5

Total

18

/

20

Passed

Description

100%Weight 40%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

An excellent description: it states what the skill covers, gives five concrete 'use when' triggers with natural vocabulary, and explicitly disambiguates against sibling per-language skills. Third-person voice is used throughout with no padding.

DimensionReasoningScore

Specificity

The description names multiple concrete capabilities: 'implement task logic in a non-Python language while the DAG stays in Python', how '@task.stub' pairs with native code, how 'task/DAG IDs must match across the two sides', and how 'data passes via XCom as JSON'. It also explicitly carves its scope (owns the shared Python-stub pattern, delegates native API/build/runtime to per-language skills), which is comprehensive for this skill's role. Not 4: coverage has no real gaps — every listed capability is specific and concrete, matching the anchor-5 example that lists several specific actions.

5 / 5

Completeness

It explicitly answers both questions: 'what' is stated up front (the language-neutral foundation, stub pattern, conceptual model) and 'when' via a concrete 'Use when the user wants to run an Airflow task in another language..., asks how the Python @task.stub pairs with native task code..., how task/DAG IDs must match..., how data passes via XCom as JSON, or which language SDKs exist'. Both are concrete, matching the anchor-5 example structure exactly. Not 4: the 'when' clause is not merely present — it enumerates five specific trigger scenarios.

5 / 5

Trigger Term Quality

Natural trigger phrases a user would actually say are covered comprehensively with synonyms: 'run an Airflow task in another language', 'non-Python language', 'Java, Kotlin, Go, or other JVM/native languages', '@task.stub', 'XCom as JSON', 'task/DAG IDs must match'. These span the vocabulary users would use when asking about this feature. Not 4: there is no common phrasing in this domain noticeably missing; the description enumerates both casual ('another language') and technical ('JVM/native') variations.

5 / 5

Distinctiveness Conflict Risk

The description actively prevents mis-triggering: 'This skill owns the shared Python-stub pattern and conceptual model; for a specific language's native API, build, and runtime, use that language's skill (e.g. authoring-java-sdk-tasks, authoring-go-sdk-tasks)'. Its triggers (stub pattern, ID matching, XCom-as-JSON, which language SDKs exist) are distinct from general DAG authoring and from per-language skills. Not 4: the overlap risk with the closest related skills is not just minor but explicitly resolved by the boundary statement.

5 / 5

Total

20

/

20

Passed

Validation

100%

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 16 / 16 Passed

Validation for skill structure

No warnings or errors.

Repository

astronomer/agents

Path

skills/authoring-language-sdk-tasks/SKILL.md

Reviewed

Table of Contents

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.