feat: publish skill plugins to Tessl registry with badges

[amondnet]

Summary

Publishes 14 skill plugins to the pleaseai Tessl registry workspace and adds tessl badges + marketplace entries, following the pattern established for bun in #194/#196. Also improves the graphite-setup skill based on a Tessl skill review.

Changes

• Tessl manifests — add .tessl-plugin/plugin.json to graphite and 14 more plugins (better-auth, claude-md-management, cubic, fetch, java-development, markitdown, mastra, mcp-dev, nuxt-i18n, please-plugins, portone, zod, web-design, google-workspace). Each lists the plugin's skill dirs under pleaseai/<plugin>.
• Skill name slugs — rename the frontmatter name: of cubic-review, fetch, and find-plugin to their directory slugs (Tessl requires ^[a-z0-9]+(-[a-z0-9]+)*$). Display-only: invocation id is the directory name and triggering is description-based.
• graphite-setup skill — add a numbered, checkpoint-gated onboarding workflow (raised Tessl workflow_clarity 2→3) and point the CI-optimization sketch to Graphite's official action. Trim generic framing from the graphite skill intro.
• Badges + READMEs — add the tessl badge to all 15 plugin READMEs (12 newly scaffolded, 3 edited), badge the 8 existing root-README entries, and add 7 new root entries + install commands.

Notes

• All 16 plugins (these 14 + bun + graphite) are live at https://tessl.io/registry/pleaseai/<plugin>, moderation pending.
• Does NOT touch CHANGELOG or .claude-plugin/plugin.json versions (release-please owns those). The version field in .tessl-plugin/plugin.json mirrors the current manifest version, matching the bun precedent.
• google-workspace and web-design are vendor-synced (SYNC.md); their added .tessl-plugin manifest + README may need re-checking after a future sync.

---

Summary by cubic

Publishes 15 skill plugins to the pleaseai Tessl registry with badges/marketplace entries, improves Graphite setup guidance, and expands Tessl CI (publish + skill review) across all manifest-backed plugins. Also fixes the skill review path to run from the repo root.

• New Features

  • Add .tessl-plugin/plugin.json to 15 plugins (14 new plus graphite) to publish to the pleaseai Tessl registry.
  • Add Tessl badges to plugin READMEs (exclude java-development to preserve upstream sync) and update the root README with marketplace entries and install commands.

• Refactors

  • Tessl compliance: slugify skill frontmatter names (cubic-review, fetch, find-plugin); set claude-md-management author to a URL; keep java-development README byte-identical to upstream.
  • graphite-setup: add a numbered, checkpointed onboarding flow; point CI optimization to Graphite’s official action; trim the graphite intro.
  • CI and release: generalize Tessl publish to any *-v* component with a manifest (skip when no token/manifest); run tesslio/skill-review once from the repo root to cover all changed skills and fix the path double-prefix issue; track .tessl-plugin/plugin.json (and other runtime manifests) in release-please so tags publish the correct versions.

^{Written for commit 2e5035f. Summary will update on new commits.}

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

Project	Deployment	Actions	Updated (UTC)
claude-code-plugins	Ready	Preview, Comment	May 30, 2026 4:17pm

[gemini-code-assist]

Code Review

This pull request adds several new Claude Code plugins (including better-auth, claude-md-management, fetch, google-workspace, graphite, java-development, and others) by introducing their metadata, documentation, and skills, as well as updating the main README.md with Tessl badges and installation instructions. Feedback on these changes recommends replacing the 'email' field with a 'url' in the author metadata for the claude-md-management plugin, and avoiding local modifications to the imported java-development plugin files to preserve the upstream sync contract.

[cubic-dev-ai]

No issues found across 36 files

Confidence score: 5/5

• Automated review surfaced no issues in the provided summaries.
• No files require special attention.

Architecture diagram

sequenceDiagram
    participant User as Claude Code User
    participant Plugin as Claude Code Plugin Engine
    participant Tessl as Tessl Registry
    participant GitHub as GitHub (README repo)
    participant Graphite as Graphite CLI

    Note over User,Graphite: NEW: Tessl Registry Publication Flow

    User->>Plugin: /plugin install <name>@pleaseai

    Plugin->>Tessl: fetch manifest (plugin.json) from pleaseai/<name>
    Tessl-->>Plugin: return .tessl-plugin/plugin.json with skill list
    
    Plugin->>Plugin: validate skill name slugs match `^[a-z0-9]+(-[a-z0-9]+)*$`
    alt slug mismatch
        Plugin->>Plugin: use directory name as invocation id
        Note over Plugin: display name may differ from slug
    end

    Plugin->>Plugin: register skills & install

    Note over Plugin,GitHub: Badge Display Flow
    User->>GitHub: view README.md
    GitHub->>Tessl: request badge image from api.tessl.io/v1/badges/pleaseai/<plugin>
    Tessl-->>GitHub: return badge SVG
    GitHub-->>User: render badge inline

    Note over Plugin,Graphite: graphite-setup Onboarding Flow (CHANGED)
    User->>Plugin: requests Graphite setup
    Plugin->>Graphite: execute checkpoint-gated workflow

    loop step 1 to 5 with checkpoints
        Plugin->>Graphite: apply config (repo settings, branch protection, CI, merge queue)
        Graphite-->>Plugin: result
        Plugin->>Plugin: verify checkpoint condition
        alt checkpoint passes
            Plugin->>Plugin: proceed to next step
        else checkpoint fails
            Plugin->>Plugin: fix current step before moving on
        end
    end

    Plugin->>Graphite: CI optimization setup
    Note over Plugin,Graphite: prefer official Graphite CI Action over hand-rolled API call
    Graphite-->>Plugin: return action reference

    Note over Plugin,Tessl: Vendor-synced Plugins
    opt google-workspace, web-design are vendor-synced
        Plugin->>Plugin: SYNC.md flags need re-check after future sync
    end

Loading

_{Re-trigger cubic}

[github-actions]

🔍 Tessl Skill Review

plugins/cubic/skills/cubic-review/SKILL.md

Review Details

Review Details

Dimension	Score	Detail
conciseness	███ 3/3	The content is lean and efficient. It avoids explaining what code review is or how CLI tools work. Every section serves a purpose—prerequisites, CLI reference, output format, and workflow are all tightly written without padding.
actionability	███ 3/3	Provides specific, executable CLI commands with flags, a concrete JSON output schema, installation commands, and a clear step-by-step workflow. The mutual exclusivity constraint on flags is a useful concrete detail.
workflow clarity	███ 3/3	The 7-step workflow is clearly sequenced with a verification/re-run step at the end (step 7), includes a human approval checkpoint before applying fixes (step 5), and covers the full loop from review to fix to re-verify.
progressive disclosure	██░ 2/3	The skill references /cubic:review for the full command reference, which is good progressive disclosure. However, no bundle files are provided to support this reference, and the skill itself is relatively self-contained without clear signaling of what additional content exists beyond that single reference.

Overall: This is a well-crafted skill that is concise, actionable, and has a clear workflow with proper validation loops. The CLI commands are specific and copy-paste ready, the JSON output format provides a concrete schema, and the workflow includes both human approval checkpoints and re-verification. The only minor weakness is the reference to /cubic:review without supporting bundle files to back it up.

---

plugins/fetch/skills/fetch/SKILL.md

Review Details

Review Details

Dimension	Score	Detail
conciseness	███ 3/3	The content is lean and efficient. It avoids explaining what web fetching is or how MCP works, assumes Claude's competence, and every section serves a clear purpose. The table format is an efficient way to present tool options.
actionability	██░ 2/3	The tool names are concrete and the format selection guide is helpful, but there are no actual invocation examples showing parameters or expected responses. A single concrete example call (e.g., mcp__fetch__fetch_json with a URL and showing the returned structure) would make this fully actionable.
workflow clarity	███ 3/3	This is a simple, single-purpose skill (choose a tool, call it with a URL). The three-step process is clear and unambiguous. There are no destructive or batch operations requiring validation checkpoints, so the simple workflow is appropriate.
progressive disclosure	███ 3/3	For a simple skill under 50 lines with no need for external references, the content is well-organized into logical sections (when to use, available tools, how to use, format selection, fallback). No external files are needed and the structure supports easy scanning.

Overall: This is a well-structured, concise skill that efficiently maps out the available fetch MCP tools and when to use each one. Its main weakness is the lack of concrete invocation examples — showing at least one actual tool call with parameters would elevate actionability. The format selection guide and fallback guidance are practical additions that add value without bloat.

Suggestions:

• Add 1-2 concrete tool invocation examples showing actual parameters (e.g., a fetch_json call to an API endpoint and a fetch_markdown call to a web page) to make the skill fully copy-paste actionable.
• Consider adding a brief note on common parameters these tools accept (e.g., headers, timeout) if any exist, or explicitly state that only a URL is required.

---

plugins/graphite/skills/graphite-setup/SKILL.md

Review Details

Review Details

Dimension	Score	Detail
conciseness	██░ 2/3	The skill is generally well-written and avoids explaining basic concepts, but includes some sections that could be tightened — the 'When to reach for this skill' section largely duplicates the description/triggers, and some explanatory prose (e.g., the Enterprise/IP section, the 'Operating principles for Claude' section) could be more concise. The tables and structured content are efficient, but overall it's slightly verbose for what it conveys.
actionability	██░ 2/3	The skill provides concrete guidance through tables, checklists, and a partial YAML example, but the CI Optimizations code example is explicitly a 'sketch' with ... placeholders rather than executable code, and it defers to external docs for the actual action name and inputs. The branch-ignore YAML snippet is concrete and copy-paste ready, but the most complex configuration (the optimize_ci job) is not fully actionable.
workflow clarity	███ 3/3	The onboarding workflow is exemplary — five clearly sequenced steps, each with an explicit checkpoint that describes what success looks like, and an explicit instruction to fix before moving on. The guardrails section for CI Optimizations describes safe-by-default failure behavior. The 'Operating principles' section adds diagnostic ordering (check branch protection first). This is a strong workflow with validation at every step.
progressive disclosure	██░ 2/3	The skill uses internal anchors and links to external Graphite docs effectively, but all content is inline in a single file with no bundle files for detailed reference material. The CI Optimizations section and branch protection tables could reasonably be split into separate reference files. However, for a standalone skill without bundle files, the internal structure with headers and anchor links provides reasonable navigation.

Overall: This is a well-structured configuration skill with an excellent onboarding workflow featuring explicit checkpoints and validation steps at each stage. Its main weaknesses are the incomplete CI Optimizations code example (a sketch rather than executable code) and moderate verbosity in sections like 'When to reach for this skill' and 'Operating principles.' The content is highly organized and navigable but could benefit from fully actionable code examples and slightly tighter prose.

Suggestions:

• Replace the CI Optimizations 'sketch' with a fully executable GitHub Actions example using the actual Graphite action name and inputs, or explicitly state why this must be looked up from docs (e.g., action name changes frequently).
• Consider removing or condensing the 'When to reach for this skill' section — it largely restates the skill's trigger conditions which are metadata concerns, not actionable content for Claude during execution.

---

plugins/graphite/skills/graphite/SKILL.md

Review Details

Review Details

Dimension	Score	Detail
conciseness	██░ 2/3	The skill is generally well-written and avoids explaining basic concepts, but it's quite long (~200+ lines) with some sections that could be tightened. For example, the worktrees and multiple trunks sections include details that are somewhat niche and could be deferred. The navigation table and reorganizing table are efficient, but overall the document could be more selective about what to include in the main file.
actionability	███ 3/3	Excellent actionability throughout — every section provides concrete, executable commands with flags and aliases. The golden path example is copy-paste ready, conflict resolution steps are specific, and the tables provide exact command syntax. No pseudocode or vague instructions.
workflow clarity	███ 3/3	Multi-step workflows are clearly sequenced with explicit validation checkpoints. The 'golden path' create→submit flow is clear, conflict resolution has a feedback loop (resolve → gt add → gt continue, or gt abort), and the sync workflow explains what happens at each step. The 'Operating principles for Claude' section adds important guardrails like running gt ls before destructive operations.
progressive disclosure	██░ 2/3	The content is well-organized with clear section headers and logical grouping, but everything is in a single monolithic file with no references to supporting documents. Advanced topics like worktrees, multiple trunks, collaborating on others' stacks, and the full reorganizing table could be split into separate reference files to keep the main skill leaner.

Overall: This is a high-quality, comprehensive skill that provides excellent actionable guidance for Graphite CLI workflows. Its main strength is the concrete, executable commands with clear workflows and validation steps. The primary weakness is that it's quite long for a single file — advanced topics like worktrees, multiple trunks, and collaboration could be split into referenced files to improve token efficiency and progressive disclosure.

Suggestions:

• Split advanced/niche sections (worktrees, multiple trunks, collaborating on others' stacks) into separate referenced files to reduce the main skill's token footprint.
• Trim minor redundancies — e.g., the 'Manual restack' section's bullet list of when-to-use could be condensed since the scenarios are already implied by earlier sections.

---

plugins/please-plugins/skills/find-plugin/SKILL.md

Review Details

Review Details

Dimension	Score	Detail
conciseness	██░ 2/3	Generally efficient but includes some unnecessary elements like the full plugin categories table (which could be discovered from the marketplace.json itself) and some slightly verbose explanations. The step-by-step structure is mostly lean but the categories table and some formatting add bulk.
actionability	███ 3/3	Provides fully executable bash commands for every step — reading the catalog, searching skills with grep/find, checking installed status with jq, and installing plugins. The output format templates are concrete and copy-paste ready.
workflow clarity	███ 3/3	Clear 5-step sequential workflow with well-defined inputs and outputs at each stage. The process flows logically from discovery → search → rank → present → install, with a clear fallback path when no plugin matches. The deduplication note between Steps 1 and 2 serves as a validation checkpoint.
progressive disclosure	██░ 2/3	Content is well-structured with clear sections, but the categories table and all details are inline in a single file. For a skill of this length (~100 lines of content), the inline approach is borderline acceptable, but the categories reference table could reasonably be a separate file. No bundle files exist to offload to.

Overall: This is a well-crafted skill with strong actionability and clear workflow sequencing. Every step includes executable commands and concrete output formats. The main weakness is moderate verbosity — the categories table and some explanatory text could be trimmed since Claude can derive much of this from the marketplace.json itself.

Suggestions:

• Consider removing or significantly trimming the Plugin Categories table, since Claude will read marketplace.json and can derive categories dynamically — this saves ~20 lines of potentially stale content.
• The 'Semantic match' scoring criterion in Step 3 is vague compared to the other two — either remove it or provide a concrete heuristic for how to evaluate semantic relevance.

---

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.