Deepfreeze

Deepfreeze

Load skills from the internet without installing them permanently. Skills are cached in a session-scoped temp directory and cleaned up on demand.

CRITICAL: Temporary Only — Never Install

This skill exists to PREVENT permanent installation. You MUST:

• NEVER run npx skills add, npx skills install, or any install command
• NEVER copy files into ~/.config/kilo/skills/ or ~/.kilocode/skills/ (outside .temp/)
• NEVER modify package.json, .skill-lock.json, or any config to register a skill
• NEVER suggest the user permanently install a skill you fetched temporarily
• If the temp loading fails, report the error — do NOT fall back to permanent installation

ALL skills — including those from the Default Skill Library below — are temporary. They go into .temp/, they load into context for the current session, and they get cleaned up. Nothing persists permanently.

Session Limit: Max 50 Skills

A maximum of 50 temp skills can be loaded per session. Before fetching a new skill:

1. Count existing skills in .temp/ directory
2. If count >= 50, refuse and tell the user: "Session limit reached (50 temp skills). Say 'clear temp skills' to free up slots, then try again."
3. If count < 50, proceed with fetch

Auto-Cleanup on Session Restart

Skills are automatically removed when a new agent session starts. The CLI tracks sessions via a .session marker file in the temp directory.

How It Works

1. On every load, list, or clear command, the CLI checks the session marker
2. If the session ID has changed (new agent session), all old temp skills are deleted first
3. Session ID is derived from OPENCLAUDE_SESSION_ID, CLAUDE_SESSION_ID, or KILO_SESSION_ID environment variables
4. If no env var is set, uses an auto-generated ID based on parent PID and time window (4-hour buckets)

Session Commands

deepfreeze session    # Show current session info, skill count, and session source

For Agent Developers

To ensure clean session boundaries, set a session environment variable before invoking deepfreeze:

# Set a unique session ID for this agent conversation
export OPENCLAUDE_SESSION_ID="session-$(date +%s)-$$"
deepfreeze load https://github.com/user/repo

Or if your agent framework provides a session ID, pass it through:

OPENCLAUDE_SESSION_ID="$AGENT_SESSION_ID" deepfreeze load <url>

Manual Cleanup

deepfreeze clear         # Remove all temp skills (frozen skills untouched)
deepfreeze clear --all   # Remove ALL skills (temp + frozen)

Deep Freeze: Pin Skills Across Sessions

Frozen skills persist across sessions and are protected from auto-cleanup. Use this for skills you always want available.

Commands

deepfreeze freeze <name>     # Pin a temp skill → moves to .frozen/
deepfreeze unfreeze <name>   # Unpin → returns to .temp/ (auto-cleanup again)
deepfreeze frozen            # List all frozen (pinned) skills

When to Freeze

• Freeze a skill when you want it available in every session without re-fetching
• Unfreeze when you no longer need it pinned, or want to update it
• Frozen skills are not counted toward the 50 temp skill limit

Example Workflow

deepfreeze load https://github.com/user/repo    # Load as temp
deepfreeze freeze pdf                            # Pin it
deepfreeze frozen                                # Confirm it's frozen
# ... session ends, new session starts ...
deepfreeze list                                  # Temp is empty (auto-cleared)
deepfreeze frozen                                # 'pdf' still here!
deepfreeze unfreeze pdf                          # Return to temp when done

For Agent Developers

When the user says "freeze this skill" or "pin this skill", run:

deepfreeze freeze <skill-name>

When they say "unfreeze" or "unpin":

deepfreeze unfreeze <skill-name>

Quick Start

User: load temp skill from https://github.com/vercel-labs/agent-skills
Agent: Fetches, caches, and loads the skill for this session.

Supported URL formats:

• GitHub repo: https://github.com/user/repo → fetches SKILL.md from repo root
• GitHub subfolder: https://github.com/user/repo/tree/main/path → fetches SKILL.md from that path
• Raw URL: https://example.com/SKILL.md → fetches directly
• Raw GitHub: https://raw.githubusercontent.com/... → fetches directly

URL Resolution

When the user provides a URL, resolve it to a raw SKILL.md URL using these rules:

1. GitHub blob URL (github.com/user/repo or github.com/user/repo/tree/branch/path):

   • Extract user, repo, branch (default: main), and path (default: root)
   • Convert to: https://raw.githubusercontent.com/{user}/{repo}/{branch}/{path}/SKILL.md
   • If the path already ends with .md, use it as-is (don't append /SKILL.md)

2. Raw GitHub URL (raw.githubusercontent.com/...):

   • Use as-is

3. Any other HTTP(S) URL:

   • Use as-is (must point to SKILL.md content)

Resolution Examples

Fetching & Caching

Step 0: Check Session Limit

Before fetching, count existing temp skills:

# On Windows (PowerShell)
$count = (Get-ChildItem "$HOME\.config\kilo\skills\.temp" -Directory -ErrorAction SilentlyContinue).Count
if ($count -ge 50) { Write-Host "LIMIT REACHED: $count/50 temp skills loaded. Run 'clear temp skills' to free slots." }

# On macOS/Linux
count=$(ls -d ~/.config/kilo/skills/.temp/*/ 2>/dev/null | wc -l)
if [ "$count" -ge 50 ]; then echo "LIMIT REACHED: $count/50 temp skills loaded. Run 'clear temp skills' to free slots."; fi

If limit reached, STOP and inform the user. Do NOT fetch.

Step 1: Check Cache First

Before fetching, check if the .temp directory exists and create it if needed:

# On Windows (PowerShell)
New-Item -ItemType Directory -Path "$HOME\.config\kilo\skills\.temp" -Force

# On macOS/Linux
mkdir -p ~/.config/kilo/skills/.temp

Use the appropriate command for the current platform. The bash tool abstracts this — just run the command.

Step 2: Fetch the SKILL.md Content

Use the webfetch tool with the resolved URL:

webfetch(url=resolved_url, format="text")

Step 3: Validate the Content

The fetched content MUST contain valid SKILL.md frontmatter. Check for:

• Starts with ---
• Contains name: field
• Contains description: field
• Ends the frontmatter block with ---

If validation fails, report the error to the user and stop.

Step 4: Extract Skill Name

Parse the name: field from the frontmatter. This becomes the cache directory name.

Step 5: Save to Cache

# On Windows (PowerShell)
$skillDir = "$HOME\.config\kilo\skills\.temp\{skill-name}"
New-Item -ItemType Directory -Path $skillDir -Force
Set-Content -Path "$skillDir\SKILL.md" -Value $fetchedContent

# On macOS/Linux
mkdir -p ~/.config/kilo/skills/.temp/{skill-name}
echo "$fetchedContent" > ~/.config/kilo/skills/.temp/{skill-name}/SKILL.md

Replace {skill-name} with the actual name extracted from frontmatter. Use the Write tool if available, otherwise use platform-appropriate shell command.

Loading into Context

After saving the skill to cache, load it into the conversation context.

Method 1: Skill Tool (Preferred)

Try loading via the Skill tool using the full path:

Skill(name="$HOME\.config\kilo\skills\.temp\{skill-name}\SKILL.md")

If this works, the skill is now available in context.

Method 2: Direct Read (Fallback)

If the Skill tool cannot resolve the temp path, read the file directly:

Read(filePath="$HOME\.config\kilo\skills\.temp\{skill-name}\SKILL.md")

Then inject the content as context in your response. The skill instructions will be available for the current conversation.

Confirmation

After loading, confirm to the user: "Loaded temp skill '{skill-name}' from {url}. It's now available for this session."

Cleanup

When the user says "clear temp skills", "cleanup temp skills", or "remove temp skills":

Step 1: List Cached Skills

# On Windows (PowerShell)
Get-ChildItem "$HOME\.config\kilo\skills\.temp" -Directory -ErrorAction SilentlyContinue | Select-Object Name

# On macOS/Linux
ls -la ~/.config/kilo/skills/.temp/ 2>/dev/null

If the .temp directory doesn't exist or is empty, inform the user: "No temp skills to clean up."

Step 2: Delete the Temp Directory

# On Windows (PowerShell)
Remove-Item "$HOME\.config\kilo\skills\.temp" -Recurse -Force -ErrorAction SilentlyContinue

# On macOS/Linux
rm -rf ~/.config/kilo/skills/.temp

Step 3: Confirm Cleanup

"Cleared all temp skills from cache."

Error Handling

Default Skill Library

100 coding & development skills from the open agent skills ecosystem. All loaded TEMPORARILY — never installed permanently. Max 50 per session.

Source: skills.sh — 2026-05-27.

React & Frontend

Next.js & Deployment

Testing & QA

Databases

Code Quality & Review

TypeScript & JavaScript

Backend & API

DevOps & CI/CD

Browser & Scraping

Agent Workflows

Planning & Architecture

Quick Load Examples

# React performance rules
load temp skill from https://github.com/vercel-labs/agent-skills/tree/main/vercel-react-best-practices

# TDD workflow
load temp skill from https://github.com/obra/superpowers

# Supabase + Postgres patterns
load temp skill from https://github.com/supabase/agent-skills

# Playwright testing
load temp skill from https://github.com/currents-dev/playwright-best-practices-skill

# Code review & quality
load temp skill from https://github.com/pbakaus/impeccable

# Browser automation
load temp skill from https://github.com/vercel-labs/agent-browser

# Database optimization
load temp skill from https://github.com/jeffallan/claude-skills

# TypeScript patterns
load temp skill from https://github.com/wshobson/agents

Browse more at skills.sh — the open agent skills ecosystem.

Important Notes

• TEMPORARY ONLY — this skill never permanently installs anything
• This skill only fetches SKILL.md files — no scripts, no executables
• Each fetch is user-initiated — no automatic background fetching
• All loaded skills go into ~/.config/kilo/skills/.temp/ — never into the main skills directories
• Cached skills persist until manually cleaned up ("clear temp skills")
• Re-fetching the same URL overwrites the cached version
• NEVER run npx skills add or any install command — use this skill instead