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 |
|---|---|
| Complexity | 322 |
| Duplication | 20 |
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, naming conventions, and policy defaults multiple times across sections (Quick Start, What this skill creates, Marketplace workflow, Required behavior). Much of this is redundant — e.g., the marketplace entry JSON shape appears twice, allowed policy values are listed twice, and rules about --marketplace-name are stated three times. Claude doesn't need explanations of what 'personal marketplace' means repeated in multiple places. |
| actionability | ███ 3/3 | The skill provides fully executable bash commands with concrete flags, specific script paths, and copy-paste ready examples. The JSON schemas for plugin manifests and marketplace entries are complete and concrete. Every step has an explicit command to run. |
| workflow clarity | ███ 3/3 | The Quick Start section provides a clear numbered sequence (scaffold → edit → marketplace → optional folders → validate). Validation checkpoints are explicit — both validate_plugin.py before handing back and quick_validate.py after editing SKILL.md. The update flow in the references has a clear loop with cachebuster → read marketplace name → reinstall → new thread. |
| progressive disclosure | ██░ 2/3 | The skill correctly references external files (references/plugin-json-spec.md, references/installing-and-updating.md) and the bundle structure supports this. However, the SKILL.md itself contains enormous amounts of detail that belong in reference files — the full marketplace JSON spec, all marketplace generation rules, and detailed policy value enumerations are inlined rather than delegated to the existing references/plugin-json-spec.md which already contains this information. |
Overall: The skill is highly actionable with clear executable commands, good validation checkpoints, and a well-structured workflow. However, it suffers significantly from verbosity and redundancy — marketplace rules, JSON shapes, and policy constraints are repeated across multiple sections and also duplicated from the reference files. The content would benefit greatly from consolidating duplicated information into the reference files and keeping the SKILL.md as a lean overview.
Suggestions:
- Remove the duplicated marketplace JSON examples and policy value enumerations from SKILL.md, since these are already fully documented in references/plugin-json-spec.md — replace with a brief reference link.
- Consolidate the 'Marketplace workflow' and 'Required behavior' sections, which repeat many of the same rules (e.g., --marketplace-name usage, policy defaults, displayName placement) — merge into a single concise rules section.
- Remove explanatory phrases like 'Here, "personal marketplace" means the marketplace whose file is at that path' which appear multiple times and explain something Claude can infer from context.
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 User & Account Config, Email Flows, and Security list options that are essentially API reference material that could be offloaded. The skill is fairly long (~180 lines) and some content borders on documentation mirroring rather than adding unique value. |
| actionability | ██░ 2/3 | The setup workflow provides concrete CLI commands and a verification step, which is good. However, the core auth.ts configuration lacks a concrete executable example — there's no actual code showing how to create the auth instance, configure the database adapter, or set up a route handler. The plugin import example is the only real code snippet. Most guidance is descriptive option listings rather than copy-paste ready code. |
| workflow clarity | ███ 3/3 | The setup workflow is clearly sequenced with numbered steps, branching paths for different adapters (built-in vs Drizzle vs Prisma), 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 skill links to external docs and references, which is good. However, with no bundle files, all content is inline in a single long file. Sections like Security options, Hooks, Session Management, and Database adapters could be split into separate reference files. The structure is reasonable with clear section headers but the file is monolithic for its breadth of coverage. |
Overall: This is a comprehensive reference guide for Better Auth that covers the full breadth of the library's features with good workflow sequencing and useful gotchas. Its main weaknesses are the lack of concrete, executable code examples for core setup tasks (auth.ts creation, route handler setup, database adapter configuration) and the monolithic structure that packs extensive API reference material into a single file. The setup workflow and common gotchas sections are the strongest parts.
Suggestions:
- Add a concrete, executable auth.ts example showing database adapter setup, basic config, and route handler creation — this is the most critical missing piece for actionability.
- Extract detailed reference sections (Security options, Hooks, Session Management, Database adapters) into separate bundle files and link to them from the main SKILL.md to improve progressive disclosure.
- Add a minimal client-side code example showing createAuthClient usage with signUp/signIn to complement the server setup.
plugins/better-auth/.agents/skills/organization-best-practices/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill is fairly comprehensive but includes some redundancy — the complete configuration example at the end repeats patterns already shown. Some sections like Security Considerations explain things Claude would understand (e.g., what soft delete means). However, most content is practical and not overly padded. |
| actionability | ███ 3/3 | Nearly every section includes executable, copy-paste-ready TypeScript code with realistic parameters. Server-side and client-side examples are clearly distinguished, and API methods are shown with their actual parameter shapes. |
| workflow clarity | ██░ 2/3 | The setup section has a clear 4-step sequence with a verification checkpoint. However, multi-step processes like ownership transfer, invitation acceptance flows, and migration lack explicit validation/feedback loops. The owner protection section shows a two-step process but doesn't include verification that the transfer succeeded before proceeding. |
| progressive disclosure | ██░ 2/3 | The content is well-organized with clear section headers and logical grouping, but it's a long monolithic document (~300+ lines) with no references to external files. Topics like schema customization, lifecycle hooks, and dynamic access control could be split into separate reference files to keep the main skill lean. |
Overall: This is a solid, highly actionable skill with excellent executable code examples covering the full breadth of Better Auth's organization plugin. Its main weaknesses are length (could benefit from splitting advanced topics into referenced files) and missing validation checkpoints in multi-step workflows like ownership transfer and migration. The content is well-structured but could be more concise by removing the final complete configuration example that largely repeats earlier snippets.
Suggestions:
- Add explicit validation/verification steps after multi-step operations like ownership transfer (e.g., confirm new owner role before removing old owner) and migration (e.g., verify table creation).
- Extract advanced topics (lifecycle hooks, schema customization, dynamic access control) into separate referenced files to reduce the main skill's token footprint.
- Remove or significantly trim the 'Complete Configuration Example' section at the end, as it largely duplicates code patterns already shown throughout the document.
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 display component, and the complete configuration example at the end which largely repeats earlier snippets. 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 snippets are copy-paste ready with correct imports and API calls. |
| workflow clarity | ███ 3/3 | The setup flow 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 the only file, so the inline approach is somewhat justified. |
Overall: This is a solid, actionable skill with executable code examples covering the full 2FA lifecycle in Better Auth. Its main weakness is length — it could be more concise by removing React component examples Claude can trivially generate and by not repeating configuration options in the final complete example. The workflow clarity is strong with explicit sequencing for setup and sign-in flows.
Suggestions:
- Remove the React component examples (QRCode display, BackupCodes list) — Claude can generate these trivially; just mention the data shape returned.
- Remove or significantly trim the 'Complete Configuration Example' section since it repeats options already shown in individual sections, or replace it with a brief 'see above sections for individual options' note.
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 are slightly verbose—e.g., the 'Browser and Auth Safety' section repeats the warning about not using alternative browsers multiple times, and the 'Operating Rules' section partially restates constraints already covered inline. Could be tightened by ~20%. |
| actionability | ███ 3/3 | Every step includes concrete, copy-paste-ready CLI commands with specific flags and arguments. The skill covers installation, startup, polling, user-driven testing, agent-driven testing, and evidence gathering with executable examples throughout. |
| workflow clarity | ███ 3/3 | Multi-step processes are clearly sequenced with explicit validation checkpoints: check status before starting, poll until ready, verify browserConnected before handing to user, check errors after reproduction. The feedback loop of 'replay interaction → check errors → fix → repeat' is explicit. Error recovery paths (inspect retained process output, restart cleanly) are specified. |
| progressive disclosure | ██░ 2/3 | The content is well-organized into logical sections with clear headers, but it's a single monolithic file with no references to supporting documents. At ~120 lines with multiple distinct concerns (installation, user-driven testing, agent-driven testing, auth safety, operating rules), some content like the auth safety details or the full evidence commands reference could benefit from being split into separate files. |
Overall: This is a strong, actionable skill with clear workflows and concrete CLI commands throughout. Its main weakness is moderate verbosity—some constraints are stated redundantly across sections—and the lack of progressive disclosure into supporting files for a document of this length. The workflow clarity is excellent with proper validation checkpoints and error recovery paths.
Suggestions:
- Consolidate redundant constraints (e.g., 'do not start a second d3k' appears in both the startup section and operating rules; browser ownership warnings appear in both agent-driven testing and auth safety) to reduce token usage.
- Consider extracting the 'Browser and Auth Safety' section and 'Evidence Commands' reference into separate bundle files, with brief summaries and links in the main SKILL.md.
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 | █░░ 1/3 | The skill is extremely verbose with significant repetition. The poll rules are stated in full detail in the Workflow section and then repeated nearly verbatim in the Commands & rules section. Many instructions (e.g., foreground polling constraints, background job rules, npx invocation fallbacks) are restated multiple times. The document could be cut by 40-50% without losing information. |
| actionability | ███ 3/3 | The skill provides concrete, executable commands throughout (npx -y lavish-axi , poll, end, export, share, playbook, design, stop). The workflow is specific with exact CLI invocations and flags like --agent-reply, --reopen, --password. Fallback commands for restricted environments are also provided. |
| workflow clarity | ███ 3/3 | The workflow is clearly sequenced (steps 1-7) with explicit validation checkpoints: poll returns layout_warnings which must be repaired before involving the human (step 4), feedback loops are built in (step 5), and session termination is clearly defined (steps 6-7). Error recovery is addressed (re-run poll if killed/timed out). |
| 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 document itself is a monolithic wall of text with the Commands & rules section duplicating much of the Workflow section. Content that could be separated (e.g., detailed polling rules, Mermaid/Excalidraw integration details) is inlined, making the document harder to scan. |
Overall: The skill provides highly actionable, concrete CLI commands and a well-structured workflow with proper validation checkpoints and feedback loops. However, it suffers significantly from verbosity and repetition—polling rules, foreground/background constraints, and npx invocation patterns are restated multiple times across sections. The document would benefit greatly from deduplication and moving detailed reference material (Mermaid/Excalidraw behavior, sharing details) into separate files or playbooks.
Suggestions:
- Deduplicate the polling rules: state them once in the Workflow section and reference that section from Commands & rules, or consolidate into a single authoritative location
- Move detailed Mermaid/Excalidraw whiteboard behavior (scene autosave, re-convert flow, edit summary handling) into a playbook or separate reference file rather than inlining it in Commands & rules
- Remove the repeated 'Use lavish-axi when...' trigger list that appears in both 'When to use' and the end of 'Commands & rules'
plugins/lavish/agent/skills/lavish/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/nostics/.agents/skills/nostics/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The content is dense and information-rich, but some sections could be tightened. The reporters/conventions guidance and the production builds section include explanatory rationale that borders on verbose (e.g., explaining why reporters would cause duplicates). However, most content earns its place given the complexity of the API surface. |
| actionability | ███ 3/3 | Excellent executable code examples throughout: defineDiagnostics setup, call-site patterns, custom reporters, Vite config, production ternary, and formatDiagnostic output. Every major feature has copy-paste-ready TypeScript with realistic values (Nuxt-style codes). The call-site table and reporter table provide concrete, specific guidance. |
| workflow clarity | ██░ 2/3 | The skill covers multiple workflows (defining catalogs, production builds, stripping) but presents them as reference sections rather than sequenced steps with validation checkpoints. The production build section describes what to do but lacks explicit verification steps (e.g., 'verify the catalog tree-shakes by checking bundle size'). The strip plugin section mixes explanation with instructions without clear sequencing. |
| progressive disclosure | ███ 3/3 | Clean structure with well-signaled references to references/migration.md and references/documentation-site.md at the end. The main SKILL.md serves as a comprehensive but navigable overview, and detailed migration/docs-site workflows are appropriately delegated to one-level-deep reference files. Section headers provide clear navigation. |
Overall: This is a strong, highly actionable skill with excellent code examples covering the full nostics API surface. Its main weakness is workflow clarity — the production build and stripping workflows would benefit from explicit step-by-step sequences with validation checkpoints rather than descriptive paragraphs. The content is slightly verbose in places where rationale is given for design decisions (e.g., why to separate report-only and throw catalogs), but overall token efficiency is reasonable given the API complexity.
Suggestions:
- Restructure the 'Production builds' section as a numbered workflow with explicit validation steps (e.g., '1. Add defineProdDiagnostics ternary → 2. Build → 3. Verify catalog text is absent from bundle → 4. Confirm thrown diagnostics still carry .name and .docs').
- Trim explanatory rationale in the reporters section — e.g., the paragraph about why to omit reporters for throw-only catalogs could be condensed to a single sentence or a bullet point.
plugins/nostics/agent/skills/nostics/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/portless/.agents/skills/portless/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | █░░ 1/3 | Extremely verbose at ~400+ lines. The 'Why portless' section lists 9 bullet points explaining problems Claude already understands. Extensive coverage of LAN mode, Tailscale, ngrok, OS services, git worktrees, and troubleshooting scenarios makes this more of a full product README than a focused skill. Much of this content (e.g., explaining what port conflicts are, cookie/storage clashes) wastes tokens on concepts Claude knows. |
| actionability | ███ 3/3 | Highly actionable with concrete, copy-paste-ready commands throughout. Installation commands, CLI examples, configuration JSON snippets, and troubleshooting steps are all executable and specific. The CLI reference table and environment variable table provide precise, usable guidance. |
| workflow clarity | ██░ 2/3 | The Quick Start provides a clear sequence, and integration patterns show concrete workflows. However, there are no explicit validation checkpoints or feedback loops — for example, after setting up the proxy or configuring monorepo apps, there's no 'verify it works' step until the troubleshooting section mentions portless doctor. The doctor command should be integrated into setup workflows. |
| progressive disclosure | █░░ 1/3 | This is a monolithic wall of text with no bundle files to offload content to. The CLI reference table, environment variables table, detailed LAN mode docs, Tailscale/ngrok integration, OS service setup, and extensive troubleshooting could all be split into separate referenced files. Everything is inline in one massive document with no layered structure. |
Overall: This skill reads like a comprehensive product README rather than a focused skill document. While it excels at actionability with concrete commands and configurations throughout, it is far too verbose — explaining motivations Claude doesn't need, covering every feature exhaustively inline, and lacking any progressive disclosure structure. The workflow clarity would benefit from explicit validation checkpoints using portless doctor integrated into setup flows.
Suggestions:
- Remove or drastically reduce the 'Why portless' section — Claude doesn't need motivation for using a tool it's been asked to use. A single sentence suffices.
- Split the document: keep Quick Start, zero-config, and basic troubleshooting in SKILL.md; move CLI reference, environment variables, LAN mode, Tailscale/ngrok, OS services, and advanced troubleshooting into separate referenced files (e.g., CLI_REFERENCE.md, ADVANCED.md, TROUBLESHOOTING.md).
- Add explicit validation steps to workflows, e.g., after setup: 'Run
portless doctorto verify proxy, DNS, and CA trust are working correctly before proceeding.' - Cut the content by at least 50% — remove explanations of concepts (what port conflicts are, what cookies do), redundant examples, and details about every supported Linux distro for trust store installation.
plugins/portless/agent/skills/portless/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 mostly efficient but has some redundancy — the driver adapter table and examples appear in the main SKILL.md and are repeated in the reference files. The MongoDB warnings are stated multiple times (at least 3-4 repetitions of 'stay on Prisma 6.x' and 'do not use SQL adapter'). The Quick Reference section largely duplicates what's in the reference files. |
| actionability | ███ 3/3 | The skill provides fully executable code examples for schema configuration, driver adapter setup, and client instantiation. Commands are copy-paste ready with specific package names, import paths, and configuration patterns for each database provider. |
| workflow clarity | ██░ 2/3 | The Prisma Client Setup section provides numbered steps for the setup workflow, but there are no validation checkpoints — no step to verify the database connection works, no error recovery guidance if prisma generate fails, and no verification that the adapter is correctly configured. For a setup workflow that can fail at multiple points (connection, generation, instantiation), explicit validation steps would be valuable. |
| progressive disclosure | ███ 3/3 | The SKILL.md serves as a clear overview with essential information inline, then points to well-organized, one-level-deep reference files for each database provider. All referenced paths match actual bundle files, 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 actionability and excellent progressive disclosure across its reference files. The main weaknesses are redundancy (MongoDB warnings repeated excessively, Quick Reference duplicating reference files) and missing validation/verification steps in the setup workflow. Tightening the repeated content and adding connection verification steps would elevate this skill significantly.
Suggestions:
- Reduce MongoDB-related warnings to a single, prominent callout rather than repeating the 'stay on Prisma 6.x / do not use SQL adapter' guidance 4+ times across the main file.
- Add a validation step after client instantiation, e.g.,
await prisma.$connect()with error handling guidance, to help catch connection issues early. - Consider removing the Quick Reference section since it largely duplicates the content in the reference files — a simple link table would suffice.
plugins/prisma/.agents/skills/prisma-postgres/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill is mostly efficient but includes some redundancy—the 'When to Apply' section largely restates what the description and quick reference already convey, and the priority table with prefixes adds marginal value. The core workflows section is reasonably lean but could be tighter. |
| actionability | ███ 3/3 | The skill provides concrete, executable commands throughout (npx create-db, prisma postgres link with flags, @prisma/cli commands, npm install). Key details like one-time connection URL visibility and --confirm flags for destructive commands are included. Code blocks are copy-paste ready. |
| workflow clarity | ██░ 2/3 | Multiple workflows are listed with clear steps, but validation checkpoints are largely missing. For example, the Console-first workflow has no verification step, and the programmatic provisioning workflow (section 4) is more of a pointer than a sequenced process. The 'database create' workflow in 2b mentions storing the connection URL but lacks explicit validation/error recovery steps. |
| progressive disclosure | ███ 3/3 | The skill provides a clear overview with well-signaled, one-level-deep references to four specific reference files. The bundle structure matches the referenced paths exactly, and the 'How to Use' section provides clear navigation guidance for which reference to start with. |
Overall: This is a well-structured skill with strong progressive disclosure and actionable commands. Its main weaknesses are some redundancy in the introductory sections (When to Apply, Rule Categories, Quick Reference all partially overlap) and a lack of explicit validation/error-recovery steps in the workflows, particularly for operations that produce one-time secrets or involve destructive commands.
Suggestions:
- Add explicit validation checkpoints to workflows—e.g., after 'prisma postgres link', verify the connection with 'prisma db pull' or a test query before proceeding to migrations.
- Consolidate the 'When to Apply', 'Rule Categories', and 'Quick Reference' sections into a single concise section to reduce redundancy and save tokens.
plugins/prisma/.agents/skills/prisma-upgrade-v7/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill is fairly comprehensive but includes some redundancy—the 'Quick Reference' section, 'Rule Categories by Priority' table, and 'Upgrade Steps Overview' all partially overlap with the step-by-step migration and breaking changes summary. Some sections like 'When to Apply' explain obvious triggers. However, it avoids explaining basic concepts Claude would know. |
| actionability | ███ 3/3 | The skill provides fully executable code examples for every migration step—package.json changes, tsconfig updates, schema.prisma modifications, prisma.config.ts creation, driver adapter installation commands, and client instantiation code. All examples are copy-paste ready with clear before/after comparisons. |
| workflow clarity | ██░ 2/3 | The steps are clearly numbered and sequenced, but there are no explicit validation checkpoints between steps. For a migration involving multiple breaking changes, there should be verification steps (e.g., 'run prisma generate and confirm no errors before proceeding to step 6'). The troubleshooting section helps but is reactive rather than preventive. |
| progressive disclosure | ███ 3/3 | The skill has excellent progressive disclosure—a clear overview with step-by-step essentials in the main file, with detailed reference files for each category (driver-adapters, schema-changes, esm-support, etc.). References are one level deep, clearly listed, and the bundle structure matches the referenced paths exactly. |
Overall: This is a well-structured migration guide with excellent actionability and progressive disclosure. The main weaknesses are moderate verbosity from overlapping organizational sections (priority table, quick reference, overview, and step-by-step all covering similar ground) and the lack of explicit validation checkpoints between migration steps that could catch errors early in a complex multi-step process.
Suggestions:
- Add explicit validation checkpoints between steps (e.g., 'Run
npx prisma generateafter step 3 and verify no errors before proceeding to driver adapter setup') - Consolidate the 'Rule Categories by Priority', 'Quick Reference', and 'Upgrade Steps Overview' sections into a single concise overview to reduce redundancy
plugins/prisma/agent/skills/prisma-database-setup/SKILL.md
⚠️ Error: - Reviewing skill...
✘ Skill validation failed
plugins/prisma/agent/skills/prisma-postgres/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/slack-agent/.agents/skills/slack-agent/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill is comprehensive but includes some content Claude already knows (git commit conventions, basic Vitest patterns, general advice like 'never commit .env files'). The environment variables table and some explanatory prose could be tightened. However, most framework-specific content (eve patterns, Connect setup, gotchas) earns its place. |
| actionability | ███ 3/3 | Excellent actionability throughout — executable code for channel setup, tool definitions, Connect CLI commands, deployment steps, and testing patterns. Code examples are copy-paste ready with real imports and realistic patterns. The gotchas section provides specific diagnostic steps rather than vague warnings. |
| workflow clarity | ███ 3/3 | Multi-step workflows are clearly sequenced with explicit validation checkpoints: the wizard phases are numbered with dependencies, the quality checklist has ordered verification steps, the Connect setup has a clear sequence with the critical '--triggers' requirement called out, and the task completion checklist serves as a final validation gate. Error recovery is addressed in gotchas. |
| progressive disclosure | ██░ 2/3 | The skill references wizard phases (./wizard/.md), patterns (./patterns/.md), and reference docs (./reference/*.md) with clear navigation, which is good structure. However, the SKILL.md itself is very long (~600+ lines) with substantial inline content that could be pushed to reference files — the AI Integration section, State & Durability, and Slack-Specific Patterns sections are detailed enough to warrant their own files. No bundle files were provided to verify referenced paths exist. |
Overall: This is a high-quality, highly actionable skill that provides comprehensive guidance for building Slack agents with eve and Vercel Connect. Its greatest strength is the depth of executable examples and the thorough coverage of gotchas and edge cases. Its main weakness is length — at 600+ lines, it pushes the boundaries of token efficiency, with some sections (git conventions, basic test patterns, storage recommendations) that could be trimmed or externalized to keep the main file leaner.
Suggestions:
- Move the AI Integration, State & Durability, and Slack-Specific Patterns sections into separate reference files (e.g., ./reference/ai-integration.md) and replace with brief summaries and links to reduce the main file's token footprint.
- Remove content Claude already knows: git commit format examples, basic Vitest boilerplate, and advice like 'never commit node_modules' — these waste tokens without adding framework-specific value.
plugins/slack-agent/agent/skills/slack-agent/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 tables serve as compact lookup references with inline usage snippets, and the Quick Start is minimal. The 'When to Use' section is slightly redundant with the description but brief enough to not waste significant tokens. |
| actionability | ███ 3/3 | The Quick Start provides copy-paste ready bash commands. The Basic Syntax section gives a complete, executable markdown example. Feature reference tables include concrete syntax snippets (e.g., ts {2,3}, ts {monaco}`) that are directly usable. The export prerequisite note is a specific, actionable instruction. |
| workflow clarity | ███ 3/3 | The Quick Start presents a clear sequence (create → dev → build → export) with explicit validation checkpoints ('Verify: After pnpm run dev, confirm slides load...'). The export prerequisite callout provides error recovery guidance. For a tool-usage skill like this, the workflow is appropriately clear without needing complex feedback loops. |
| progressive disclosure | ███ 3/3 | Exemplary progressive disclosure: concise overview with quick start and basic syntax inline, then organized tables pointing to 50+ one-level-deep reference files. References are clearly categorized by domain (Code & Editor, Diagrams & Math, Layout & Styling, etc.) with usage hints so Claude can decide which to consult without opening them all. |
Overall: This is an excellent reference skill that serves as a well-organized index to Slidev's features. It provides just enough inline content (Quick Start commands, basic syntax example) to be immediately actionable, while delegating detailed feature documentation to a comprehensive set of one-level-deep reference files. The content is concise, assumes Claude's competence, and includes appropriate validation checkpoints.
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 extensive tables, many code examples, and a best practices section that largely restates what's already shown in the examples. The 'When to Use' section and some best practices tips explain things Claude would infer. However, the tables are reasonably dense and the code examples are not padded with unnecessary prose. |
| actionability | ███ 3/3 | Every section provides concrete, executable configuration snippets and CLI commands. The Quick Start, Common Patterns, and CLI Quick Reference sections are all copy-paste ready with real tsdown config objects and bash commands. |
| workflow clarity | ██░ 2/3 | This is primarily a configuration reference skill rather than a multi-step workflow, so the bar is lower. However, the Quick Start section lacks explicit validation steps (e.g., verifying the build output works). The migration section references the tsdown-migrate skill but doesn't include verification steps after migration. For a tool that generates build artifacts, a 'verify output' step would strengthen the workflow. |
| progressive disclosure | ███ 3/3 | Excellent progressive disclosure structure. The SKILL.md serves as a clear overview with well-organized tables linking to 35+ reference files covering options, guides, recipes, and advanced topics. References are one level deep, clearly signaled with descriptive names, and the file naming convention (guide-, option-, recipe-, advanced-) makes navigation intuitive. |
Overall: This is a well-structured skill with excellent progressive disclosure and highly actionable code examples. Its main weakness is verbosity — the SKILL.md tries to be both a quick reference and a comprehensive catalog, resulting in a long document where the Common Patterns section largely duplicates what's already in the Basic Configuration and tables. The best practices section also adds marginal value given the examples already shown. Trimming redundant patterns and the best practices list would significantly improve token efficiency.
Suggestions:
- Reduce the Common Patterns section to 3-4 essential patterns (basic library, React, browser IIFE) and move the rest to a references file like
references/recipe-patterns.md. - Remove or significantly trim the Best Practices section — most tips (dts: true, clean: true, minify: true) are already demonstrated in the code examples above and are self-evident to Claude.
- Add a brief verification step after Quick Start (e.g., 'Verify: check dist/ contains expected .mjs/.cjs files') to improve workflow clarity.
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 ('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 examples (e.g., turbo run vs turbo is explained twice — once as a rule and again as an anti-pattern). |
| actionability | ███ 3/3 | Every pattern and anti-pattern includes concrete, copy-paste-ready JSON configuration examples. The decision trees point to specific files and flags. Code examples are complete and executable (turbo.json configs, package.json scripts, CLI commands, YAML CI configs). The guidance is specific and prescriptive rather than vague. |
| workflow clarity | ██░ 2/3 | The decision trees provide clear routing for common scenarios, and the task configuration section shows clear sequences. However, there are no explicit validation checkpoints or feedback loops — for example, after configuring tasks there's no 'verify with --dry' step, and after setting up caching there's no 'confirm with --summarize' checkpoint. For a build system where misconfigurations can silently produce wrong caches, validation steps would be important. |
| progressive disclosure | ███ 3/3 | Excellent progressive disclosure structure. The SKILL.md serves as a comprehensive overview with decision trees that route to specific reference files. The Reference Index at the bottom provides a clean table mapping every reference file to its purpose. All references are one level deep and clearly signaled. The bundle structure matches the referenced paths perfectly. |
Overall: This is a well-structured, highly actionable Turborepo skill with excellent progressive disclosure through decision trees and a comprehensive reference index. Its main weakness is verbosity — the anti-patterns section is thorough but repetitive (e.g., turbo run vs turbo appears twice), and some explanations could be trimmed. Adding validation checkpoints (e.g., 'verify cache behavior with --summarize') would strengthen workflow clarity for this configuration-heavy domain.
Suggestions:
- Consolidate the 'turbo run vs turbo' guidance — it appears both as a standalone rule and as an anti-pattern; merge into one section to save tokens.
- Add validation checkpoints to key workflows, e.g., after configuring tasks: 'Verify with
turbo run build --dryto confirm dependency graph' and after environment setup: 'Runturbo run build --summarizeto confirm env vars are in the hash'. - Trim explanatory prose in anti-patterns that Claude can infer, such as the bullet list under 'Problems with root .env' — the directory structure comparison alone makes the point.
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 skill is comprehensive and mostly efficient, but it's extremely long (~600+ lines) with some sections that could be consolidated. The v2 migration notes and multiple creation patterns (git, tarball, snapshot, VCR image) add bulk. However, most content is genuinely new information Claude wouldn't know, and there's minimal hand-holding or concept explanation. |
| actionability | ███ 3/3 | Every section provides fully executable TypeScript code examples that are copy-paste ready. Commands include specific arguments, imports are shown, and return types/behaviors are documented. The CLI reference is concrete with exact flags and syntax. |
| workflow clarity | ██░ 2/3 | The Common Patterns section shows clear multi-step workflows (Build and Test Pattern checks exit codes before proceeding), but most of the document is a reference guide rather than a workflow. There are no explicit validation checkpoints or error recovery loops for complex operations like snapshot management or network policy configuration. |
| progressive disclosure | █░░ 1/3 | This is a monolithic wall of text with no references to supporting files. At 600+ lines, content like the full CLI reference, network policy details, multi-user/groups, and snapshot management could easily be split into separate reference files. Everything is inline in a single massive document with no progressive structure. |
Overall: This skill is an extremely thorough and actionable API reference for @vercel/sandbox v2, with excellent executable code examples covering virtually every SDK feature. Its main weakness is its monolithic structure — at 600+ lines it would benefit enormously from splitting into a concise overview SKILL.md with references to detailed sub-documents for network policies, snapshots, CLI reference, etc. The workflow patterns at the end are good but lack explicit validation/error-recovery steps for complex operations.
Suggestions:
- Split the content into a concise SKILL.md overview (quick start, basic creation, common patterns) with references to separate files like CLI_REFERENCE.md, NETWORK_POLICY.md, SNAPSHOTS.md, and MULTI_USER.md
- Add explicit validation checkpoints to the Common Patterns section, e.g., verifying sandbox health after resume, checking snapshot status before forking, and handling APIError in multi-step workflows
- Consolidate the many creation variants (git, tarball, snapshot, VCR image, fork) into a summary table in the main file with detailed examples in a referenced CREATION_SOURCES.md
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's competence with package managers, ESM, and Vite concepts without over-explaining. Tables are used effectively for dense information, and every section serves a clear purpose without padding. |
| actionability | ███ 3/3 | The skill provides fully executable commands, copy-paste ready config files, concrete bash commands for each package manager, and specific code examples for Vite configs, Cloudflare bindings, and Nitro deployment. The before/after tables for script replacement are immediately actionable. |
| workflow clarity | ███ 3/3 | The migration is clearly sequenced into numbered phases (Verify → Check → Automated/Manual → Deploy → Verify) with explicit validation checkpoints. Phase 2 includes a fallback path to Phase 3, Phase 5 provides verification steps, and the automated path includes a clear 'if it fails, continue to Phase 3' decision point. The anti-patterns section adds guardrails against common mistakes. |
| progressive disclosure | ███ 3/3 | The SKILL.md provides a complete overview with well-signaled one-level-deep references to three supporting files (compatibility.md, config-examples.md, troubleshooting.md). Each reference is contextually placed where the user would need it. The bundle files contain appropriately detailed content that would bloat the main skill if inlined. |
Overall: This is an exceptionally well-crafted skill that demonstrates excellent structure, actionability, and progressive disclosure. The phased workflow with clear decision points (automated vs manual, Cloudflare vs Nitro) guides Claude through the migration process efficiently. The anti-patterns section and known limitations table add valuable guardrails, and the supporting reference files are well-organized and appropriately scoped.
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, but it's quite long (~350 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 earns its place given the complexity of the blueprint API. |
| 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 testing section gives exact CLI commands, and the common mistakes table provides concrete correct/incorrect pairs. Nothing is left as pseudocode or vague description. |
| workflow clarity | ███ 3/3 | The bundle creation workflow is clearly sequenced (create directory → write files → zip plugin → reference in blueprint.json) with a complete worked example. Testing workflows distinguish between inline, CLI interactive, and headless validation approaches. The gotcha about --blueprint-may-read-adjacent-files serves as an important validation checkpoint. The common mistakes table acts as a pre-flight checklist. |
| progressive disclosure | ███ 3/3 | The skill is well-structured with a clear progression: quick start template → top-level properties → resources → steps → common patterns → common mistakes → full reference links. Advanced topics (bundles, testing) are in later sections. External references to the full blueprint docs and JSON schema are clearly signaled at the end. For a standalone skill with no bundle files, the organization is excellent. |
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 well-organized progressive structure from quick start to advanced bundles, and the extremely useful common mistakes table. The only minor weakness is that it's quite long and could potentially be tightened in places — some sections read more like API documentation than a focused skill — but the complexity of the blueprint API largely justifies the length.
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—no unnecessary explanations of what WordPress is or how plugins work. It assumes Claude's competence and focuses on the routing procedure. |
| actionability | ███ 3/3 | Provides a concrete script to run (node skills/wp-project-triage/scripts/detect_wp_project.mjs), specific file paths to inspect on failure, and a clear escalation question. The decision tree reference adds fully specific routing targets and keyword triggers. |
| workflow clarity | ███ 3/3 | The procedure is clearly sequenced (run triage → classify → route → apply guardrails), with a verification step to re-run triage after significant changes, and explicit failure mode handling with fallback inspection steps and escalation. |
| progressive disclosure | ███ 3/3 | The SKILL.md is a concise overview that correctly delegates the detailed decision tree to references/decision-tree.md—a single, well-signaled, one-level-deep reference. The referenced path matches the actual bundle structure. |
Overall: This is a well-crafted routing skill that is concise, actionable, and well-structured. It provides a clear multi-step procedure with validation, failure modes, and escalation, while appropriately delegating detailed routing logic to a single reference file. The content respects Claude's intelligence throughout and every section earns its place.
plugins/wordpress/.agents/skills/wp-abilities-api/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill is reasonably efficient but includes some unnecessary framing (e.g., 'Inputs required' section, explanatory preambles before reference links). Several steps could be tightened — for instance, the repeated 'read references/X.md' directives add bulk without adding actionable inline content. However, it avoids explaining basic WordPress or PHP concepts Claude already knows. |
| actionability | ██░ 2/3 | The skill provides concrete search patterns (grep strings) and specific hook names, meta keys, and endpoint paths, which is good. However, it lacks executable code examples inline — the actual registration code, REST verification commands, and JS consumption patterns are all deferred to reference files. The procedure reads more like a checklist of decisions than copy-paste-ready implementation guidance. |
| workflow clarity | ███ 3/3 | The procedure is clearly sequenced (6 numbered steps from confirming availability through JS consumption), with explicit verification steps, a dedicated 'Failure modes / debugging' section covering common issues and their causes, and an escalation path. The debugging section effectively serves as a feedback loop for 'ability doesn't show up' scenarios with specific things to check. |
| progressive disclosure | ███ 3/3 | The skill is an excellent overview that delegates detailed content to well-organized, one-level-deep reference files. References are clearly signaled inline at the decision points where they're needed (e.g., 'read references/grouping-heuristic.md first', 'see references/php-registration.md'). All referenced paths match actual bundle files. The structure supports discovery without overwhelming the main document. |
Overall: This is a well-structured orchestration skill that excels at progressive disclosure and workflow clarity — it serves as a clear decision-tree routing to detailed references at the right moments. Its main weakness is that the SKILL.md itself contains almost no executable code or concrete examples inline, relying heavily on references for actionable content. The conciseness could be improved by trimming some of the advisory preambles before reference links.
Suggestions:
- Add at least one inline executable PHP code snippet showing a minimal ability registration (id, label, description, category, meta with show_in_rest) so the skill is actionable without opening a reference file.
- Add a concrete REST verification command or code snippet (e.g., a curl or WP-CLI command to check the endpoint) inline in step 5 rather than deferring entirely to references/rest-api.md.
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'). Overall it's well-structured but could be tighter. |
| actionability | ██░ 2/3 | The skill provides concrete script commands (list_blocks.mjs, detect_wp_project.mjs) and clear procedural steps, but lacks executable code examples inline—most actionable detail is deferred to reference files. The main body reads more as a decision tree with pointers than as copy-paste-ready guidance. |
| workflow clarity | ███ 3/3 | The numbered multi-step procedure is clearly sequenced from triage (step 0) through creation, metadata, registration, rendering, attributes, deprecations, and tooling. Verification is explicit with specific checks (inserter, save/reload, frontend output, lint/build). Failure modes and debugging are addressed with clear pointers. |
| progressive disclosure | ███ 3/3 | The skill is an excellent overview that delegates detailed content to well-organized, one-level-deep reference files. Every reference path matches actual bundle files, references are clearly signaled at the point of need, and no content is buried more than one level deep. |
Overall: This is a well-structured skill with excellent progressive disclosure and workflow clarity—the numbered procedure with verification and failure-mode sections is strong. Its main weakness is that actionable, executable code examples are almost entirely deferred to reference files, leaving the main body somewhat abstract. Minor conciseness improvements could be made by trimming the 'When to use' section and reducing explanatory prose in procedural steps.
Suggestions:
- Add at least one or two inline executable code/command examples (e.g., the create-block scaffold command, or a minimal block.json snippet) so the main body is more immediately actionable without requiring reference file lookups.
- Trim the 'When to use' section or merge it into the procedure intro—it largely restates the skill description and consumes tokens without adding new information.
plugins/wordpress/.agents/skills/wp-block-themes/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ██░ 2/3 | The skill is reasonably efficient but includes some unnecessary explanation (e.g., explaining what block theme indicators are, restating the style hierarchy multiple times across the main file and references). Some sections like 'Inputs required' add modest value but could be tighter. |
| actionability | ██░ 2/3 | The skill provides concrete script commands (detect_wp_project.mjs, detect_block_themes.mjs) and clear folder paths, but lacks executable code examples for actual theme.json edits, template creation, or pattern registration. Most guidance is directional ('Read: references/...') rather than copy-paste ready. |
| workflow clarity | ███ 3/3 | The procedure is clearly numbered and sequenced (0-6), with a triage step, conditional branching (create new theme if needed), and a verification section that includes checking for user customization overrides. The debugging/failure modes section provides a feedback loop for when styles don't apply. |
| progressive disclosure | ███ 3/3 | Excellent progressive disclosure: the main SKILL.md provides a clear overview with well-signaled one-level-deep references to specific topic files (debugging.md, theme-json.md, patterns.md, etc.). All referenced files exist in the bundle and are appropriately scoped. |
Overall: This is a well-structured skill with excellent progressive disclosure and clear workflow sequencing. Its main weakness is that actionability relies heavily on references rather than providing inline executable examples, and some content could be tightened. The bundle structure is well-organized with appropriately sized reference files.
Suggestions:
- Add at least one inline executable example of a theme.json edit (e.g., adding a color preset) so the skill has copy-paste ready guidance without requiring a reference file lookup.
- Consider removing or condensing the 'Inputs required' section since Claude can infer what context it needs from the procedure steps.
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 unnecessary explanation (e.g., the 'When to use' section listing trigger phrases is somewhat redundant, and the server-side rendering section repeats content that exists in the reference file). Some sections could be tightened, but overall it respects Claude's intelligence. |
| actionability | ███ 3/3 | The skill provides concrete, executable PHP and JSON code examples throughout—wp_interactivity_state() calls, block.json configuration, wp_interactivity_data_wp_context() usage, and specific debugging steps. All code is copy-paste ready and contextually complete. |
| workflow clarity | ███ 3/3 | The procedure is clearly sequenced (detect → identify stores → server-side rendering → implement directives → build alignment → debug), with explicit verification steps including triage signal checks, manual smoke tests, and Playwright E2E. Failure modes are well-documented with specific remediation steps, and the debugging section provides a clear checklist. |
| progressive disclosure | ███ 3/3 | Content is well-structured with the main SKILL.md providing an actionable overview and appropriately delegating detailed content to one-level-deep references (references/server-side-rendering.md, references/directives-quickref.md, references/debugging.md). References are clearly signaled at relevant points in the workflow and in the escalation section. |
Overall: This is a well-crafted skill with strong actionability, clear workflow sequencing, and good progressive disclosure to supporting reference files. The main area for improvement is conciseness—some content in the SKILL.md body (particularly the server-side rendering section) overlaps significantly with the reference file, and the 'When to use' trigger list adds marginal value. Overall, it's a high-quality skill that would effectively guide Claude through WordPress Interactivity API tasks.
Suggestions:
- Trim the server-side rendering section in the main SKILL.md to a brief summary with key patterns, since the detailed examples and explanations already exist in references/server-side-rendering.md—this would reduce duplication and save tokens.
plugins/wordpress/.agents/skills/wp-performance/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ███ 3/3 | The skill is lean and efficient throughout. It assumes Claude's competence with WordPress, WP-CLI, and general programming concepts. No unnecessary explanations of what WordPress is or how caching works conceptually. The WordPress 6.9 section is slightly verbose but provides genuinely useful context-specific information that Claude wouldn't inherently know. |
| actionability | ███ 3/3 | Provides concrete WP-CLI commands, specific script invocations, curl commands, and clear tool recommendations. Each step has specific executable actions (e.g., wp doctor check, wp profile stage --fields=stage,time,cache_ratio). References point to detailed files with additional concrete commands and fix patterns. |
| workflow clarity | ███ 3/3 | The procedure is clearly sequenced from guardrails (step 0) through measurement, diagnostics, profiling, fixing, and verification (step 6). Explicit validation checkpoints exist: baseline capture before changes, re-running the same measurements after fixes, checking for PHP errors, and the feedback loop of 'if errors: fix and re-validate.' The escalation and failure modes sections add important safety guardrails. |
| progressive disclosure | ███ 3/3 | Excellent progressive disclosure structure. The main SKILL.md provides a clear overview and workflow, with 10 well-organized reference files covering specific topics (database, cron, object-cache, etc.). All references are one level deep, clearly signaled with 'Read:' directives, and the bundle file listing confirms all referenced paths exist. Content is appropriately split between overview and detail. |
Overall: This is an exceptionally well-structured skill that demonstrates best practices across all dimensions. It provides a clear, sequenced workflow with explicit safety guardrails and validation steps, delegates detailed topic-specific guidance to well-organized reference files, and maintains excellent token efficiency throughout. The only minor note is the WordPress 6.9 section which adds some length but provides genuinely useful version-specific context.
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 or how WordPress works, assumes Claude's competence, and 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 point to files with executable code examples and neon config templates. |
| workflow clarity | ███ 3/3 | The procedure is clearly numbered (steps 0-5) with a logical sequence from discovery through stubs, configuration, fixing, third-party handling, and baseline management. The Verification section includes explicit re-run validation and baseline growth checks, and the failure modes section provides debugging feedback loops. |
| progressive disclosure | ███ 3/3 | The SKILL.md serves as a clear overview with well-signaled one-level-deep references to references/configuration.md, references/third-party-classes.md, and references/wordpress-annotations.md. All referenced files exist in the bundle and contain substantive, complementary content. No nested references or monolithic walls of text. |
Overall: This is an excellent skill file that demonstrates strong structure, conciseness, and actionability. The numbered procedure with clear prerequisites, verification steps, and failure modes creates a robust workflow. The progressive disclosure pattern is well-executed with meaningful reference files that contain executable examples and concrete configuration templates.
plugins/wordpress/.agents/skills/wp-playground/SKILL.md
Review Details
Review Details
| Dimension | Score | Detail |
|---|---|---|
| conciseness | ███ 3/3 | The content is lean and efficient. It avoids explaining what WordPress Playground is conceptually and jumps straight into actionable steps. The 'Inputs required' section is a concise checklist, and each procedure step is tightly written with only necessary context. |
| actionability | ███ 3/3 | Provides fully executable bash commands for every major workflow (server, run-blueprint, build-snapshot), specific flags with explanations, and concrete troubleshooting steps. Commands are copy-paste ready with clear flag options. |
| workflow clarity | ███ 3/3 | Steps are clearly numbered and sequenced with guardrails upfront (step 0). Verification section provides explicit validation steps (check plugin active, re-run with debug verbosity, smoke test). Failure modes section provides a clear troubleshoot-and-fix feedback loop. Escalation criteria are well-defined. |
| progressive disclosure | ███ 3/3 | The SKILL.md provides a clear overview with well-signaled one-level-deep references to bundle files (references/blueprints.md, references/cli-commands.md, references/debugging.md). All referenced paths exist in the bundle and contain appropriate detail-level content. Content is appropriately split between overview and reference material. |
Overall: This is an excellent skill file that is concise, highly actionable, and well-structured. It covers the full lifecycle of WordPress Playground usage (spin-up, blueprints, snapshots, debugging, version switching, browser workflows) with executable commands, clear verification steps, and well-organized progressive disclosure to reference files. The guardrails section and failure modes provide important safety and troubleshooting guidance without being verbose.
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 serves a clear purpose. Bullet points are tight and directive. |
| actionability | ██░ 2/3 | The skill provides clear procedural steps and specific API names (register_setting, $wpdb->prepare, etc.), but lacks executable code examples. The references also contain mostly guidelines and API names rather than copy-paste-ready code snippets. The script references exist but detect_plugins.mjs is empty. |
| workflow clarity | ███ 3/3 | The procedure is clearly sequenced (0-5) with a logical flow from triage to architecture to security to verification. The verification section provides explicit checkpoints (activation without fatals, settings save correctly, uninstall removes intended data, run lint/tests). Failure modes section provides debugging feedback loops for common issues. |
| progressive disclosure | ███ 3/3 | The SKILL.md serves as a clear overview with well-signaled one-level-deep references to specific topic files (references/structure.md, references/lifecycle.md, etc.). All referenced files exist in the bundle and contain appropriately scoped content. Navigation is intuitive and no multi-level chaining occurs. |
Overall: This is a well-structured skill with excellent progressive disclosure and workflow clarity. The main weakness is the lack of executable code examples—both in the SKILL.md and in the reference files—which limits actionability for a development-focused skill. The empty detect_plugins.mjs script is also a concern.
Suggestions:
- Add at least one executable code example per major section (e.g., a complete register_activation_hook snippet, a Settings API registration block, a nonce+capability check pattern) either inline or in the reference files.
- Populate scripts/detect_plugins.mjs with actual detection logic or remove the reference if the script is not yet implemented.
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 the verification section adds a validation checkpoint. However, step 3 ('use the report to select workflow guardrails') lacks specificity on what guardrails to apply for each project kind, and there's no explicit feedback loop for handling invalid JSON output or script failures beyond the brief failure modes section. |
| progressive disclosure | ███ 3/3 | The skill is well-structured with a concise overview that correctly references the schema file and script at one level deep. The bundle structure supports the body content with the schema in references/ and the script in scripts/, and navigation is clear and appropriately signaled. |
Overall: The skill is well-organized, concise, and follows good progressive disclosure patterns with appropriate references to bundle files. Its main weakness is that the detector script is empty (0 bytes), making the skill non-functional as delivered, and step 3 of the procedure could benefit from concrete examples mapping report fields to specific workflow decisions. The verification and failure modes sections are helpful but could be more detailed.
Suggestions:
- Implement the detect_wp_project.mjs script so the skill is actually executable — currently it's 0 bytes
- Add a brief example showing how to map a triage report output to specific workflow guardrails (e.g., 'if kind includes wp-block-theme, ensure theme.json edits follow X pattern')
- Add an example of the expected JSON output from the detector to make the workflow more concrete without requiring the user to read the full schema
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, what WordPress is, or how HTTP methods work. Every section delivers actionable guidance without padding. Bullet points are terse and informative. |
| 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. No copy-paste ready code blocks are provided—everything is described in prose/bullets rather than demonstrated with concrete code snippets. |
| workflow clarity | ███ 3/3 | The procedure is clearly numbered (steps 0-6) with a logical sequence from triage through registration, validation, responses, auth, and client behavior. Verification steps are explicit and specific. Failure modes section provides a debugging feedback loop with specific symptoms mapped to causes and fixes. |
| progressive disclosure | ███ 3/3 | The skill provides a clear overview with well-signaled one-level-deep references to six specific reference files. Each step points to the relevant reference document (e.g., 'Read references/routes-and-endpoints.md'). All referenced files exist in the bundle and contain appropriately summarized content. |
Overall: This is a well-structured, concise skill that effectively guides Claude through WordPress REST API development with clear sequencing, good progressive disclosure to reference files, and useful debugging/failure mode coverage. Its main weakness is the lack of executable code examples—the guidance is specific in naming functions and patterns but doesn't provide copy-paste ready code blocks that demonstrate complete implementations.
Suggestions:
- Add at least one complete, executable code example for route registration (e.g., a full
register_rest_route()call with namespace, callback, permission_callback, and args) in step 2 to improve actionability. - Include a brief code snippet showing
register_rest_fieldorregister_metausage in step 4, as these are common tasks that benefit from concrete examples.
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 efficient. 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 detailed executable guidance is deferred to reference files. The main body contains workflow outlines rather than fully copy-paste-ready command sequences. |
| workflow clarity | ███ 3/3 | Multi-step processes are clearly sequenced with explicit validation checkpoints: the search-replace workflow includes backup → dry-run → execute → flush. Guardrails are front-loaded (step 0), verification is a dedicated section with specific checks, and failure modes with debugging guidance are included. |
| progressive disclosure | ███ 3/3 | Content is excellently structured with a clear 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 navigation is intuitive. |
Overall: This is a well-structured operational skill that effectively balances conciseness with comprehensive coverage. The progressive disclosure pattern is exemplary, with clear routing to reference files for detailed guidance. The main weakness is that actionability in the body itself relies heavily on the reference files for executable details, though the search-replace workflow in the body does include concrete commands.
Suggestions:
- Consider adding one or two more inline executable command examples in the main body (e.g., a complete plugin install command or a db export example) to reduce dependency on reference files for basic operations.
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 synonyms section and the 'When to use' trigger list are somewhat verbose. The MCP server instructions 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 (e.g., wpds://pages, wpds://components/:name) which is helpful, but lacks executable code examples or copy-paste ready snippets. The guidance is mostly directional ('use the MCP server', 'read relevant documentation') rather than showing exactly how to use retrieved information to build UI. |
| workflow clarity | ██░ 2/3 | There is an implicit workflow: check MCP docs → build UI → validate with lint scripts → provide recap. However, the steps are not clearly sequenced, and the validation step ('if the local context provides lint scripts, use them... when possible') is vague and conditional rather than explicit. For a skill involving code generation, a clearer step-by-step process with validation checkpoints would be stronger. |
| progressive disclosure | ██░ 2/3 | The content is reasonably organized with clear section headers (Prerequisites, When to use, Rules, Output). However, there are no bundle files or external references to offload detailed content. The MCP server URIs serve as a form of external reference, which is appropriate, but the skill could benefit from separating detailed component usage patterns or examples into supporting files. |
Overall: This skill provides a reasonable framework for using the WPDS MCP server when building WordPress UIs, with clear MCP resource URIs and appropriate scoping/boundaries. However, it lacks concrete code examples showing how to actually use retrieved WPDS components/tokens in practice, and the workflow could be more explicitly sequenced with stronger validation checkpoints. The content is moderately concise but could be tightened in several areas.
Suggestions:
- Add at least one concrete, executable code example showing how to use a WPDS component retrieved via the MCP server (e.g., importing and rendering a Button component with design tokens).
- Define a clearer numbered workflow: 1) Identify UI requirements → 2) Query MCP for relevant components/tokens → 3) Implement using retrieved patterns → 4) Validate with lint scripts → 5) Summarize decisions.
- Tighten the 'When to use' section by removing redundant examples and the synonym definitions, which Claude can infer from context.
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.
e0aa60d to
3e8e671
Compare
|
1 participant
Automated refresh of vendored skills.sh skills to their latest upstream versions.
Updated lock directories:
plugins/better-authplugins/dev3000plugins/eveplugins/lavishplugins/nosticsplugins/portlessplugins/prismaplugins/slack-agentplugins/slidevplugins/supabaseplugins/tsdownplugins/turborepoplugins/vercel-sandboxplugins/vinextplugins/wordpress(repo root)Generated by
.github/workflows/update-skills.yml→scripts/update-skills.ts.