fix: update vendored skills to latest versions#262
fix: update vendored skills to latest versions#262pleaseai-release-bot[bot] wants to merge 1 commit into
Conversation
pleaseai-release-bot
Bot
added
the
dependencies
|
PR author is in the excluded authors list. |
|
The latest updates on your projects. Learn more about Vercel for GitHub.
|
Up to standards ✅🟢 Issues
|
| Metric | Results |
|---|---|
| Duplication | 10 |
NEW Get contextual insights on your PRs based on Codacy's metrics, along with PR and Jira context, without leaving GitHub. Enable AI reviewer
TIP This summary will be updated as you push new changes.
🔍 Tessl Skill Review
|
| Dimension | Score | Detail |
|---|---|---|
| conciseness | █░░ 1/3 | The skill is extremely verbose at ~200+ lines of body content. It repeats marketplace rules, policy defaults, and behavioral constraints multiple times across sections (Quick Start, Marketplace workflow, Required behavior). Much of this is redundant with what the scripts already enforce and what Claude can infer. The deeplink instructions, marketplace name rules, and policy value enumerations are stated 2-3 times each. |
| actionability | ███ 3/3 | The skill provides fully executable bash commands with concrete flags, specific file paths, and copy-paste ready JSON examples for both plugin manifests and marketplace entries. Every step has a concrete command or script invocation with clear arguments. |
| workflow clarity | ███ 3/3 | The Quick Start section provides a clear numbered sequence (scaffold → edit → marketplace → optional folders → validate). Validation is explicitly called out as a required step before handing back a plugin. The update flow in the referenced document includes explicit feedback loops (cachebuster → read name → reinstall → new thread). |
| progressive disclosure | ██░ 2/3 | References to references/plugin-json-spec.md and references/installing-and-updating.md are well-signaled and one level deep. However, the SKILL.md itself contains enormous amounts of inline detail (full marketplace JSON schemas, all policy values, deeplink construction rules, marketplace generation rules) that duplicate what's already in the reference files, defeating the purpose of progressive disclosure. |
Overall: The skill is highly actionable with executable commands, concrete JSON examples, and clear validation steps, making it easy for Claude to follow the workflow. However, it suffers significantly from verbosity—marketplace rules, policy defaults, and behavioral constraints are repeated across multiple sections and also duplicated from reference files. The content would benefit greatly from consolidating redundant rules and trusting the reference files and scripts to carry the detailed specifications.
Suggestions:
- Remove duplicated marketplace JSON schemas and policy value enumerations from the SKILL.md body since they already exist in
references/plugin-json-spec.md—replace with a brief summary and a reference link. - Consolidate the 'Marketplace workflow' and 'Required behavior' sections, which repeat many of the same rules (e.g., policy defaults, --marketplace-name usage, displayName placement) into a single concise section.
- Move the deeplink construction rules (View/Share URLs, query parameter restrictions) into a reference file or collapse them into 2-3 lines instead of the current ~15 lines of instructions.
- Remove explanations of what scripts already enforce (e.g., name normalization rules are implemented in create_basic_plugin.py and don't need full re-specification in the body).
agent/skills/plugin-creator/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/better-auth/.agents/skills/better-auth-best-practices/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | Generally efficient and well-organized with tables and short descriptions, but some sections like Session Management, User & Account Config, and Security include explanatory detail that could be trimmed. The skill avoids explaining basic concepts but has some redundancy (e.g., env vars mentioned in both setup and quick reference). |
| actionability | ██░ 2/3 | The setup workflow provides concrete CLI commands and a verification step, which is good. However, the core config sections are mostly descriptive option listings rather than executable code examples. The auth.ts creation (step 3) lacks a concrete code example, and most sections describe what options exist rather than showing copy-paste ready configurations. |
| workflow clarity | ███ 3/3 | The setup workflow is clearly sequenced with numbered steps, branching paths for different adapters (Drizzle vs Prisma vs built-in), and an explicit verification checkpoint (GET /api/auth/ok). The 'Re-run after adding/changing plugins' note serves as a validation reminder. The Common Gotchas section acts as an error-recovery guide. |
| progressive disclosure | ██░ 2/3 | The content is well-structured with clear section headers and a logical flow from setup to advanced topics. However, for a skill of this length (~180 lines), some sections like Security, Hooks, and Plugins could be split into separate reference files. External links to docs are provided but no bundle files exist to offload detailed content. |
Overall: This is a solid reference-style skill that covers Better Auth comprehensively with good workflow clarity and a useful gotchas section. Its main weaknesses are the lack of executable code examples for core configuration (the auth.ts setup step is described but not shown) and the monolithic structure that could benefit from splitting detailed sections into separate files. The content is reasonably concise but could be tightened in places.
Suggestions:
- Add a concrete, copy-paste ready auth.ts code example showing database adapter setup, emailAndPassword config, and at least one plugin — this is the most critical missing actionable element.
- Add a concrete route handler example for at least one framework (e.g., Next.js) since step 4 of the workflow just says 'Create route handler' without showing how.
- Consider splitting detailed reference sections (Hooks, Security, Plugins, Session Management) into separate bundle files and linking to them from the main SKILL.md to improve progressive disclosure.
plugins/better-auth/.agents/skills/organization-best-practices/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill is mostly efficient with good code examples, but includes some unnecessary explanations (e.g., 'For client-side member additions, use the invitation system instead') and the complete configuration example at the end largely repeats earlier content. Some sections like Security Considerations explain concepts Claude would already understand (e.g., what invitation expiry means). |
| actionability | ███ 3/3 | Nearly every section includes fully executable, copy-paste ready TypeScript code examples with realistic parameters. The code covers server setup, client setup, CRUD operations, configuration options, hooks, and schema customization — all concrete and specific. |
| workflow clarity | ██░ 2/3 | The setup section has a clear 4-step sequence with a verification checkpoint ('Verify: check that tables exist'). However, multi-step workflows like ownership transfer before removal, or the invitation flow (create → send email → accept), lack explicit validation/feedback loops. The owner protection section shows the correct sequence but doesn't include error handling or verification steps. |
| progressive disclosure | ██░ 2/3 | The content is well-organized with clear section headers and logical grouping, but it's a monolithic ~300-line document with no references to external files. Topics like lifecycle hooks, schema customization, and the complete configuration example could be split into separate reference files to keep the main skill leaner. |
Overall: This is a comprehensive, highly actionable skill with excellent executable code examples covering the full Better Auth organization plugin API. Its main weaknesses are its length (could benefit from splitting advanced topics into referenced files) and some missing validation/feedback loops in multi-step workflows like setup migration and ownership transfer. The content is well-structured but could be more concise by removing the redundant complete configuration example and trimming explanatory text.
Suggestions:
- Split advanced topics (lifecycle hooks, schema customization, dynamic access control, complete configuration example) into separate referenced files to reduce the main skill's token footprint.
- Add explicit validation/error-handling steps to multi-step workflows — e.g., after migration, verify tables exist before proceeding; after ownership transfer, confirm the new owner role before removing the old owner.
- Remove or significantly trim the 'Complete Configuration Example' section since it largely duplicates code already shown in individual sections.
plugins/better-auth/.agents/skills/two-factor-authentication-best-practices/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill is mostly efficient with good code examples, but includes some unnecessary elements like the BackupCodes React component (Claude knows how to render a list), the QR code component (trivial), and the complete configuration example at the end which largely duplicates earlier sections. Some inline comments restate what's already explained in prose. |
| actionability | ███ 3/3 | Fully executable code examples throughout — server config, client config, enable/disable 2FA, TOTP verification, OTP sending/verification, backup code generation, sign-in flow, and complete configuration. All examples are copy-paste ready with real imports and API calls. |
| workflow clarity | ███ 3/3 | The setup workflow has clear sequencing (add plugin → add client plugin → migrate → verify column exists). The sign-in flow is explicitly numbered with a clear 5-step sequence including the redirect check. The session management flow (credentials → session removed → temp cookie → verify → session created) is well-documented. The enable-then-verify lifecycle is clearly explained. |
| progressive disclosure | ██░ 2/3 | The content is well-organized with clear section headers and logical grouping, but it's a long monolithic document (~200 lines) with no references to external files. The complete configuration example at the end and some sections (like backup code display component) could be split out. However, with no bundle files provided, this is a standalone skill that manages its length reasonably through good heading structure. |
Overall: This is a solid, actionable skill with excellent executable code examples covering the full 2FA lifecycle in Better Auth. Its main weakness is moderate verbosity — some React components and the final complete configuration example add bulk without proportional value. The workflow sequencing is clear, especially for setup and sign-in flows.
Suggestions:
- Remove trivial React components (QRCode wrapper, BackupCodes list) — Claude knows how to render these patterns without examples.
- Remove or significantly trim the 'Complete Configuration Example' section, as it duplicates options already shown in individual sections.
plugins/better-auth/agent/skills/better-auth-best-practices/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/better-auth/agent/skills/organization-best-practices/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/better-auth/agent/skills/two-factor-authentication-best-practices/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/dev3000/.agents/skills/d3k/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill is mostly efficient and avoids explaining basic concepts, but some sections could be tightened. For example, the 'Browser and Auth Safety' section explains why not to use alternative browsers at length, and some operational rules repeat guidance already stated earlier (e.g., not starting a second d3k). |
| actionability | ███ 3/3 | The skill provides concrete, copy-paste-ready commands throughout—status checks, installation, startup flags, agent-browser interactions, evidence gathering, and error inspection. Every step has a specific executable command with clear flags and explanations of when to use them. |
| workflow clarity | ███ 3/3 | The multi-step workflows are clearly sequenced with explicit validation checkpoints: check status before starting, poll until ready, verify browserConnected before handing to user, and check errors after reproduction. The user-driven vs agent-driven paths are cleanly separated with distinct steps. Error recovery is addressed (inspect retained process output, restart cleanly if browser unavailable). |
| progressive disclosure | ██░ 2/3 | The content is well-organized with clear section headers and logical grouping, but it's a moderately long monolithic file with no references to supporting documents. Some sections like 'Browser and Auth Safety' and 'Operating Rules' could potentially be split out, though the skill is not excessively long. No bundle files are provided, so there's no external structure to leverage. |
Overall: This is a strong, actionable skill that provides clear executable commands and well-structured workflows for operating d3k. The separation of user-driven vs agent-driven testing paths is well done, and validation checkpoints are explicit throughout. Minor weaknesses include some redundancy in operating rules and the auth safety section being slightly verbose, plus the lack of any progressive disclosure to supporting files.
Suggestions:
- Trim the 'Browser and Auth Safety' section by removing the enumeration of specific alternative tools (Playwright, browser MCP session, manual CDP attachment) and condensing to a single directive about always using d3k's managed browser for auth flows.
- Remove duplicated guidance in 'Operating Rules' that restates instructions already given in earlier sections (e.g., not starting a second d3k, keeping d3k alive).
plugins/dev3000/agent/skills/d3k/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/lavish/.agents/skills/lavish/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill contains some redundancy (e.g., the 'When to use' section repeats information from the description and Commands section; the npx invocation pattern is explained multiple times). However, most content is genuinely instructive and specific to this tool's unique workflow. Some tightening is possible but it's not egregiously verbose. |
| actionability | ███ 3/3 | The skill provides specific, executable commands (npx -y lavish-axi , poll, end, export, share, playbook), clear fallback patterns for restricted environments, exact flag names (--agent-reply, --reopen, --password), and concrete file paths (.lavish/.html). Guidance is copy-paste ready. |
| workflow clarity | ███ 3/3 | The workflow section provides a clear numbered sequence with explicit validation checkpoints (poll for layout_warnings, fix error-severity findings before proceeding, re-poll after applying feedback). It includes feedback loops (apply feedback → poll again), error recovery (re-run if killed/timed out), and clear termination conditions (end command or user-ended session). |
| progressive disclosure | ██░ 2/3 | The skill references playbooks via npx -y lavish-axi playbook <id> and npx -y lavish-axi design for detailed guidance, which is good progressive disclosure. However, the main file itself is quite long (~100+ lines) with the Commands & rules section containing dense inline content that could benefit from better structural separation. No bundle files are provided to verify the playbook content exists. |
Overall: This is a well-crafted skill that provides highly actionable, specific guidance for a complex interactive workflow. Its main strengths are the clear workflow sequence with validation checkpoints and the concrete, executable commands throughout. Its weaknesses are moderate verbosity with some repeated information and a lengthy Commands & rules section that could be better organized or split out.
Suggestions:
- Consolidate the repeated npx invocation guidance (appears in intro, workflow, and commands sections) into a single 'Invocation' section to reduce redundancy.
- Consider moving the detailed 'Commands & rules' section to a separate reference file, keeping only the most critical rules inline and linking to the full reference.
plugins/lavish/agent/skills/lavish/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/prisma/.agents/skills/prisma-database-setup/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill is reasonably efficient but includes some redundancy—the driver adapter table and PostgreSQL example appear in the main body and are repeated in the reference files. The Quick Reference section duplicates schema configs that are already in the reference files. Some sections like 'When to Apply' and the priority table add marginal value. |
| actionability | ███ 3/3 | The skill provides fully executable code examples for driver adapter setup, schema configuration, CLI commands for installation and generation, and concrete connection string formats. The Prisma Client setup steps are copy-paste ready with specific install commands and TypeScript code. |
| workflow clarity | ██░ 2/3 | The Prisma Client Setup section provides a numbered sequence of steps, but there are no validation checkpoints—no step to verify the database connection works, no 'prisma db push' or migration step to confirm schema sync, and no error recovery guidance in the main workflow. For a setup process that can fail at multiple points (connection, generation, adapter instantiation), explicit verification steps are missing. |
| progressive disclosure | ███ 3/3 | The skill provides a clear overview with essential information inline, then points to well-organized, one-level-deep reference files for each database provider. The bundle structure matches the referenced paths exactly, and the 'How to Use' section clearly directs users to the right reference file for their database. |
Overall: This is a well-structured skill with strong progressive disclosure and actionable code examples across all supported databases. Its main weaknesses are some content redundancy between the overview and reference files, and a lack of validation/verification steps in the setup workflow (e.g., testing the connection after configuration). The MongoDB-specific guidance about staying on Prisma 6.x is a valuable, non-obvious piece of knowledge that earns its place.
Suggestions:
- Add a verification step after Prisma Client setup, such as running a simple query or
prisma db pushto confirm the connection works, with error recovery guidance if it fails. - Remove the Quick Reference schema blocks since they duplicate content already in the reference files—replace with a one-liner pointing to the appropriate reference file for each provider.
plugins/prisma/.agents/skills/prisma-upgrade-v7/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill is mostly efficient with good tables and code examples, but there's notable redundancy — the same migration steps appear in both the 'Step-by-Step Migration' section and the 'Quick Upgrade Commands' section, and the breaking changes summary table partially duplicates information found in the step-by-step guide. The 'When to Apply' and 'Rule Categories by Priority' sections add organizational overhead that could be trimmed. |
| actionability | ███ 3/3 | The skill provides fully executable code examples for every migration step — schema changes, config file creation, driver adapter installation and configuration, client instantiation, and import updates. Commands are copy-paste ready with concrete before/after comparisons. |
| workflow clarity | ██░ 2/3 | The 10-step migration overview provides a clear sequence, and individual steps have concrete code. However, there are no explicit validation checkpoints between steps (e.g., 'verify the generated client exists before updating imports') and no error recovery feedback loops. The troubleshooting section is at the end rather than integrated into the workflow. For a migration involving multiple destructive/breaking changes, this lack of validation gates is a gap. |
| progressive disclosure | ███ 3/3 | The SKILL.md provides a comprehensive overview with inline quick-start steps while clearly referencing 7 well-organized reference files for detailed coverage of each topic. References are one level deep, clearly listed with descriptions, and the bundle file listing confirms all referenced paths exist and are substantive. |
Overall: This is a well-structured migration guide with strong actionability — every step has executable code with clear before/after comparisons. The progressive disclosure is excellent, with a good overview-to-reference split. The main weaknesses are some redundancy between sections (hurting conciseness) and the lack of explicit validation checkpoints in the multi-step migration workflow, which is important for a breaking-change upgrade.
Suggestions:
- Add explicit validation checkpoints between migration steps (e.g., 'Run
npx prisma generateand verify the output directory exists before updating imports' or 'Runnpx tsc --noEmitto check for import errors after step 7'). - Reduce redundancy by removing the 'Quick Upgrade Commands' section or merging it into the step-by-step migration, since the same commands appear in both places.
plugins/prisma/agent/skills/prisma-database-setup/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/prisma/agent/skills/prisma-upgrade-v7/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/shadcn-ui/agent/skills/migrate-radix-to-base/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/shadcn-ui/agent/skills/shadcn/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/slidev/.agents/skills/slidev/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ███ 3/3 | The content is lean and well-structured. It avoids explaining what Slidev, Vite, Vue, or Markdown are. The quick start is minimal, the basic syntax example is just enough to get started, and the feature reference tables use compact inline usage snippets with links to details rather than inline explanations. |
| actionability | ███ 3/3 | Provides executable CLI commands (pnpm create slidev, pnpm run dev, pnpm run export), a complete copy-paste-ready markdown slide example, and concrete inline usage syntax for every feature in the reference tables. The export prerequisite note about playwright-chromium is a practical, specific detail. |
| workflow clarity | ███ 3/3 | The Quick Start section provides a clear sequence (create → dev → build → export) with explicit validation checkpoints ('confirm slides load at localhost:3030', 'check the output PDF exists'). The export prerequisite callout provides error recovery guidance. For a tool-usage skill like this, the workflow is appropriately clear. |
| progressive disclosure | ███ 3/3 | Exemplary progressive disclosure: concise overview with quick start and basic syntax inline, then organized reference tables with one-level-deep links to 50+ reference files. All referenced paths match the actual bundle file listing. Content is categorized into logical groups (Code & Editor, Diagrams & Math, Layout & Styling, etc.) for easy navigation. |
Overall: This is an excellent skill file that serves as a well-organized index into a comprehensive Slidev reference bundle. It provides just enough inline content (quick start commands, basic syntax example) to be immediately actionable, while efficiently delegating detailed feature documentation to one-level-deep reference files. The compact table format for feature references is particularly effective at maximizing information density.
plugins/slidev/agent/skills/slidev/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/tsdown/.agents/skills/tsdown/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The SKILL.md is quite long (~350 lines) with many code examples that are useful but somewhat repetitive. The 'When to Use' section and 'Runtime Requirement' explanation add some unnecessary verbosity for Claude, and the extensive tables duplicate information available in references. However, the code examples are lean and the tables serve as a quick lookup. |
| actionability | ███ 3/3 | Excellent actionability with fully executable code examples throughout - from Quick Start commands to complete configuration objects for every common pattern (React library, browser IIFE, WASM, CSS, executables, etc.). All examples are copy-paste ready with proper imports and complete config objects. |
| workflow clarity | ██░ 2/3 | For a library bundler skill, the workflow is relatively straightforward (configure → build → verify), but the skill lacks explicit validation checkpoints. There's no 'verify your output' step after building, no guidance on what to check if the build produces unexpected results, and the migration workflow mentions 'Test build' but doesn't specify what to validate. |
| progressive disclosure | ███ 3/3 | Excellent progressive disclosure with a clear overview in SKILL.md containing quick-start content, common patterns, and well-organized tables that link to 35+ detailed reference files. References are one level deep, clearly categorized (guide-, option-, advanced-, recipe-, reference-*), and the navigation tables make discovery easy. |
Overall: This is a well-structured skill with excellent actionability and progressive disclosure. The main SKILL.md serves as an effective overview with copy-paste-ready examples and clear navigation to detailed references. Its primary weakness is verbosity - the file could be trimmed by removing some redundant patterns and the explanatory 'When to Use' section - and it lacks explicit validation/verification steps in its workflows.
Suggestions:
- Trim the 'Common Patterns' section to 3-4 essential examples and move the rest to a references file (e.g., references/recipes-common.md) to reduce token usage
- Add a brief verification step after the Quick Start section (e.g., 'Verify: check dist/ contains expected .mjs/.cjs files and run
node dist/index.mjs') - Remove the 'When to Use' bullet list - Claude can infer when to use a library bundler from context
plugins/tsdown/agent/skills/tsdown/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/turborepo/.agents/skills/turborepo/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill is quite long with extensive anti-pattern examples that include both WRONG and CORRECT versions, which is valuable but verbose. Some sections like the root .env anti-pattern include explanations Claude could infer (e.g., 'Bad habits start small — starter templates should model correct patterns'). The decision trees are efficient, but the anti-patterns section could be tightened by removing redundant explanations. |
| actionability | ███ 3/3 | Every section provides concrete, copy-paste-ready JSON configurations with clear WRONG/CORRECT comparisons. The turbo.json examples, package.json scripts, CLI commands, and CI workflow snippets are all fully executable and specific. The decision trees provide precise file references for each scenario. |
| workflow clarity | ██░ 2/3 | The decision trees provide clear navigation for common scenarios, and the anti-patterns section sequences fixes well (e.g., the prebuild fix with conditional steps). However, there are no explicit validation checkpoints — for example, after configuring tasks or fixing anti-patterns, there's no 'verify with --dry or --summarize' step. For a build system where misconfigurations can silently produce incorrect caches, validation steps would be important. |
| progressive disclosure | ██░ 2/3 | The Reference Index at the bottom is excellent with well-organized tables pointing to one-level-deep reference files that match the actual bundle structure. However, the SKILL.md itself is very long (~500+ lines) with extensive inline anti-pattern content that could be moved to a separate references/configuration/gotchas.md or anti-patterns file. The decision trees effectively serve as navigation, but the main body contains too much detail that should be in reference files. |
Overall: This is a comprehensive and highly actionable Turborepo skill with excellent concrete examples and decision trees for common scenarios. Its main weaknesses are length (too much anti-pattern detail inline rather than in reference files) and missing validation/verification steps after configuration changes. The reference index and bundle structure are well-organized, but the SKILL.md tries to be both an overview and a detailed guide.
Suggestions:
- Move the extensive anti-patterns section (or at least the less critical ones like root .env, strict mode filtering, shared code in apps) to a reference file like references/configuration/gotchas.md, keeping only the top 3-4 most critical anti-patterns inline.
- Add validation checkpoints after key workflows, e.g., 'After configuring tasks, verify with
turbo run build --dryto confirm dependency ordering' or 'Useturbo run build --summarizeto verify cache inputs include expected env vars.' - Trim explanatory prose that Claude can infer — for example, the 'Problems with root .env' bullet list and 'Benefits of Package Configurations' list could be reduced to single-line comments in the code examples.
plugins/turborepo/agent/skills/turborepo/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/vercel-sandbox/.agents/skills/sandbox/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The content is comprehensive and mostly efficient for an SDK reference, but includes some unnecessary explanations (e.g., explaining what a Session is when the code is self-evident, explaining what persistent means after showing it). The sheer volume (~600+ lines) could be trimmed, though most content is actionable code examples rather than prose. |
| actionability | ███ 3/3 | Excellent actionability throughout — nearly every section provides fully executable TypeScript code examples that are copy-paste ready. Commands, imports, options, and patterns are all concrete and specific with real parameter values. |
| workflow clarity | ██░ 2/3 | While individual operations are clear, multi-step workflows like 'Build and Test Pattern' check exit codes but lack explicit validation/recovery loops. The document is more of an API reference than a workflow guide — steps are shown but checkpoints and error recovery paths are minimal (only basic exit code checks). |
| progressive disclosure | ██░ 2/3 | The content is a monolithic document with good section headers but no references to external files for detailed topics. The entire SDK reference, CLI reference, patterns, and limitations are all inline. Topics like network policy, multi-user, and snapshots could be split into separate referenced files for better organization. |
Overall: This is a highly actionable SDK reference with excellent executable code examples covering the full @vercel/sandbox API surface. Its main weaknesses are its monolithic structure (everything in one large file without progressive disclosure to sub-documents) and the lack of explicit validation/recovery workflows for multi-step operations. The content is slightly verbose for a skill file but most of the length comes from useful code examples rather than unnecessary prose.
Suggestions:
- Split detailed sections (Network Policy, Multi-User, Snapshots, CLI Reference) into separate referenced files and keep SKILL.md as a concise overview with links
- Add explicit validation checkpoints to multi-step patterns (e.g., verify sandbox is running before writing files, verify snapshot exists before forking)
- Remove the 'What changed in v2' section or move it to a separate MIGRATION.md — Claude doesn't need migration context to use the current API
plugins/vercel-sandbox/agent/skills/sandbox/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/vinext/.agents/skills/migrate-to-vinext/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ███ 3/3 | The content is lean and efficient throughout. It assumes Claude knows what ESM, CJS, package managers, and Next.js concepts are. Every section delivers actionable information without preamble or unnecessary explanation. The opening paragraph efficiently establishes context without over-explaining. |
| actionability | ███ 3/3 | The skill provides fully executable commands, concrete code examples (vite.config.ts, bash commands, wrangler.jsonc), specific before/after mappings for script replacement, and clear tables for package manager detection. Code is copy-paste ready and complete. |
| workflow clarity | ███ 3/3 | The migration is clearly sequenced across 5 phases with explicit checkpoints: verify project first (with STOP condition), check compatibility, attempt automated migration with fallback to manual, deploy optionally, then verify. Phase 2 explicitly notes it's non-destructive and to skip to Phase 4 on success. Phase 5 provides verification steps. The troubleshooting reference includes a verification checklist. |
| progressive disclosure | ███ 3/3 | The SKILL.md serves as a clear overview with well-signaled one-level-deep references to three supporting files: compatibility.md, config-examples.md, and troubleshooting.md. Each reference is contextually placed where needed. The bundle files contain appropriately detailed content that would bloat the main skill if inlined. |
Overall: This is an excellent skill that efficiently guides Claude through a complex multi-step migration process. It combines lean prose with concrete, executable examples, clear phase-based workflow with validation checkpoints, and well-structured progressive disclosure to supporting references. The anti-patterns section adds significant value by preventing common mistakes.
plugins/vinext/agent/skills/migrate-to-vinext/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/wordpress/.agents/skills/blueprint/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill is generally efficient and avoids explaining basic concepts Claude already knows (like what WordPress is), but it's quite long (~300+ lines) and some sections could be tightened. The resource reference table, steps reference, and common patterns sections are thorough but border on being a full API reference rather than a lean skill. However, most content is genuinely useful and non-obvious. |
| actionability | ███ 3/3 | Excellent actionability throughout — every step type includes complete, copy-paste-ready JSON examples. The common patterns section provides real-world executable blueprints. The common mistakes table gives specific wrong/right pairs. CLI commands for testing are concrete and complete. |
| workflow clarity | ███ 3/3 | The bundle creation workflow is clearly sequenced (create directory → write files → zip → reference in blueprint.json) with a full worked example. Testing workflows cover multiple scenarios (inline URL, CLI server, headless validation) with explicit gotchas like the --blueprint-may-read-adjacent-files flag. The shorthands-vs-steps ordering caveat is an important validation checkpoint. |
| progressive disclosure | ███ 3/3 | The skill is well-structured with a clear hierarchy: quick start template → top-level properties → resources → steps → patterns → mistakes → testing. It appropriately defers to external references (blueprint docs URL, JSON schema URL) for the complete API while covering the most common cases inline. No bundle files are needed for this self-contained reference skill. |
Overall: This is a high-quality skill that provides comprehensive, actionable guidance for WordPress Playground blueprints. Its greatest strengths are the executable JSON examples throughout, the thorough common mistakes table, and clear testing workflows. The only notable weakness is length — at 300+ lines it pushes the boundary of conciseness, though most content is genuinely non-obvious and earns its place.
plugins/wordpress/.agents/skills/wordpress-router/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ███ 3/3 | The skill is lean and efficient. Every section serves a clear purpose, there's no explanation of what WordPress is or how plugins work, and it assumes Claude's competence throughout. |
| actionability | ███ 3/3 | Provides a concrete script command to run (node skills/wp-project-triage/scripts/detect_wp_project.mjs), specific file paths to inspect on failure, and clear routing instructions. The escalation section even provides the exact question to ask. |
| workflow clarity | ███ 3/3 | The procedure is clearly sequenced (run triage → classify → route → apply guardrails), with verification steps (re-run triage after restructuring, run lint/test/build), failure mode debugging, and an escalation path for ambiguous cases. |
| progressive disclosure | ███ 3/3 | The SKILL.md serves as a concise overview and correctly delegates the detailed decision tree to references/decision-tree.md with a clear one-level-deep reference. The bundle structure confirms the referenced file exists and contains substantive routing logic. |
Overall: This is a well-crafted router skill that is concise, actionable, and well-structured. It provides a clear multi-step workflow with validation checkpoints, failure modes, and escalation paths. The progressive disclosure is excellent, keeping the main skill lean while delegating detailed routing logic to a single reference file.
plugins/wordpress/.agents/skills/wp-abilities-api/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill is mostly efficient but includes some unnecessary framing (e.g., 'Inputs required' section, some verbose preamble in steps). Phrases like 'Before deciding what to register, read references/domain-vs-projection.md — abilities live at the domain capability layer; MCP / Command Palette / REST exposure is a projection' explain concepts that could be stated more tersely. However, it avoids explaining basic WordPress or PHP concepts Claude already knows. |
| actionability | ██░ 2/3 | The skill provides a clear procedural structure with specific search patterns and configuration keys (e.g., 'meta.show_in_rest', hook names), but lacks executable code examples directly in the SKILL.md body. Most concrete guidance is delegated to reference files rather than shown inline. The procedure tells you what to do but relies heavily on 'see references/X.md' for the actual how-to code. |
| workflow clarity | ███ 3/3 | The procedure is clearly sequenced (6 numbered steps from confirming availability through JS consumption), includes a verification section with specific checks, and has a detailed failure modes/debugging section that serves as error-recovery guidance. The escalation section provides a clear fallback path. The workflow covers the full lifecycle from discovery through verification. |
| progressive disclosure | ███ 3/3 | Excellent progressive disclosure structure. The SKILL.md serves as a clear overview with well-signaled, one-level-deep references to 9 reference files covering specific topics (domain-vs-projection, grouping-heuristic, php-registration, error-code-vocabulary, etc.). References are contextually placed at the decision points where they're needed, and all referenced paths match actual bundle files. |
Overall: This is a well-structured skill with excellent progressive disclosure and workflow clarity. Its main weakness is that actionability suffers from heavy delegation to reference files — the SKILL.md body itself contains no executable code, relying entirely on references for concrete implementation details. Conciseness could be improved by trimming some explanatory framing that doesn't add decision-making value.
Suggestions:
- Add at least one inline executable code snippet for the most common operation (e.g., a minimal wp_register_ability call with meta.show_in_rest) so the skill body is actionable without requiring a reference file lookup.
- Tighten the 'Inputs required' section — the three bullet points could be folded into the procedure's prerequisites or removed entirely since Claude can infer these from context.
plugins/wordpress/.agents/skills/wp-block-development/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill is reasonably efficient but includes some unnecessary framing (e.g., 'When to use' section largely restates what the description already covers, and some steps have light explanatory padding like 'treat Inner Blocks as a first-class feature'). The apiVersion 3 section in the main body duplicates content from references/block-json.md. Overall mostly lean but could be tighter. |
| actionability | ██░ 2/3 | The skill provides concrete script commands (list_blocks.mjs, detect_wp_project.mjs) and references specific functions/patterns (useBlockProps, register_block_type_from_metadata), but lacks executable code examples inline. Most steps say 'Read: references/X.md' rather than showing copy-paste-ready code. The references themselves are also light on executable examples, mostly pointing to upstream docs. |
| workflow clarity | ███ 3/3 | The procedure is clearly numbered (steps 0-10) with a logical sequence from triage through creation, metadata, registration, rendering, attributes, deprecations, and verification. The verification section provides explicit checkpoints (block appears in inserter, no 'Invalid block', assets load correctly). Failure modes section provides debugging feedback loops. The workflow is well-structured for a complex multi-step process. |
| progressive disclosure | ███ 3/3 | Excellent progressive disclosure: the main SKILL.md serves as a clear overview with well-signaled one-level-deep references to specific reference files. Each 'Read:' pointer is clearly labeled and corresponds to an actual file in the bundle. Content is appropriately split—overview and procedure in the main file, details in references. Navigation is straightforward. |
Overall: This is a well-structured skill with excellent workflow clarity and progressive disclosure. The numbered procedure guides Claude through a complex domain with clear sequencing and verification steps, and references are well-organized across supporting files. The main weaknesses are some redundancy between the main body and reference files (especially apiVersion 3 content) and a lack of inline executable code examples—most actionable guidance is deferred to reference files that themselves mostly link to upstream docs.
Suggestions:
- Add at least one or two inline executable code snippets for the most common operations (e.g., a minimal block.json example, a register_block_type_from_metadata() PHP snippet) to improve actionability without requiring reference file lookups.
- Remove or significantly condense the apiVersion 3 explanation in the main body since it's duplicated in references/block-json.md—a single sentence with a pointer would suffice.
- Populate scripts/list_blocks.mjs with actual content, as it's currently empty and referenced as a key triage step.
plugins/wordpress/.agents/skills/wp-block-themes/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ███ 3/3 | The content is lean and efficient. It avoids explaining what block themes are or how WordPress works conceptually. Every section serves a clear purpose—triage, locate, modify, verify—without padding. |
| actionability | ██░ 2/3 | The skill provides concrete script commands for triage/detection and clear procedural steps, but lacks executable code examples (e.g., sample theme.json snippets, template HTML). Most actionable detail is deferred to reference files, and the main body is more directional than copy-paste ready. |
| workflow clarity | ███ 3/3 | The numbered procedure (steps 0–6) is clearly sequenced with logical progression from triage to verification. The verification section includes checks for user customization overrides, and the failure modes section provides a feedback loop for debugging. The style hierarchy is explicitly called out as a validation checkpoint. |
| progressive disclosure | ███ 3/3 | The skill is an excellent overview that delegates detailed content to well-organized, one-level-deep reference files. Each step clearly signals which reference to read, all referenced files exist in the bundle, and the references are appropriately sized and focused. |
Overall: This is a well-structured skill that effectively uses progressive disclosure to keep the main body concise while providing detailed guidance in reference files. The workflow is clearly sequenced with good triage, verification, and debugging sections. The main weakness is that the body itself lacks concrete executable examples (code snippets, sample JSON), relying heavily on references for actionable detail.
Suggestions:
- Add a small inline theme.json snippet in step 3 showing a common settings/styles change to make the main body more immediately actionable without requiring a reference file lookup.
plugins/wordpress/.agents/skills/wp-interactivity-api/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill is mostly efficient but includes some redundancy—server-side rendering details are covered both inline and in the referenced file, and some explanatory text (e.g., 'SEO benefits and faster perceived load time') could be trimmed since Claude understands these concepts. The 'When to use' section is useful but slightly verbose. |
| actionability | ███ 3/3 | The skill provides fully executable PHP and JSON code snippets, specific search terms for detection, concrete debugging steps, and clear commands. The code examples are copy-paste ready and cover both block.json and theme/plugin scenarios. |
| workflow clarity | ███ 3/3 | The procedure is clearly sequenced (detect → identify stores → server-side rendering → implement directives → build alignment → debug), with explicit verification steps, failure modes with specific remediation, and a debugging checklist. The feedback loop for hydration mismatches is well-defined. |
| progressive disclosure | ███ 3/3 | Content is well-structured with the main SKILL.md providing an overview and actionable essentials, while detailed references (server-side-rendering.md, directives-quickref.md, debugging.md) are clearly signaled and one level deep. The inline content appropriately summarizes what's expanded in references. |
Overall: This is a well-crafted skill with strong actionability, clear workflow sequencing, and good progressive disclosure through well-organized reference files. The main area for improvement is conciseness—some server-side rendering content is duplicated between the main skill and the reference file, and a few explanatory phrases could be trimmed. Overall, it provides excellent guidance for working with the WordPress Interactivity API.
Suggestions:
- Reduce duplication between the inline server-side rendering section (Step 3) and references/server-side-rendering.md—consider keeping only a brief example inline and pointing to the reference for the full treatment.
plugins/wordpress/.agents/skills/wp-performance/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ███ 3/3 | The skill is lean and well-structured. It avoids explaining what WordPress, caching, or profiling are. Every section serves a purpose, and the WordPress 6.9 section provides genuinely useful context Claude wouldn't inherently know. No unnecessary padding or concept explanations. |
| actionability | ███ 3/3 | Provides specific CLI commands (wp profile stage, wp doctor check, wp option list), concrete scripts to run (perf_inspect.mjs), exact flags and options, and clear fix patterns per bottleneck category. The guidance is copy-paste ready and executable. |
| workflow clarity | ███ 3/3 | The procedure is clearly numbered (0-6) with explicit guardrails at step 0, a deterministic diagnostic script at step 1, progressive deepening through steps 2-4, categorized fixes at step 5, and explicit verification at step 6 with baseline comparison. Includes feedback loops (re-run same measurement, fix and re-validate) and failure mode debugging. |
| progressive disclosure | ███ 3/3 | Excellent progressive disclosure: the main skill provides a clear overview and workflow, with each bottleneck category and tool pointing to specific reference files (all of which exist in the bundle). References are one level deep, clearly signaled with inline paths, and the bundle structure matches all referenced paths exactly. |
Overall: This is an exceptionally well-crafted skill that demonstrates strong conciseness, actionability, workflow clarity, and progressive disclosure. The numbered procedure with guardrails, baseline measurement, categorized fixes, and verification creates a robust workflow. The reference file structure is well-organized and all paths are accurate, making this an excellent example of a backend-only performance investigation skill.
plugins/wordpress/.agents/skills/wp-phpstan/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ███ 3/3 | The skill is lean and efficient. It avoids explaining what PHPStan is, what WordPress is, or how Composer works. Every section delivers actionable guidance without padding. The 'When to use' section is brief and targeted. |
| actionability | ███ 3/3 | Provides concrete commands (e.g., node skills/wp-phpstan/scripts/phpstan_inspect.mjs, composer run phpstan, vendor/bin/phpstan analyse), specific package names, and clear decision criteria. References contain executable neon configs and PHP code examples. |
| workflow clarity | ███ 3/3 | The procedure is clearly numbered (0-5) with logical sequencing from discovery through stubs, configuration, fixing, third-party handling, and baseline management. The verification section includes explicit re-run validation steps and checks for baseline growth. Failure modes provide clear debugging paths. |
| progressive disclosure | ███ 3/3 | The SKILL.md provides a clear overview with well-signaled one-level-deep references to references/configuration.md, references/third-party-classes.md, and references/wordpress-annotations.md. Each reference file contains the detailed content (templates, code examples, patterns) appropriately separated from the main workflow. |
Overall: This is an excellent skill file that demonstrates strong structure, conciseness, and actionability. The workflow is well-sequenced with clear validation checkpoints, and the progressive disclosure pattern effectively separates overview guidance from detailed reference material. The failure modes and escalation sections add practical value without bloat.
plugins/wordpress/.agents/skills/wp-playground/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ███ 3/3 | The content is lean and efficient throughout. It avoids explaining what WordPress Playground is conceptually, jumps straight into when/how to use it, and every section earns its place. The 'Inputs required' section is borderline but provides genuinely useful pre-flight info rather than padding. |
| actionability | ███ 3/3 | Provides concrete, copy-paste-ready CLI commands for every workflow (server, run-blueprint, build-snapshot, debugging). Flags are explicitly named with examples, and failure modes include specific solutions rather than vague advice. |
| workflow clarity | ███ 3/3 | Steps are clearly numbered and sequenced from quick start through advanced workflows. Guardrails are upfront (step 0), verification steps are explicit (check plugin active, use --verbosity=debug), and failure modes section provides a feedback loop for common errors with specific fixes. |
| progressive disclosure | ███ 3/3 | The SKILL.md serves as a clear overview with well-signaled one-level-deep references to blueprints.md, cli-commands.md, and debugging.md. The bundle files exist and contain appropriate detail. Content is appropriately split between the main file and references. |
Overall: This is an excellent skill file that is concise, actionable, and well-structured. It provides concrete CLI commands for every workflow, clear sequencing with guardrails and verification steps, and appropriate progressive disclosure to reference files. The failure modes section adds practical value for error recovery.
plugins/wordpress/.agents/skills/wp-plugin-development/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ███ 3/3 | The content is lean and well-structured. It avoids explaining what WordPress plugins are or how PHP works, assumes Claude's competence, and every section earns its place with actionable guidance rather than background exposition. |
| actionability | ██░ 2/3 | The skill provides clear procedural steps and references specific APIs/functions, but lacks executable code examples. Key patterns like activation hooks, Settings API registration, and nonce checks would benefit from concrete copy-paste-ready code snippets rather than just naming the functions. The reference files also lack code examples. |
| workflow clarity | ███ 3/3 | The procedure is clearly sequenced from triage (step 0) through architecture, lifecycle, settings, security, and data storage. The verification section provides explicit validation checkpoints, and the failure modes section provides diagnostic feedback loops for common issues like activation hooks not firing or settings not saving. |
| progressive disclosure | ███ 3/3 | The SKILL.md serves as a clear overview with well-signaled one-level-deep references to six reference files and a script. All referenced paths exist in the bundle, content is appropriately split between the overview and reference files, and navigation is straightforward. |
Overall: This is a well-structured skill with excellent progressive disclosure and workflow clarity. It efficiently covers the breadth of WordPress plugin development concerns without over-explaining. The main weakness is the lack of concrete, executable code examples—both in the main skill and in the reference files—which limits immediate actionability for common patterns like hook registration, Settings API usage, and security implementations.
Suggestions:
- Add at least one executable PHP code snippet per major section (e.g., a complete activation hook registration, a Settings API registration block, and a nonce+capability check pattern) to make the skill immediately actionable.
- Include concrete code examples in reference files, particularly security.md (nonce verification + capability check pattern) and settings-api.md (complete register_setting + add_settings_section + add_settings_field example).
plugins/wordpress/.agents/skills/wp-project-triage/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ███ 3/3 | The content is lean and efficient. Every section serves a purpose, there's no explanation of what WordPress is or how Node scripts work, and it assumes Claude's competence throughout. |
| actionability | ██░ 2/3 | The procedure gives a concrete command to run and references the schema, but the actual detector script is empty (0 chars), meaning the skill cannot be executed as written. The guidance on 'use the report to select workflow guardrails' is also somewhat vague without concrete examples of how to map report fields to specific actions. |
| workflow clarity | ██░ 2/3 | Steps are clearly sequenced and there's a verification section, but the workflow lacks explicit validation checkpoints between steps (e.g., what to do if JSON doesn't parse, no feedback loop for fixing issues). Step 4 ('update the detector rather than guessing') is good guidance but lacks specifics on how. |
| progressive disclosure | ███ 3/3 | The skill is well-structured as a concise overview that correctly references the schema file for detailed output contracts and the script for execution. References are one level deep and clearly signaled. The bundle structure supports the body content appropriately. |
Overall: This is a well-structured, concise skill that effectively delegates to a detection script and schema reference. Its main weakness is that the detection script is empty (0 chars), making the skill non-functional as delivered. The workflow could also benefit from more concrete examples of how to interpret and act on the triage report output.
Suggestions:
- Implement the detect_wp_project.mjs script so the skill is actually executable — currently it's 0 bytes
- Add a brief example of the JSON output the detector produces and show how specific fields map to workflow decisions (e.g., 'if kind includes wp-block-theme, ensure theme.json edits follow X pattern')
- Add an explicit validation checkpoint after step 1: 'Verify the JSON parses correctly and contains required fields (project.kind, signals, tooling) before proceeding'
plugins/wordpress/.agents/skills/wp-rest-api/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ███ 3/3 | The content is lean and efficient throughout. It avoids explaining what REST APIs are or how WordPress works fundamentally, instead jumping straight to actionable guidance. Every section serves a clear purpose with no padding or unnecessary context. |
| actionability | ██░ 2/3 | The skill provides specific function names, constants, and patterns (e.g., register_rest_route, WP_REST_Server::READABLE, rest_ensure_response()), but lacks executable code examples. There are no copy-paste ready code blocks showing a complete route registration or controller class, which would significantly improve actionability. |
| workflow clarity | ███ 3/3 | The procedure is clearly sequenced from triage (step 0) through registration, validation, responses, authentication, and client-facing behavior. The verification section provides explicit checkpoints, and the failure modes section acts as a debugging feedback loop with specific symptoms mapped to causes and fixes. |
| progressive disclosure | ███ 3/3 | The skill is an excellent overview that delegates detailed content to well-organized, one-level-deep reference files. Each procedural step includes a clear 'Read references/...' pointer, and the bundle files exist and contain relevant summary content that complements the main skill without redundancy. |
Overall: This is a well-structured skill with excellent progressive disclosure and workflow clarity. It efficiently covers the full scope of WordPress REST API development without unnecessary verbosity. The main weakness is the lack of executable code examples — the skill references specific functions and patterns but never shows a complete, copy-paste ready code block demonstrating route registration or a controller class.
Suggestions:
- Add at least one complete, executable code example showing a basic
register_rest_route()call withpermission_callback,args, and a callback function returningrest_ensure_response(). - Consider adding a minimal controller class skeleton (extending
WP_REST_Controller) since the skill recommends this approach for non-trivial endpoints but doesn't show what one looks like.
plugins/wordpress/.agents/skills/wp-wpcli-and-ops/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ███ 3/3 | The skill is lean and well-structured. It avoids explaining what WP-CLI is or how WordPress works, assumes Claude's competence, and every section serves a clear purpose. No unnecessary padding or concept explanations. |
| actionability | ██░ 2/3 | The skill provides concrete command examples (wp db export, wp search-replace --dry-run) and references a specific inspector script, but most executable details are deferred to reference files. The main body contains more routing logic than copy-paste-ready commands, and the inspector script is empty (0 chars). |
| workflow clarity | ███ 3/3 | Multi-step processes are clearly sequenced with explicit validation checkpoints. The search-replace workflow includes backup → dry-run → execute → flush. Step 0 establishes guardrails before any writes. Verification section includes re-running the inspector and smoke tests. Failure modes and escalation are clearly documented. |
| progressive disclosure | ███ 3/3 | Content is excellently structured with a concise overview in SKILL.md and well-signaled one-level-deep references to specific topic files (safety.md, search-replace.md, multisite.md, etc.). All referenced paths exist in the bundle and the reference files are appropriately scoped and concise. |
Overall: This is a well-structured operational skill that effectively uses progressive disclosure to keep the main file scannable while providing detailed guidance in reference files. The workflow clarity is strong with explicit guardrails, validation steps, and failure mode documentation. The main weakness is that actionability in the body itself relies heavily on delegation to reference files, and the inspector script is empty, which undermines the concrete inspection step.
Suggestions:
- Populate scripts/wpcli_inspect.mjs with actual implementation, as it's referenced as a key step but is currently empty (0 chars).
- Consider inlining a few more concrete command examples in the main body (e.g., the exact wp db export and wp search-replace commands with placeholder arguments) so the skill is more immediately actionable without needing to read reference files.
plugins/wordpress/.agents/skills/wpds/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill is mostly efficient but includes some unnecessary content. The synonym definitions and the extensive 'When to use' trigger list add moderate bloat. The MCP usage instructions are useful but could be tighter. Some phrasing like 'for example, Gutenberg, WooCommerce, WordPress.com, Jetpack, etc etc' is padded. |
| actionability | ██░ 2/3 | The skill provides concrete MCP resource URIs (wpds://pages, wpds://components, etc.) which is good, but lacks executable code examples, specific command invocations, or concrete demonstrations of how to use the MCP tools or produce output. The guidance is mostly directional rather than copy-paste ready. |
| workflow clarity | ██░ 2/3 | There is an implicit workflow: read documentation first via MCP, then build UI, then validate with lint scripts, then provide recap. However, the steps are not clearly sequenced or numbered, and the validation step ('if lint scripts exist, use them') is vague and conditional rather than explicit. No feedback loop for error recovery is defined. |
| progressive disclosure | ██░ 2/3 | The skill references the WPDS MCP server as the source of detailed documentation, which is a form of progressive disclosure. However, there are no bundle files, no linked reference documents, and the skill inlines all its content in a single file without clear navigation to deeper resources. For a skill of this complexity, some supporting reference files would improve organization. |
Overall: This skill provides a reasonable framework for using the WPDS MCP server to build WordPress UIs, with clear rules about preferring MCP documentation over web searches. However, it lacks concrete executable examples, explicit workflow sequencing with validation checkpoints, and could be more concise by trimming synonym definitions and verbose trigger lists. The actionability would benefit significantly from a worked example showing MCP tool invocation and resulting code output.
Suggestions:
- Add a concrete worked example showing an MCP tool call (e.g., querying wpds://components/Button) and the resulting code output to improve actionability.
- Define a clear numbered workflow sequence: 1) Query MCP for relevant docs, 2) Build UI code, 3) Validate with lint scripts, 4) Fix and re-validate if errors, 5) Provide recap — this would improve workflow clarity.
- Trim the synonym definitions and consolidate the 'When to use' triggers into a more concise list to improve token efficiency.
- Consider adding a bundle file with common WPDS patterns or component usage examples that the skill can reference for progressive disclosure.
plugins/wordpress/agent/skills/wp-playground/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/wordpress/agent/skills/wp-rest-api/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
To improve your score, point your agent at the Tessl optimization guide. Need help? Jump on our Discord.
Feedback
Report issues with this review at tesslio/skill-review, or send private feedback from your terminal with tessl feedback.
|
1 participant
Automated refresh of vendored skills.sh skills to their latest upstream versions.
Updated lock directories:
plugins/better-authplugins/dev3000plugins/lavishplugins/prismaplugins/slidevplugins/supabaseplugins/tsdownplugins/turborepoplugins/vercel-sandboxplugins/vinextplugins/wordpress(repo root)Generated by
.github/workflows/update-skills.yml→scripts/update-skills.ts.Summary by cubic
Refreshes vendored
skills.shcontent across plugins and expands theplugin-creatorskill with a local update flow, stronger validation, and manifest enhancements. This keeps skills current and improves plugin development ergonomics.New Features
plugin-creator: added CLI scripts for cachebusting (update_plugin_cachebuster.py), validation, basic scaffolding, and marketplace name reads; added docs for installing/updating and a sampleplugin.jsonspec; supportsinterface.logoDarkandmcpServersas a path or inline object; validator updated accordingly.dev3000(d3k) skill copy to emphasize managed browser and evidence; improvedbetter-authguides with Drizzle/Prisma migration steps; added agent assets and OpenAI agent config forplugin-creator.Dependencies
skills-lock.jsonacross multiple plugins; added.claude/skillspointers for a broad set of plugin skills (e.g., Google Workspace, Docus, Git AI).plugin.jsonremains valid. New fields (interface.logoDark) and inlinemcpServersare optional.Written for commit e0aa60d. Summary will update on new commits.