New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Protocolsio Integration

by davila7 in davila7/claude-code-templates

Integration with protocols.io API for managing scientific protocols.

MITAuto-check passedBackend & APIs

Install Protocolsio Integration

skills CLI
$ npx skills add davila7/claude-code-templates --skill protocolsio-integration -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install davila7/claude-code-templates protocolsio-integration --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/davila7/claude-code-templates.git skills-src && mkdir -p .claude/skills && cp -r skills-src/cli-tool/components/skills/scientific/protocolsio-integration .claude/skills/protocolsio-integration && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
protocolsio-integration
GitHub stars
32k
Used in
10 other repos
Token cost
~3.7k tokens
SKILL.md length
1,355 words
Files
7 (incl. references)
Skills in repo
478
Repo updated
First seen
Licence
MIT

At a glance

Integration with protocols.io API for managing scientific protocols.

  • Works in 9 steps: Authentication & Access → Protocol Operations → Discussions & Collaboration → …
  • Backend & APIs work in your project
  • SKILL.md covers Overview, When to Use This Skill, Core Capabilities and Getting Started, plus 8 more sections
  • Reaches protocols.io; needs CLIENT_ACCESS_TOKEN and OAUTH_ACCESS_TOKEN

What it does

Protocolsio Integration is an agent skill from davila7/claude-code-templates. Integration with protocols.io API for managing scientific protocols. This skill should be used when working with protocols.io to search, create, update, or publish protocols; manage protocol steps and materials; handle discussions and comments; organize workspaces; upload and manage files; or integrate protocols.io functionality into workflows. Applicable for protocol discovery, collaborative protocol development, experiment tracking, lab protocol management, and scientific documentation.

Its SKILL.md is about 3.7k tokens, which your agent loads only when the skill is triggered. The skill folder holds 7 other files, including reference files (for example `references/additional_features.md`, `references/authentication.md` and `references/discussions.md`).

It sits in Backend & APIs. The repository describes itself as: CLI tool for configuring and monitoring Claude Code. The licence is MIT.

When your agent uses it

  • Backend & APIs work in your project

Example prompts

  • “/protocolsio-integration”

Requirements

  • Python 3
  • A credential in CLIENT_ACCESS_TOKEN
  • A credential in OAUTH_ACCESS_TOKEN

Workflow steps

9 steps, taken from the step headings in SKILL.md.

  1. Authentication & Access
  2. Protocol Operations
  3. Discussions & Collaboration
  4. Workspace Management
  5. File Operations
  6. Additional Features
  7. Authentication Setup
  8. Identify Your Use Case
  9. Implement Integration

What it can do on your machine

Read from SKILL.md and the folder at commit 46b4d8b. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are python).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • protocols.io

    Also links to:

    • apidoc.protocols.io

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • CLIENT_ACCESS_TOKEN
    • OAUTH_ACCESS_TOKEN

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Protocolsio Integration loads about 3.7k tokens when it runs, and up to ~16k if it reads all its reference files. Until then it costs about 129 tokens; SKILL.md has 1,355 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~129
When it runs · the whole SKILL.md, loaded when a task matches
~3.7k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~16k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from davila7/claude-code-templates at commit 46b4d8b, republished under its MIT licence (© davila7). 1,355 words, ~3,708 tokens.

Download SKILL.mdSave it as .claude/skills/protocolsio-integration/SKILL.md (or your agent's skills folder). This skill also uses 6 other files; get the full folder from GitHub.
name
protocolsio-integration
description
Integration with protocols.io API for managing scientific protocols. This skill should be used when working with protocols.io to search, create, update, or publish protocols; manage protocol steps and materials; handle discussions and comments; organize workspaces; upload and manage files; or integrate protocols.io functionality into workflows. Applicable for protocol discovery, collaborative protocol development, experiment tracking, lab protocol management, and scientific documentation.

Protocols.io Integration

Overview

Protocols.io is a comprehensive platform for developing, sharing, and managing scientific protocols. This skill provides complete integration with the protocols.io API v3, enabling programmatic access to protocols, workspaces, discussions, file management, and collaboration features.

When to Use This Skill

Use this skill when working with protocols.io in any of the following scenarios:

  • Protocol Discovery: Searching for existing protocols by keywords, DOI, or category
  • Protocol Management: Creating, updating, or publishing scientific protocols
  • Step Management: Adding, editing, or organizing protocol steps and procedures
  • Collaborative Development: Working with team members on shared protocols
  • Workspace Organization: Managing lab or institutional protocol repositories
  • Discussion & Feedback: Adding or responding to protocol comments
  • File Management: Uploading data files, images, or documents to protocols
  • Experiment Tracking: Documenting protocol executions and results
  • Data Export: Backing up or migrating protocol collections
  • Integration Projects: Building tools that interact with protocols.io

Core Capabilities

This skill provides comprehensive guidance across five major capability areas:

1. Authentication & Access

Manage API authentication using access tokens and OAuth flows. Includes both client access tokens (for personal content) and OAuth tokens (for multi-user applications).

Key operations:

  • Generate authorization links for OAuth flow
  • Exchange authorization codes for access tokens
  • Refresh expired tokens
  • Manage rate limits and permissions

Reference: Read references/authentication.md for detailed authentication procedures, OAuth implementation, and security best practices.

2. Protocol Operations

Complete protocol lifecycle management from creation to publication.

Key operations:

  • Search and discover protocols by keywords, filters, or DOI
  • Retrieve detailed protocol information with all steps
  • Create new protocols with metadata and tags
  • Update protocol information and settings
  • Manage protocol steps (create, update, delete, reorder)
  • Handle protocol materials and reagents
  • Publish protocols with DOI issuance
  • Bookmark protocols for quick access
  • Generate protocol PDFs

Reference: Read references/protocols_api.md for comprehensive protocol management guidance, including API endpoints, parameters, common workflows, and examples.

3. Discussions & Collaboration

Enable community engagement through comments and discussions.

Key operations:

  • View protocol-level and step-level comments
  • Create new comments and threaded replies
  • Edit or delete your own comments
  • Analyze discussion patterns and feedback
  • Respond to user questions and issues

Reference: Read references/discussions.md for discussion management, comment threading, and collaboration workflows.

4. Workspace Management

Organize protocols within team workspaces with role-based permissions.

Key operations:

  • List and access user workspaces
  • Retrieve workspace details and member lists
  • Request access or join workspaces
  • List workspace-specific protocols
  • Create protocols within workspaces
  • Manage workspace permissions and collaboration

Reference: Read references/workspaces.md for workspace organization, permission management, and team collaboration patterns.

5. File Operations

Upload, organize, and manage files associated with protocols.

Key operations:

  • Search workspace files and folders
  • Upload files with metadata and tags
  • Download files and verify uploads
  • Organize files into folder hierarchies
  • Update file metadata
  • Delete and restore files
  • Manage storage and organization

Reference: Read references/file_manager.md for file upload procedures, organization strategies, and storage management.

6. Additional Features

Supplementary functionality including profiles, notifications, and exports.

Key operations:

  • Manage user profiles and settings
  • Query recently published protocols
  • Create and track experiment records
  • Receive and manage notifications
  • Export organization data for archival

Reference: Read references/additional_features.md for profile management, publication discovery, experiment tracking, and data export.

Getting Started

Step 1: Authentication Setup

Before using any protocols.io API functionality:

  1. Obtain an access token (CLIENT_ACCESS_TOKEN or OAUTH_ACCESS_TOKEN)
  2. Read references/authentication.md for detailed authentication procedures
  3. Store the token securely
  4. Include in all requests as: Authorization: Bearer YOUR_TOKEN
Step 2: Identify Your Use Case

Determine which capability area addresses your needs:

  • Working with protocols? → Read references/protocols_api.md
  • Managing team protocols? → Read references/workspaces.md
  • Handling comments/feedback? → Read references/discussions.md
  • Uploading files/data? → Read references/file_manager.md
  • Tracking experiments or profiles? → Read references/additional_features.md
Step 3: Implement Integration

Follow the guidance in the relevant reference files:

  • Each reference includes detailed endpoint documentation
  • API parameters and request/response formats are specified
  • Common use cases and workflows are provided with examples
  • Best practices and error handling guidance included

Base URL and Request Format

All API requests use the base URL:

https://protocols.io/api/v3

All requests require the Authorization header:

Authorization: Bearer YOUR_ACCESS_TOKEN

Most endpoints support JSON request/response format with Content-Type: application/json.

Content Format Options

Many endpoints support a content_format parameter to control how protocol content is returned:

  • json: Draft.js JSON format (default)
  • html: HTML format
  • markdown: Markdown format

Include as query parameter: ?content_format=html

Rate Limiting

Be aware of API rate limits:

  • Standard endpoints: 100 requests per minute per user
  • PDF endpoint: 5 requests/minute (signed-in), 3 requests/minute (unsigned)

Implement exponential backoff for rate limit errors (HTTP 429).

Common Workflows

Workflow 1: Import and Analyze Protocol

To analyze an existing protocol from protocols.io:

  1. Search: Use GET /protocols with keywords to find relevant protocols
  2. Retrieve: Get full details with GET /protocols/{protocol_id}
  3. Extract: Parse steps, materials, and metadata for analysis
  4. Review discussions: Check GET /protocols/{id}/comments for user feedback
  5. Export: Generate PDF if needed for offline reference

Reference files: protocols_api.md, discussions.md

Show full SKILL.md (573 more words)Show less
Workflow 2: Create and Publish Protocol

To create a new protocol and publish with DOI:

  1. Authenticate: Ensure you have valid access token (see authentication.md)
  2. Create: Use POST /protocols with title and description
  3. Add steps: For each step, use POST /protocols/{id}/steps
  4. Add materials: Document reagents in step components
  5. Review: Verify all content is complete and accurate
  6. Publish: Issue DOI with POST /protocols/{id}/publish

Reference files: protocols_api.md, authentication.md

Workflow 3: Collaborative Lab Workspace

To set up team protocol management:

  1. Create/join workspace: Access or request workspace membership (see workspaces.md)
  2. Organize structure: Create folder hierarchy for lab protocols (see file_manager.md)
  3. Create protocols: Use POST /workspaces/{id}/protocols for team protocols
  4. Upload files: Add experimental data and images
  5. Enable discussions: Team members can comment and provide feedback
  6. Track experiments: Document protocol executions with experiment records

Reference files: workspaces.md, file_manager.md, protocols_api.md, discussions.md, additional_features.md

Workflow 4: Experiment Documentation

To track protocol executions and results:

  1. Execute protocol: Perform protocol in laboratory
  2. Upload data: Use File Manager API to upload results (see file_manager.md)
  3. Create record: Document execution with POST /protocols/{id}/runs
  4. Link files: Reference uploaded data files in experiment record
  5. Note modifications: Document any protocol deviations or optimizations
  6. Analyze: Review multiple runs for reproducibility assessment

Reference files: additional_features.md, file_manager.md, protocols_api.md

Workflow 5: Protocol Discovery and Citation

To find and cite protocols in research:

  1. Search: Query published protocols with GET /publications
  2. Filter: Use category and keyword filters for relevant protocols
  3. Review: Read protocol details and community comments
  4. Bookmark: Save useful protocols with POST /protocols/{id}/bookmarks
  5. Cite: Use protocol DOI in publications (proper attribution)
  6. Export PDF: Generate formatted PDF for offline reference

Reference files: protocols_api.md, additional_features.md

Python Request Examples

python
import requests

token = "YOUR_ACCESS_TOKEN"
headers = {"Authorization": f"Bearer {token}"}

# Search for CRISPR protocols
response = requests.get(
    "https://protocols.io/api/v3/protocols",
    headers=headers,
    params={
        "filter": "public",
        "key": "CRISPR",
        "page_size": 10,
        "content_format": "html"
    }
)

protocols = response.json()
for protocol in protocols["items"]:
    print(f"{protocol['title']} - {protocol['doi']}")
Create New Protocol
python
import requests

token = "YOUR_ACCESS_TOKEN"
headers = {
    "Authorization": f"Bearer {token}",
    "Content-Type": "application/json"
}

# Create protocol
data = {
    "title": "CRISPR-Cas9 Gene Editing Protocol",
    "description": "Comprehensive protocol for CRISPR gene editing",
    "tags": ["CRISPR", "gene editing", "molecular biology"]
}

response = requests.post(
    "https://protocols.io/api/v3/protocols",
    headers=headers,
    json=data
)

protocol_id = response.json()["item"]["id"]
print(f"Created protocol: {protocol_id}")
Upload File to Workspace
python
import requests

token = "YOUR_ACCESS_TOKEN"
headers = {"Authorization": f"Bearer {token}"}

# Upload file
with open("data.csv", "rb") as f:
    files = {"file": f}
    data = {
        "folder_id": "root",
        "description": "Experimental results",
        "tags": "experiment,data,2025"
    }

    response = requests.post(
        "https://protocols.io/api/v3/workspaces/12345/files/upload",
        headers=headers,
        files=files,
        data=data
    )

file_id = response.json()["item"]["id"]
print(f"Uploaded file: {file_id}")

Error Handling

Implement robust error handling for API requests:

python
import requests
import time

def make_request_with_retry(url, headers, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.get(url, headers=headers)

            if response.status_code == 200:
                return response.json()
            elif response.status_code == 429:  # Rate limit
                retry_after = int(response.headers.get('Retry-After', 60))
                time.sleep(retry_after)
                continue
            elif response.status_code >= 500:  # Server error
                time.sleep(2 ** attempt)  # Exponential backoff
                continue
            else:
                response.raise_for_status()

        except requests.exceptions.RequestException as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(2 ** attempt)

    raise Exception("Max retries exceeded")

Reference Files

Load the appropriate reference file based on your task:

  • authentication.md: OAuth flows, token management, rate limiting
  • protocols_api.md: Protocol CRUD, steps, materials, publishing, PDFs
  • discussions.md: Comments, replies, collaboration
  • workspaces.md: Team workspaces, permissions, organization
  • file_manager.md: File upload, folders, storage management
  • additional_features.md: Profiles, publications, experiments, notifications

To load a reference file, read the file from the references/ directory when needed for specific functionality.

Best Practices

  1. Authentication: Store tokens securely, never in code or version control
  2. Rate Limiting: Implement exponential backoff and respect rate limits
  3. Error Handling: Handle all HTTP error codes appropriately
  4. Data Validation: Validate input before API calls
  5. Documentation: Document protocol steps thoroughly
  6. Collaboration: Use comments and discussions for team communication
  7. Organization: Maintain consistent naming and tagging conventions
  8. Versioning: Track protocol versions when making updates
  9. Attribution: Properly cite protocols using DOIs
  10. Backup: Regularly export important protocols and workspace data

Additional Resources

Troubleshooting

Authentication Issues:

  • Verify token is valid and not expired
  • Check Authorization header format: Bearer YOUR_TOKEN
  • Ensure appropriate token type (CLIENT vs OAUTH)

Rate Limiting:

  • Implement exponential backoff for 429 errors
  • Monitor request frequency
  • Consider caching frequent requests

Permission Errors:

  • Verify workspace/protocol access permissions
  • Check user role in workspace
  • Ensure protocol is not private if accessing without permission

File Upload Failures:

  • Check file size against workspace limits
  • Verify file type is supported
  • Ensure multipart/form-data encoding is correct

For detailed troubleshooting guidance, refer to the specific reference files covering each capability area.

© davila7, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 6 other files (references) in cli-tool/components/skills/scientific/protocolsio-integration of davila7/claude-code-templates.

  • SKILL.md
  • references/additional_features.md
  • references/authentication.md
  • references/discussions.md
  • references/file_manager.md
  • references/protocols_api.md
  • references/workspaces.md

Open the folder on GitHubat commit 46b4d8b

Used in 10 other repositories

We found 15 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 10 other GitHub owners. This page covers the copy in davila7/claude-code-templates, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Protocolsio Integration next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Protocolsio Integration compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Protocolsio Integration this skilldavila7/claude-code-templates32k10 repos~3.7kAutomated safety check: PassMIT
Configuring Horizoncoollabsio/coolify63k4 repos~898Automated safety check: PassMIT
Nestjs Best Practicesrolling-scopes/rsschool-app10k6 repos~1.2kAutomated safety check: PassMIT
Sub2API AdminWei-Shaw/sub2api44k1 repos~717Automated safety check: PassLGPL-3.0
Firecrawl Build Onboardingfirecrawl/firecrawl190k1 repos~1.4kAutomated safety check: NotesISC
Obsidian BasesAtmosphere/atmosphere3.8k22 repos~3.2kAutomated safety check: PassApache-2.0

Similar skills

  • Configuring Horizon

    coollabsio/coolify

    A skill your agent uses whenever the user mentions Horizon by name in a Laravel context.

    63k GitHub starsUsed in 4 repos~898 tokens
    Backend & APIsAuto-check passed

  • Nestjs Best Practices

    rolling-scopes/rsschool-app

    NestJS best practices and architecture patterns for building production-ready applications.

    10k GitHub starsUsed in 6 repos~1.2k tokens
    Backend & APIsAuto-check passed

  • Sub2API Admin

    Wei-Shaw/sub2api

    Manages a Sub2API deployment from the command line: accounts, redeem and invitation codes, groups, proxies, imports, exports and raw admin API calls.

    44k GitHub starsUsed in 1 repo~717 tokens
    Backend & APIsAuto-check passed

  • Firecrawl Build Onboarding

    firecrawl/firecrawl

    Gets Firecrawl working in a project: signs you in through the browser, saves FIRECRAWL_API_KEY to .env and picks the first SDK or REST path.

    190k GitHub starsUsed in 1 repo~1.4k tokens
    Backend & APIsAuto-check: notes

  • Obsidian Bases

    Atmosphere/atmosphere

    Create and edit Obsidian Bases (.base files) with views, filters, formulas, and summaries.

    3.8k GitHub starsUsed in 22 repos~3.2k tokens
    Backend & APIsAuto-check passed

  • Fortify Development

    coollabsio/coolify

    ACTIVATE when the user works on authentication in Laravel. An agent skill from coollabsio/coolify.

    63k GitHub starsUsed in 4 repos~1.9k tokens
    Backend & APIsAuto-check passed

More from davila7/claude-code-templates

All 478 skills in this repo

  • Perplexity Web Search

    davila7/claude-code-templates

    Runs web-grounded searches through Perplexity's Sonar models over OpenRouter for current events, recent literature and cited facts beyond the model's training cutoff.

    32k GitHub starsUsed in 11 repos~3.5k tokens
    Auto-check: notes

  • Neuropixels Data Analysis

    davila7/claude-code-templates

    Analyzes Neuropixels recordings from SpikeGLX or Open Ephys through preprocessing, drift correction, Kilosort4 spike sorting, quality metrics and curation.

    32k GitHub starsUsed in 9 repos~2.8k tokens
    Auto-check passed

  • Scientific Venue Templates

    davila7/claude-code-templates

    Supplies LaTeX templates and formatting rules for journals, conferences, posters, and grant proposals, then can check a draft against them.

    32k GitHub starsUsed in 9 repos~5.1k tokens
    Auto-check: notes

  • Brand Voice Content Creator

    davila7/claude-code-templates

    Analyzes a brand's existing writing to lock in a consistent voice, then builds SEO blog posts and platform-specific social content around it.

    32k GitHub starsUsed in 3 repos~1.9k tokens
    Auto-check passed

  • CAPA Officer

    davila7/claude-code-templates

    Guides corrective and preventive action (CAPA) work in a quality management system, from initiation and root cause analysis through effectiveness verification.

    32k GitHub starsUsed in 1 repo~2k tokens
    Auto-check passed

  • Fda Consultant Specialist

    davila7/claude-code-templates

    Senior FDA consultant and specialist for medical device companies including HIPAA compliance and requirement management.

    32k GitHub starsUsed in 1 repo~2.7k tokens
    Auto-check passed

Categories

Questions about Protocolsio Integration

What does Protocolsio Integration do?

Integration with protocols.io API for managing scientific protocols. Protocolsio Integration is an agent skill from davila7/claude-code-templates.io API for managing scientific protocols.

When should I use Protocolsio Integration?

Protocolsio Integration fits situations like: backend & APIs work in your project.

How do I install Protocolsio Integration in Claude Code?

Run `npx skills add davila7/claude-code-templates --skill protocolsio-integration -a claude-code`. Or copy the skill folder (cli-tool/components/skills/scientific/protocolsio-integration in davila7/claude-code-templates) into .claude/skills/protocolsio-integration in your project. Claude Code loads it when a task matches its description.

How do I install Protocolsio Integration in Codex?

Run `npx skills add davila7/claude-code-templates --skill protocolsio-integration -a codex`. Or copy the skill folder (cli-tool/components/skills/scientific/protocolsio-integration in davila7/claude-code-templates) into .agents/skills/protocolsio-integration in your project. Codex loads it when a task matches its description.

Can I use Protocolsio Integration in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add davila7/claude-code-templates --skill protocolsio-integration -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/protocolsio-integration, .gemini/skills/protocolsio-integration, .github/skills/protocolsio-integration and .opencode/skills/protocolsio-integration in your project.

What does Protocolsio Integration need to run?

Going by SKILL.md and its folder, Protocolsio Integration needs credentials named CLIENT_ACCESS_TOKEN and OAUTH_ACCESS_TOKEN. Our summary lists: Python 3; A credential in CLIENT_ACCESS_TOKEN; A credential in OAUTH_ACCESS_TOKEN.

Does Protocolsio Integration access the network?

SKILL.md names 2 domains. In commands or code: protocols.io; the agent is likely to contact it when it follows the instructions. As links in the text: apidoc.protocols.io. This is read from the text; nothing was executed.

Is Protocolsio Integration safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Protocolsio Integration use?

Protocolsio Integration is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Protocolsio Integration use?

About 3.7k tokens (SKILL.md is roughly 15k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 12k tokens, read only when the agent opens those files.

What are the alternatives to Protocolsio Integration?

Skills that share tags, products or a category with Protocolsio Integration: Configuring Horizon (coollabsio/coolify, 63k stars), Nestjs Best Practices (rolling-scopes/rsschool-app, 10k stars), Sub2API Admin (Wei-Shaw/sub2api, 44k stars) and Firecrawl Build Onboarding (firecrawl/firecrawl, 190k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Protocolsio Integration?

davila7 (a GitHub user) maintains it in davila7/claude-code-templates, which has 32,483 GitHub stars. The repository holds 478 skills in this directory. The repository was last updated on October 9, 2026.

Source: davila7/claude-code-templates on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.