⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

agent-plugin-eval

fabricioctelles@fabricioctelles⭐ 134 stars· last commit 14d ago· 0 open issues

Audit, score, and compare repositories containing portable Agent Plugins against the official Agent Plugins specification. Use when asked to review a plugin repo, check plugin.json or mcp.json conformance, assess bundled skills and MCP servers, produce an evidence-cited 0–100 plugin scorecard, identify release blockers, or compare two agent plugins side by side.

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐ 134 on GitHubGitHub ↗

Popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

🇧🇷 Versao em Portugues do Brasil

skills.sh agentskill.sh Cloudflare Astro Coolify Google Analytics Google Search Console Substack SEO AI Agents TypeSafe Jev LGPD Security

🧠 AI Agent Skills — Open Source Collection for Claude Code, Cursor, Kiro & OpenCode

26 production-ready skills for AI coding agents. Install with one command, use across Claude Code, Cursor, Kiro, Windsurf, and OpenCode. Each skill teaches the agent to perform complex tasks — from rigorous engineering (pstack) to text humanization, SEO audits, and infrastructure automation.

Agent Skills are a lightweight, open format for extending AI agent capabilities. Each skill is a folder with a SKILL.md file containing metadata and instructions that agents load on demand. Learn more at agentskills.io.

OpenAI plugin: Deslop Writing

Deslop Writing bundles English (human-ai) and Brazilian Portuguese (humanizar) editing workflows in a portable plugin for ChatGPT and Codex, with no MCP server or external evaluator.

codex plugin marketplace add fabricioctelles/skills --ref main
codex plugin add deslop-writing@skilldev-pro

Start a new session after installation, then ask Deslop Writing to edit your draft.

🧠 Skills with TypeSafe Jev Integration

Four skills now support optional integration with TypeSafe Jev — a judgment engine that provides calibrated probability assessments (Score) and categorical classifications (Noul) for subjective evaluation criteria. When Jev is available, these skills use it for nuanced quality judgments; when unavailable, they fall back to heuristic methods.

SkillJev Use CaseQuestions
humanizarPattern severity, voice match quality, rewrite confidence8 Score + 12 Noul
human-aiPattern severity, voice match quality, rewrite confidence8 Score + 12 Noul
slop-evalTell severity, axis quality, section classification8 Score + 16 Noul
agent-plugin-evalUX coherence, documentation clarity, schema design, secret detection7 Score + 19 Noul

Each skill includes:

  • scripts/jev_questions.json — question definitions with context requirements
  • references/jev-integration.md — integration patterns and code examples
  • Discovery protocol in SKILL.md — check jev_available() before use

Available Skills

💡 Startup Idea Security: A — Skills Directory · data-fetching-and-analysis

Analyzes a startup idea through three lenses at once: Paul Graham (pressure test, founder-market fit, brutal validation), Dan Koe (monetization, offer, distribution, sales) and Seth Godin (differentiation, narrative, smallest viable audience). Delivers a pressure test, a monetization path, the minimum viable audience, a remarkability check and an action plan — not a generic canvas.

When to use: validate a startup idea, pressure-test a business model, define the MVP, find the first customers, design the revenue model, plan go-to-market, chase product-market fit, or any variation of "I have an idea".

📄 View full documentation


🔍 GEO Optimization (Generative Engine Optimization) Security: A — Skills Directory · code-quality-and-review

Optimizes digital content and marketing strategies for Generative Engines (LLMs, AI agents) to maximize citations in AI responses.

When to use: improve visibility in AI responses (ChatGPT, Perplexity, Google AI Overview), measure citation rate, align terminology for LLMs, audit pages for AI, create optimized roundups and FAQs.

Improvements in v1.1 (Mar 2026):

  • Moved Guiding Principles and case study context to references/guiding-principles.md
  • Fixed second-person language to imperative form throughout
  • Added explicit default action (Full GEO Audit) when no specific request is made
  • Converted Edge Cases section into a structured Quality Checklist with checkboxes
  • Description optimized to be more concise and actionable (Mar 8)

📄 View full documentation


📰 Substack Expert Security: A — Skills Directory · library-and-api-reference

Substack platform expert. Guides post formatting, SEO optimization (titles, slugs, meta descriptions), native engagement strategies (Notes, Chat), and conversion to paid subscriptions.

When to use: format and optimize Substack posts, improve newsletter SEO (titles, slugs, meta descriptions), grow audience with Notes and recommendations, convert free readers to paid subscribers, customize homepage and welcome emails.

Improvements in v1.1 (Mar 2026):

  • Removed duplicate Overview section and stray Portuguese artifact/orphaned code fence
  • Moved formatting tips to references/formatting-best-practices.md
  • Moved Input/Output Examples to references/seo-output-example.md
  • Added Parameters table with defaults for topic, goal, and language
  • Added explicit Clarify Scope step for ambiguous requests
  • Added Quality Checklist with 8 pre-delivery verification points

📄 View full documentation


☁️ Pier Cloud API Security: A — Skills Directory · library-and-api-reference

Complete guide to consuming the Pier Cloud (Lighthouse) API with authentication, context management, workspaces, an

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • skills/agent-plugin-eval/SKILL.md7.8 KBupstream ↗
    ---
    name: agent-plugin-eval
    description: Audit, score, and compare repositories containing portable Agent Plugins against the official Agent Plugins specification. Use when asked to review a plugin repo, check plugin.json or mcp.json conformance, assess bundled skills and MCP servers, produce an evidence-cited 0–100 plugin scorecard, identify release blockers, or compare two agent plugins side by side.
    ---
    
    # Agent Plugin Evaluation
    
    Treat the portable Agent Plugins specification as the authority. A client-native
    manifest (e.g., `.codex-plugin/plugin.json`, `.claude/settings.json`,
    `.cursor/mcp.json`) does not replace the required root `plugin.json`.
    
    ## Parameters
    
    | Parameter | Description | Default |
    |---|---|---|
    | `target` | Local repository/plugin path or Git URL | Ask if missing |
    | `compare` | Optional second path or Git URL | None |
    | `output` | Scorecard destination | Reply only; write only when requested |
    | `spec_version` | Agent Plugins version to evaluate | Version declared by `plugin.json`, or `1.0.0` |
    
    ## Safety boundary
    
    Audit untrusted repositories statically. Do not run bundled executables, hooks,
    install scripts, package managers, MCP servers, or networked tests unless the
    user explicitly authorizes execution. Redact suspected secret values; report
    only their location and kind. A secret-like key or value is a suspicion, not
    confirmation: do not assign the `FAIL` gate without corroborating evidence such
    as a recognized live credential format, a trusted secret scanner, repository
    history/provenance, or user confirmation. Never test a credential against a
    service merely to confirm it.
    
    ## Workflow
    
    1. **Resolve the plugin root.** Use a local target in place. For a Git URL,
       shallow-clone into a `mktemp -d` directory. A plugin root contains root
       `plugin.json`; if a repo has zero or multiple candidates, report the
       ambiguity instead of guessing. Done when every target maps to one explicit
       plugin root.
    2. **Load the governing rules.** Read `references/spec-checklist.md` and
       `references/rubric.md`. For Agent Plugins `1.0.0`, use the bundled snapshot.
       For another declared version, or when the user asks for the latest spec,
       browse the canonical specification and schemas at `agent-plugins.org` and
       record the evaluated version and retrieval date. The normative text wins if
       it conflicts with JSON Schema.
    3. **Inventory every package path.** Include dotfiles, symlinks, immediate
       skill children, extension namespaces, executable files, and files ignored
       by Git. Resolve every symlink and package-relative path against the plugin
       root. Done when every discovered path is accounted for as portable core,
       client extension, supporting file, or containment violation.
    4. **Run the deterministic scan.** Execute
       `python3 scripts/inspect_plugin.py <plugin-root> --json`. Treat its output as
       evidence leads, not the final judgment. Confirm each reported issue in the
       source and add `file:line` or JSON-pointer evidence. Never weaken a
       normative finding merely because a client happens to accept it.
    5. **Review components completely.** Inspect every immediate
       `skills/*/SKILL.md` and every `mcpServers` entry. Validate Agent Skills
       against their own specification. Assess instructions, resources, scripts,
       MCP configuration, extension isolation, cohesion, and practical utility.
       If `skill-evaluation` is available, it may deepen individual skill-quality
       analysis, but it never replaces this plugin-level rubric.
    6. **Classify conformance before scoring.** Use the exact failure boundaries in
       `references/spec-checklist.md`: `PASS`, `PARTIAL`, or `FAIL`. Keep client
       compatibility separate from portable conformance. A client-specific feature
       may be excellent for that client and still add zero portable coverage.
    7. **Score with cite-or-cut.** Score all applicable rubric criteria from
       `references/rubric.md`. Every score needs specific evidence; every `N/A`
       needs a reason. Run `scripts/score.py` for the weighted result and gate cap;
       do not calculate it by hand. Done when all criteria and all findings are
       reconciled with the conformance status.
    8. **Answer in the requested language.** Read
       `references/output-template.md` and emit that structure. Lead with the
       verdict, distinguish blockers from recommendations, and provide concrete
       fixes. When `compare` is set, evaluate both independently before computing
       deltas; never force the same N/A set on both plugins.
    
    ## Gates and scoring
    
    - `PASS`: no normative violation found; no score cap.
    - `PARTIAL`: non-fatal manifest deviation or invalid/skipped component; final
      score capped at 59.
    - `FAIL`: fatal manifest/package-root failure, root-manifest escape, or
      confirmed embedded credential; final score capped at 39.
    - Keep the uncapped score visible so authors can distinguish design quality
      from release-blocking conformance.
    
    Invoke the calculator with one `criterion:score:weight` triple per criterion:
    
    ```bash
    python3 scripts/score.py --gate partial 1:90:3 2:80:3 3:NA:2
    ```
    
    ## Evaluation with Jev (Optional)
    
    When [TypeSafe Jev](https://github.com/AugmentHCI/typesafe-jev) is available,
    use it for subjective quality criteria. Jev provides calibrated probability
    judgments that augment the deterministic checks.
    
    ### When to use Jev
    
    | Evaluation Type | Use Jev? | Method |
    |-----------------|----------|--------|
    | Axes 1-3 conformance | No | Deterministic (`inspect_plugin.py`) |
    | Axis 4 product quality | **Yes** | Score (UX, docs, errors) |
    | Axis 2 quality criteria | **Yes** | Score (schema design, naming) |
    | Gate classification | **Yes** | Noul (pass/fail categories) |
    | Secret detection | **Yes** | Noul (suspected/not_suspected) |
    | Quality checklist | **Yes** | Noul (present/missing) |
    
    ### Discovery protocol
    
    ```python
    from typesafe import jev_available
    
    if jev_available():
        from typesafe import Score, Noul
        # Use Jev for subjective criteria
    else:
        # Fall back to heuristic scoring
    ```
    
    ### Questions and integration
    
    Questions are defined in `scripts/jev_questions.json`:
    
    - **7 Score questions**: Axis 4 (UX coherence, documentation clarity, error
      handling) and Axis 2 (validation, schema design, naming, API elegance)
    - **20 Noul questions**: Gates (G1-G4), secrets (4), quality checklist (7),
      component validity (4)
    
    Score results (0.0-1.0) are averaged per axis and scaled to the rubric (0-25).
    Noul results provide categorical classifications for gates and checklists.
    
    See `references/jev-integration.md` for full integration patterns and code
    examples.
    
    ### Output format
    
    When Jev is used, the scorecard includes a `jev` section:
    
    ```json
    {
      "jev": {
        "available": true,
        "quality_scores": { "ux_coherence": 0.72, ... },
        "gate_classifications": { "G1": {"label": "conformant", "passed": true} },
        "secret_findings": { "requires_review": false }
      }
    }
    ```
    
    ## Gotchas
    
    - The v1 portable core contains exactly Agent Skills and MCP servers. Hooks,
      commands, agents, apps, marketplaces, and distribution policy are
      client-specific unless placed in a valid extension namespace.
    - Missing optional `skills/` or `mcp.json` is not an error. A present path of
      the wrong filesystem kind is an invalid component type.
    - Unknown root manifest fields are schema violations but have the spec's
      narrow non-fatal handling; most other manifest schema violations reject the
      whole plugin.
    - One invalid skill or MCP server must not be reported as if every independent
      component were invalid.
    - `${PLUGIN_ROOT}` and `${PLUGIN_DATA}` expand only in MCP `args`, `env` values,
      and `cwd`; never in `command`, URLs, or headers.
    - A high-quality client-native plugin can still fail the portable standard when
      root `plugin.json` is absent. Report both facts without averaging them away.
    - Keep possible credentials labeled “suspected” and redacted. A heuristic hit
      alone lowers the security score and demands remediation review, but does not
      be
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/fabricioctelles-skills-skills-agent-plugin-eval.md

// REPO STATS

134 stars
0 open issues
Last commit: 14d ago