apify-actorization

Actorization converts existing software into reusable serverless applications compatible with the Apify platform. Actors are programs packaged as Docker images that accept well-defined JSON input, perform an action, and optionally produce structured JSON output.

Quality

58%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Medium

Suggest reviewing before use

Fix and improve this skill with Tessl

tessl review fix ./skills/apify-actorization/SKILL.md

Quality

Content

77%Scale 1-3

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

This is a well-structured actorization skill with clear sequential workflow, actionable commands, and good use of checklists for validation. Its main weaknesses are moderate verbosity (some sections like 'When to Use This Skill' and 'Limitations' add little value for Claude) and the inability to verify referenced bundle files. The progressive disclosure pattern is well-designed but the main file could be leaner by moving some detailed content to references.

Suggestions

Remove the 'When to Use This Skill' and 'Limitations' sections — Claude can infer applicability, and the limitations are generic boilerplate that waste tokens.

Trim the prerequisites section: the detailed login flow (checking env vars, generating tokens, avoiding command history) is overly prescriptive for Claude and could be condensed to 'Ensure apify CLI is installed and logged in (apify info to verify).'

Dimension	Reasoning	Score
Conciseness	Generally efficient but includes some unnecessary content like the 'When to Use This Skill' section (Claude can infer this), the 'Limitations' boilerplate at the end, and some explanatory text that could be trimmed. The prerequisites section is somewhat verbose with login instructions.	2 / 3
Actionability	Provides concrete, executable commands throughout (apify init, apify run with specific flags, apify push), a quick reference table with exact SDK calls, and specific file paths. The checklist format makes steps copy-paste actionable.	3 / 3
Workflow Clarity	Clear 8-step sequential workflow with an explicit checklist, a pre-deployment validation checklist, and specific validation steps (schema validation against @apify/json_schemas, testing with apify run before deploying). The important note about using 'apify run' instead of direct execution serves as a guardrail.	3 / 3
Progressive Disclosure	Good structure with references to language-specific files (js-ts-actorization.md, python-actorization.md, cli-actorization.md, schemas-and-output.md), but no bundle files were provided to verify these exist. The main file itself is fairly long (~150 lines) and some content like monetization details and the full pre-deployment checklist could potentially be in reference files.	2 / 3
	Total	10 / 12 Passed

Description

40%Scale 1-3

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

The description clearly identifies a specific niche (Apify actor creation) and explains the concept well, but reads more like a definition than a skill selection guide. It lacks explicit trigger guidance ('Use when...') and could benefit from listing more concrete actions and natural user-facing keywords.

Suggestions

Add an explicit 'Use when...' clause, e.g., 'Use when the user wants to convert code into an Apify actor, deploy a scraper to Apify, or package software as a serverless actor.'

Include natural trigger terms users would say, such as 'web scraper', 'crawler', 'Apify SDK', 'deploy to Apify', 'convert to actor', or 'Apify platform'.

List more specific concrete actions, e.g., 'Generates Dockerfile, configures input schema, sets up Apify actor metadata, and structures output datasets.'

Dimension	Reasoning	Score
Specificity	The description names the domain (converting software to Apify actors) and describes some actions (packaging as Docker images, accepting JSON input, producing JSON output), but doesn't list multiple concrete actions like migration steps, testing, deployment, or configuration.	2 / 3
Completeness	The description explains what actorization is (converting software into Apify-compatible actors), but completely lacks a 'Use when...' clause or any explicit trigger guidance for when Claude should select this skill. Per the rubric, a missing 'Use when...' clause caps completeness at 2, and the 'when' is not even implied clearly, warranting a 1.	1 / 3
Trigger Term Quality	Includes relevant keywords like 'Apify', 'actors', 'serverless', 'Docker images', 'JSON input/output', but misses common user variations like 'web scraper', 'crawler', 'Apify SDK', 'deploy to Apify', or 'convert to actor'. The term 'actorization' is domain-specific jargon that users may not naturally use.	2 / 3
Distinctiveness Conflict Risk	The description targets a very specific niche — converting software to Apify platform actors — which is highly distinctive and unlikely to conflict with other skills. The combination of 'Apify', 'actors', and 'actorization' creates a clear, unique identity.	3 / 3
	Total	8 / 12 Passed

Validation

90%

Warnings & errors only

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

Validation — 10 / 11 Passed

Validation for skill structure

Criteria	Description	Result
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	10 / 11 Passed

Repository: popey/claude-code-skills
Path: skills/apify-actorization/SKILL.md
Commit: a5a6601

Reviewed: 5 days ago

Table of Contents

Discovery Implementation Validation

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.