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.
52
58%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Advisory
Suggest reviewing before use
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/antigravity-awesome-skills-claude/skills/apify-actorization/SKILL.mdQuality
Discovery
40%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, making it distinctive. However, it reads more like a definition than a skill selection guide—it lacks explicit trigger guidance ('Use when...') and could list more concrete actions the skill performs. The specificity of capabilities is moderate, describing the general pattern rather than enumerating actionable steps.
Suggestions
Add an explicit 'Use when...' clause, e.g., 'Use when the user wants to convert a script or application into an Apify actor, deploy to the Apify platform, or create a serverless web scraper.'
List more concrete actions the skill performs, such as 'scaffolds actor project structure, configures input schema, writes Dockerfile, sets up Apify SDK integration, and defines output dataset schema.'
Include additional natural trigger terms users might say, such as 'web scraper', 'crawler', 'Apify SDK', 'deploy to Apify', 'convert to actor', or 'Apify Cloud'.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | The description names the domain (converting software to Apify actors) and describes the general concept (Docker images, JSON input/output), but doesn't list multiple specific concrete actions like scaffolding, configuring input schemas, writing Dockerfiles, etc. | 2 / 3 |
Completeness | The description explains what actorization is (the 'what'), 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 since the 'when' is entirely absent, this scores a 1. | 1 / 3 |
Trigger Term Quality | Includes relevant terms like 'Apify', 'actors', 'serverless', 'Docker images', and 'JSON input/output', but misses common user variations like 'web scraper', 'crawler', 'Apify SDK', 'deploy to Apify', or 'convert script to actor'. | 2 / 3 |
Distinctiveness Conflict Risk | The description is highly specific to the Apify platform and the concept of 'actorization', which is a clear niche unlikely to conflict with other skills. Terms like 'Apify', 'actors', and the specific packaging pattern make it very distinguishable. | 3 / 3 |
Total | 8 / 12 Passed |
Implementation
77%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 guide with strong actionability and workflow clarity, featuring concrete commands, checklists, and validation steps throughout. The main weaknesses are moderate verbosity (some sections explain things Claude already knows or could be trimmed) and a progressive disclosure structure that references files not confirmed to exist in the bundle, plus some organizational inconsistencies like reused step numbers.
Suggestions
Remove the 'When to Use This Skill' and 'Limitations' sections — Claude can infer applicability, and the limitations are generic boilerplate that wastes tokens.
Fix the step numbering inconsistency: Steps 4-6 are grouped for schemas, but then 'Step 4: Test Locally' and 'Step 5: Deploy' reuse numbers, which is confusing. Renumber to Steps 7 and 8 to match the checklist.
| 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 explaining how to log in is somewhat verbose but arguably necessary for a multi-step workflow. | 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 checklists and step-by-step commands are copy-paste ready. | 3 / 3 |
Workflow Clarity | Clear 8-step sequenced workflow with an explicit checklist, validation steps (schema validation against @apify/json_schemas, local testing with apify run before deployment), and a comprehensive pre-deployment checklist that serves as a final verification gate before the destructive 'push' operation. | 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 SKILL.md itself is moderately long with some content (monetization, resources, limitations) that could be in separate references. The step numbering is also inconsistent (Steps 4-6 grouped, then Step 4 and Step 5 reused for Test and Deploy). | 2 / 3 |
Total | 10 / 12 Passed |
Validation
90%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
- sickn33/antigravity-awesome-skills
- Commit
0839f85
- 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.