{ "version": "https://jsonfeed.org/version/1", "title": "skillshare Blog", "home_page_url": "https://skillshare.runkids.cc/blog", "description": "skillshare Blog", "items": [ { "id": "https://skillshare.runkids.cc/blog/multi-account-claude-code", "content_html": "

You have a personal Claude Code subscription and a work one. Or maybe a client gave you access to their team account. Either way, you now have two (or three) separate Claude Code environments — and they're already drifting apart.

\n

Here's how to set up multiple accounts properly, and how to stop manually copying skills, rules, and hooks between them.

\n

Why Multiple Accounts?​

\n

A few common scenarios:

\n\n

The problem is always the same: you've built up a collection of skills, rules, hooks, and agents in one account, and now you need them in the others too.

\n

Step 1: Set Up Multiple Accounts​

\n

Claude Code stores everything in ~/.claude/ by default. To add a second account, create a separate directory and point Claude at it with CLAUDE_CONFIG_DIR.

\n
# Create a new config directory for your work account
mkdir -p ~/.claude-work
\n

Then add aliases to your ~/.zshrc (or ~/.bashrc):

\n
# Personal account (default)
alias claude=\"claude\"

# Work account
alias claude-work=\"CLAUDE_CONFIG_DIR=~/.claude-work claude\"
\n

Reload and log in:

\n
source ~/.zshrc
claude-work   # follow the login flow for your work account
\n

That's it. claude uses your personal account, claude-work uses your work account. Each has its own API key, conversation history, and settings.

\n

Need more accounts? Same pattern:

\n
alias claude-client=\"CLAUDE_CONFIG_DIR=~/.claude-client claude\"
\n

Step 2: The Config Drift Problem​

\n

After a week, here's what happens:

\n
~/.claude/
├── skills/          ← 12 skills (you just added 2 new ones)
├── rules/           ← 5 rule files
├── hooks/           ← 3 hooks
└── agents/          ← 2 agent definitions

~/.claude-work/
├── skills/          ← 10 skills (missing the 2 new ones)
├── rules/           ← 3 rule files (missing 2)
├── hooks/           ← 1 hook (you forgot to copy the other 2)
└── agents/          ← 0 (you never set these up here)
\n

You wrote a great debugging skill last Tuesday — but only in your personal account. Your work account still doesn't have it. Your carefully tuned rules about commit message style? Only in one place.

\n

You could cp -r files around, but:

\n\n

Step 3: Sync Skills Automatically​

\n

This is where skillshare comes in. Install it:

\n
# macOS / Linux
curl -fsSL https://raw.githubusercontent.com/runkids/skillshare/main/install.sh | sh

# or via Homebrew
brew install skillshare

# Windows (PowerShell)
irm https://raw.githubusercontent.com/runkids/skillshare/main/install.ps1 | iex
\n

Initialize and add your accounts as targets:

\n
skillshare init

# Add each account's skill directory
skillshare target add claude ~/.claude/skills
skillshare target add claude-work ~/.claude-work/skills
\n

Your config (~/.config/skillshare/config.yaml) now looks like:

\n
targets:
  claude:
    skills:
      path: ~/.claude/skills
  claude-work:
    skills:
      path: ~/.claude-work/skills
\n

Collect your existing skills into the source, then sync:

\n
# Pull existing skills from your primary account into skillshare
skillshare collect claude

# Sync to all accounts
skillshare sync
\n

Done. Both accounts now have the same skills.

\n

Filtering: Different Skills for Different Accounts​

\n

Not every skill belongs everywhere. Your personal side-project-ideas skill probably shouldn't show up at work:

\n
targets:
  claude:
    skills:
      path: ~/.claude/skills
  claude-work:
    skills:
      path: ~/.claude-work/skills
      exclude:
        - \"personal-*\"
  claude-client:
    skills:
      path: ~/.claude-client/skills
      include:
        - \"coding-*\"
        - \"commit\"
\n

Step 4: Sync Rules, Hooks, and Agents​

\n

Skills are only part of the picture. You also want your rules (coding standards, locale preferences), hooks (auto-format on save, test runners), and agents synced across accounts.

\n

skillshare's extras feature handles this — it syncs any directory, not just skills.

\n
# Sync rules across accounts
skillshare extras init claude-rules \\
  --source ~/.claude/rules \\
  --target ~/.claude-work/rules

# Sync hooks
skillshare extras init claude-hooks \\
  --source ~/.claude/hooks \\
  --target ~/.claude-work/hooks

# Sync agents (use --flatten because Claude discovers agents at top level only)
skillshare extras init claude-agents \\
  --source ~/.claude/agents \\
  --target ~/.claude-work/agents \\
  --flatten
\n

Or put it all in the config:

\n
extras:
  - name: claude-rules
    source: ~/.claude/rules
    targets:
      - path: ~/.claude-work/rules
        mode: merge
      - path: ~/.claude-client/rules
        mode: merge

  - name: claude-hooks
    source: ~/.claude/hooks
    targets:
      - path: ~/.claude-work/hooks
        mode: merge

  - name: claude-agents
    source: ~/.claude/agents
    targets:
      - path: ~/.claude-work/agents
        mode: merge
        flatten: true
\n

Why merge mode? It creates per-file symlinks from target to source, so account-specific files (like settings.json or settings.local.json) are left untouched. Your shared config syncs; your account-specific config stays separate.

\n

Now sync everything:

\n
skillshare sync --all   # skills + extras in one command
\n

The Daily Workflow​

\n

Once set up, keeping accounts in sync takes three commands:

\n
skillshare check        # any upstream skill updates?
skillshare update --all # pull latest versions
skillshare sync --all   # push to all accounts
\n

Write a new skill in your personal account → skillshare sync → it's everywhere.

\n

Full Config Reference​

\n

Here's a complete three-account setup:

\n
# ~/.config/skillshare/config.yaml
targets:
  claude:
    skills:
      path: ~/.claude/skills
  claude-work:
    skills:
      path: ~/.claude-work/skills
      exclude:
        - \"personal-*\"
  claude-client:
    skills:
      path: ~/.claude-client/skills
      include:
        - \"coding-*\"
        - \"commit\"

extras:
  - name: claude-rules
    source: ~/.claude/rules
    targets:
      - path: ~/.claude-work/rules
        mode: merge
      - path: ~/.claude-client/rules
        mode: merge

  - name: claude-hooks
    source: ~/.claude/hooks
    targets:
      - path: ~/.claude-work/hooks
        mode: merge

  - name: claude-agents
    source: ~/.claude/agents
    targets:
      - path: ~/.claude-work/agents
        mode: merge
        flatten: true
\n

Bonus: Manage Everything from the Web UI​

\n

Prefer a visual interface over YAML? Over half of skillshare users manage their setup through the built-in web dashboard instead of editing config files by hand.

\n
skillshare ui
\n

This opens a dashboard at localhost:19420 where you can:

\n\n

\"skillshare

\n

Everything you can do in the CLI, you can do in the UI — including setting up the multi-account extras config described above.

\n

Quick Tips​

\n\n

Get Started​

\n
curl -fsSL https://raw.githubusercontent.com/runkids/skillshare/main/install.sh | sh
skillshare init
\n", "url": "https://skillshare.runkids.cc/blog/multi-account-claude-code", "title": "Running Multiple Claude Code Accounts? Here's How to Keep Them in Sync", "summary": "You have a personal Claude Code subscription and a work one. Or maybe a client gave you access to their team account. Either way, you now have two (or three) separate Claude Code environments — and they're already drifting apart.", "date_modified": "2026-04-05T00:00:00.000Z", "author": { "name": "runkids", "url": "https://github.com/runkids" }, "tags": [ "tutorial", "extras", "multi-account" ] }, { "id": "https://skillshare.runkids.cc/blog/5-min-claude-code-skills", "content_html": "

Getting Claude Code skills organized shouldn't take more than a coffee break. Here's how to go from zero to a fully managed skill library in under 5 minutes.

\n

The Problem​

\n

Claude Code stores skills in ~/.claude/skills/. Over time, you accumulate skills from different sources — some you wrote, some from teammates, some from GitHub. Without structure, it becomes hard to track what's installed, what's outdated, and what conflicts with what.

\n

Step 1: Install skillshare​

\n
curl -fsSL https://raw.githubusercontent.com/runkids/skillshare/main/install.sh | sh
\n

Or via Homebrew (macOS/Linux):

\n
brew install skillshare
\n
note

Homebrew releases may lag behind the latest version by a few days. For the newest release, use the install script above.

\n

Verify:

\n
skillshare version
\n

Step 2: Initialize​

\n
skillshare init
\n

This creates a source directory at ~/.config/skillshare/skills/ and auto-detects Claude Code as a sync target.

\n

Step 3: Import Your Existing Skills​

\n

Already have skills in ~/.claude/skills/? Collect them into your source:

\n
skillshare collect
\n

skillshare copies each skill from Claude Code's directory into your source. Now you have a single place that holds everything.

\n

Step 4: Install a Skill from GitHub​

\n

Let's add a popular skill set:

\n
skillshare install anthropics/courses/prompt-eng
\n

This clones the repository and places skills in your source directory. Run skillshare list to see everything:

\n
skillshare list
\n

Step 5: Sync​

\n
skillshare sync
\n

By default, skillshare uses merge mode — creating per-skill symlinks from your source into ~/.claude/skills/. Your original local skills are preserved — only new ones are added.

\n

Step 6: Verify​

\n

Open Claude Code and check that your skills are available:

\n
claude
# Inside Claude Code, your skills should be loaded
\n\n

Some platforms and tools have inconsistent symlink support — WSL, certain Docker setups, or AI tools that don't follow symlinks. If you run into issues:

\n
skillshare target claude --mode copy
skillshare sync
\n

Copy mode physically copies skill files instead of symlinking. The trade-off:

\n
Merge (symlink)Copy
Source changes reflectedInstantlyAfter sync
Cross-platform compatibilityMay have issuesWorks everywhere
Local skill preservationYesYes
\n

See Sync Modes for the full comparison.

\n

What You Get​

\n

After these steps:

\n\n

Next Steps​

\n", "url": "https://skillshare.runkids.cc/blog/5-min-claude-code-skills", "title": "5 Minutes to Manage Your Claude Code Skills", "summary": "Getting Claude Code skills organized shouldn't take more than a coffee break. Here's how to go from zero to a fully managed skill library in under 5 minutes.", "date_modified": "2026-02-26T00:00:00.000Z", "author": { "name": "runkids", "url": "https://github.com/runkids" }, "tags": [ "tutorial", "claude-code" ] }, { "id": "https://skillshare.runkids.cc/blog/managing-50-skills", "content_html": "

When you use Claude Code, Cursor, and Codex daily, skill management gets chaotic fast. Here's how I keep 50+ skills organized across all three tools with a single workflow.

\n

The Setup​

\n

My daily toolkit:

\n\n

Each tool has its own skill directory, its own format quirks, and its own update cycle. Without skillshare, I was manually copying files between three locations every time I changed a skill.

\n

Directory Structure​

\n

After skillshare init, my source looks like this:

\n
~/.config/skillshare/skills/
├── _anthropics__courses__prompt-eng/   # tracked repo
├── _team__frontend/                    # team shared
├── code-review/                        # my custom skill
├── commit-message/                     # my custom skill
├── debugging/                          # organized into folders
├── testing/
└── frontend/
    ├── react-patterns/
    ├── css-guidelines/
    └── accessibility/
\n

Skills prefixed with _ are tracked repositories. The rest are local skills organized into logical groups.

\n

Organizing with --into​

\n

The --into flag places installed skills into subdirectories:

\n
skillshare install user/repo --into frontend
skillshare install another/repo --into backend
\n

This creates a clean hierarchy without flat-file chaos.

\n

Multi-Target Sync​

\n

Global config targets use a map format:

\n
targets:
  claude:
    skills:
      path: ~/.claude/skills
  cursor:
    skills:
      path: ~/.cursor/skills
  codex:
    skills:
      path: ~/.codex/skills
\n

One skillshare sync pushes all 50+ skills to all three tools simultaneously. Each target gets per-skill symlinks, so tool-specific local skills remain untouched.

\n

Per-Target Mode and Filtering​

\n

You can set a different sync mode per target, and use include/exclude patterns to control which skills go where:

\n
targets:
  claude:
    skills:
      path: ~/.claude/skills
      mode: merge
  cursor:
    skills:
      path: ~/.cursor/skills
      mode: copy          # copy mode for better compatibility
      exclude:
        - \"_experimental*\"
  codex:
    skills:
      path: ~/.codex/skills
      mode: merge
      include:
        - \"coding-*\"
\n

Daily Workflow​

\n

My morning routine takes about 30 seconds:

\n
# Check for upstream updates
skillshare check

# If updates available
skillshare update --all

# Sync to all targets
skillshare sync
\n

That's it. Three tools, 50+ skills, one command chain.

\n

Handling Conflicts​

\n

Occasionally, a tool creates a skill with the same name as one in my source. skillshare handles this gracefully:

\n\n

Backup Strategy​

\n

Before major changes, I snapshot:

\n
skillshare backup
\n

Backups are stored in ~/.local/share/skillshare/backups/ with timestamps. To restore a specific target:

\n
skillshare restore claude
\n

Key Takeaways​

\n
    \n
  1. One source, many targets — the fundamental principle
    2. \n
  2. Use --into for organization — avoid flat directory sprawl
    3. \n
  3. Check + update + sync — the daily three-command chain
    4. \n
  4. Backup before experiments — it takes 2 seconds and saves hours
    5. \n
\n

Resources​

\n", "url": "https://skillshare.runkids.cc/blog/managing-50-skills", "title": "How I Manage 50+ Skills Across 3 AI Tools", "summary": "When you use Claude Code, Cursor, and Codex daily, skill management gets chaotic fast. Here's how I keep 50+ skills organized across all three tools with a single workflow.", "date_modified": "2026-02-26T00:00:00.000Z", "author": { "name": "runkids", "url": "https://github.com/runkids" }, "tags": [ "tutorial", "advanced" ] }, { "id": "https://skillshare.runkids.cc/blog/migrate-from-vercel-skills", "content_html": "

vercel/skills and skillshare are both CLI tools for managing AI coding skills across multiple agents. If you're choosing between them — or considering a migration — here's an honest comparison.

\n

What They Have in Common​

\n

Both tools solve the same core problem: managing AI skill files across 40+ coding agents (Claude Code, Cursor, Codex, etc.). Both offer:

\n\n

Where vercel/skills Shines​

\n

Best for quick, curated installs:

\n\n

Use vercel/skills when:

\n\n

Where skillshare Shines​

\n

Best for multi-tool sync, multi-platform, and team workflows:

\n\n

Use skillshare when:

\n\n

Feature Comparison​

\n
Featurevercel/skillsskillshare
Install methodnpx (Node.js)Single binary
Git platform supportGitHub, GitLab, any git URLGitHub, GitLab, Bitbucket, Gitea, GHE, Azure DevOps, AtomGit, Codeberg, any HTTPS/SSH host
Sync modesSymlink, copyMerge (per-skill symlink), symlink, copy
Multi-tool syncYesYes
Collect (target → source)NoYes
Cross-machine syncNoYes (push/pull)
Security auditYes (server-side via Snyk, catalog skills)Yes (local, 15+ patterns, custom rules, any source)
Custom audit rulesNoYes (enable/disable patterns, configurable thresholds)
Pre-commit hookNoYes (pre-commit framework)
Audit output formatsCLI displayText, JSON, SARIF, Markdown
Backup/restoreNoYes
Web UINoYes
Hub/registryCommunity catalog (skills.sh)Self-hosted hub index
Offline operationNeeds npmYes (core operations)
Project skillsYesYes
\n

Migrating from vercel/skills​

\n

If you decide to switch, the process is straightforward:

\n

Step 1: Install skillshare​

\n
curl -fsSL https://raw.githubusercontent.com/runkids/skillshare/main/install.sh | sh
skillshare init
\n

Step 2: Collect existing skills​

\n

If vercel/skills already synced skills to your AI tool directories:

\n
skillshare collect
\n

This copies skills from your target directories into skillshare's source.

\n

Step 3: Sync​

\n
skillshare sync
\n

Step 4: Ongoing updates​

\n
skillshare check          # Detect upstream changes
skillshare update --all   # Apply updates
skillshare sync           # Push to all tools
\n

Can They Coexist?​

\n

Yes. Both tools use symlinks (or copies) to the same target directories. However, running both simultaneously on the same targets may cause conflicts — one tool's symlinks may be overwritten by the other. If you're evaluating both, use them on separate targets or test one at a time.

\n

Resources​

\n", "url": "https://skillshare.runkids.cc/blog/migrate-from-vercel-skills", "title": "skillshare vs. vercel/skills — When to Use Which", "summary": "vercel/skills and skillshare are both CLI tools for managing AI coding skills across multiple agents. If you're choosing between them — or considering a migration — here's an honest comparison.", "date_modified": "2026-02-26T00:00:00.000Z", "author": { "name": "runkids", "url": "https://github.com/runkids" }, "tags": [ "comparison" ] }, { "id": "https://skillshare.runkids.cc/blog/team-sharing-patterns", "content_html": "

Every team eventually faces the question: \"How do we share AI skills across the team?\" Here are three patterns, from simplest to most structured, with skillshare handling the mechanics.

\n

Pattern 1: Shared Git Repository​

\n

Best for: Small teams (2-5 people) who want a quick start.

\n

Create a Git repository with your team's skills:

\n
team-skills/
├── code-review/
│   └── SKILL.md
├── pr-description/
│   └── SKILL.md
└── testing-standards/
    └── SKILL.md
\n

Each team member installs it:

\n
skillshare install your-org/team-skills
skillshare sync
\n

When someone updates a skill, others pull changes:

\n
skillshare check              # \"team-skills: 2 skills updated\"
skillshare update --all       # Apply all available updates
skillshare sync
\n

Pros: Simple, familiar Git workflow, works with any Git host.

\n

Cons: Everyone gets all skills, no per-project customization.

\n

Pattern 2: Organization-Wide + Project-Scoped​

\n

Best for: Medium teams (5-20 people) with different projects.

\n

Split skills into two layers:

\n

Organization Layer (global)​

\n

Shared standards that apply everywhere:

\n
skillshare install your-org/org-skills
\n

These live in ~/.config/skillshare/skills/ and sync to all tools on every machine.

\n

Project Layer (scoped)​

\n

Project-specific skills committed to the project repo:

\n
cd your-project
skillshare init -p
skillshare install your-org/frontend-skills -p
git add .skillshare/
git commit -m \"Add project skills\"
\n

Team members get project skills automatically when they clone and run:

\n
skillshare sync -p
\n

Pros: Organization standards + project flexibility. Skills travel with the code.

\n

Cons: Two sync commands (global + project). Requires project setup.

\n

Pattern 3: Hub Index (Registry)​

\n

Best for: Large teams or open-source communities.

\n

Generate a hub index from your source skills:

\n
skillshare hub index --source ./skills --output ./skillshare-hub.json
\n

This creates a JSON file listing all available skills with metadata. Host it on GitHub Pages or any HTTPS URL, then register it:

\n
skillshare hub add https://your-org.github.io/skillshare-hub.json --label team
skillshare hub default team
\n

Team members can then browse and install:

\n
skillshare search --hub https://your-org.github.io/skillshare-hub.json
skillshare install your-org/skills --skill code-review
\n

Pros: Discoverable, self-service, scales to hundreds of skills.

\n

Cons: Requires maintaining the index. More setup upfront.

\n

Choosing a Pattern​

\n
FactorPattern 1Pattern 2Pattern 3
Setup time5 min15 min30 min
Team size2-55-2020+
Per-project skillsNoYesYes
Self-service discoveryNoNoYes
MaintenanceLowMediumMedium
\n

Most teams start with Pattern 1 and evolve to Pattern 2 when they need project-specific skills. Pattern 3 is for organizations that want a curated skill catalog.

\n

Getting Started​

\n

Regardless of pattern, the workflow is the same:

\n
skillshare install <repo>    # Add skills
skillshare sync              # Push to tools
skillshare check             # Detect updates
skillshare update --all      # Apply updates
\n

Resources​

\n", "url": "https://skillshare.runkids.cc/blog/team-sharing-patterns", "title": "3 Patterns for Team Skill Sharing", "summary": "Every team eventually faces the question: \"How do we share AI skills across the team?\" Here are three patterns, from simplest to most structured, with skillshare handling the mechanics.", "date_modified": "2026-02-26T00:00:00.000Z", "author": { "name": "runkids", "url": "https://github.com/runkids" }, "tags": [ "team", "tutorial" ] }, { "id": "https://skillshare.runkids.cc/blog/write-your-first-skill", "content_html": "

Skills are just Markdown files with frontmatter. If you can write a README, you can write a skill. Here's how to create one from scratch, audit it, and share it.

\n

What Is a Skill?​

\n

A skill is a SKILL.md file inside a named directory. It contains instructions that AI coding tools (Claude Code, Cursor, Codex, etc.) load as context when working on your code.

\n
my-skill/
└── SKILL.md
\n

That's the minimum. The SKILL.md file has two parts: frontmatter (metadata) and body (the actual instructions).

\n

Step 1: Scaffold with skillshare new​

\n
skillshare new my-code-review
\n

This creates ~/.config/skillshare/skills/my-code-review/SKILL.md with a template:

\n
---
name: my-code-review
description: >-
  Describe what this skill does. Use when user asks to
  \"trigger phrase 1\", \"trigger phrase 2\", or needs help
  with a specific task.
# targets: []           # e.g. [claude, cursor] — omit for all targets
# metadata:
#   author: Your Name
#   version: 1.0.0
---

# My Code Review

Brief overview of what this skill does and its value.
\n

Step 2: Write the Instructions​

\n

Replace the template body with clear, actionable instructions. Good skills are:

\n\n

Here's an example code review skill:

\n
---
name: my-code-review
description: >-
  Enforce team code review standards. Check for security,
  error handling, input validation, and style compliance.
targets: [claude, cursor]
---

# Code Review Standards

When reviewing code (PR reviews, code suggestions, refactoring):

## Must Check
- No hardcoded secrets or credentials
- Error handling for all external calls (API, DB, file I/O)
- Input validation at system boundaries
- Tests for new public functions

## Style
- Functions under 30 lines
- No more than 3 parameters per function
- Early returns over nested conditionals
- Descriptive variable names (no single letters except loop counters)

## Response Format
- List issues by severity: critical > warning > suggestion
- Include file path and line number for each issue
- Suggest fixes, don't just flag problems
\n

Step 3: Security Scan​

\n

Before sharing, audit your skill:

\n
skillshare audit
\n

This checks for patterns that could be harmful: prompt injection, data exfiltration, destructive commands. Even well-intentioned skills can accidentally trigger these patterns.

\n

Step 4: Sync and Test​

\n
skillshare sync
\n

Now open your AI tool and test the skill. Ask it to review some code and check whether it follows your instructions.

\n

Step 5: Share​

\n

Option A: Commit to a shared repo​

\n
# Copy to a team repository
cp -r ~/.config/skillshare/skills/my-code-review /path/to/team-skills/
cd /path/to/team-skills
git add my-code-review/
git commit -m \"Add code review skill\"
git push
\n

Team members install with:

\n
skillshare install your-org/team-skills --skill my-code-review
\n

Option B: Project-scoped skill​

\n
cd your-project
skillshare init -p
cp -r ~/.config/skillshare/skills/my-code-review .skillshare/skills/
git add .skillshare/
git commit -m \"Add project code review skill\"
\n

Anyone who clones the repo gets the skill automatically.

\n

Controlling Where Skills Sync​

\n

Per-skill target restriction​

\n

Add a targets field to SKILL.md frontmatter to limit which AI tools receive this skill:

\n
---
name: claude-only-skill
description: Only syncs to Claude Code
targets: [claude]
---
\n

Skills without a targets field sync to all configured targets.

\n

Per-target filtering​

\n

In your config, use include/exclude patterns to control which skills each target receives:

\n
targets:
  claude:
    skills:
      path: ~/.claude/skills
      exclude:
        - \"experimental-*\"
  cursor:
    skills:
      path: ~/.cursor/skills
      include:
        - \"coding-*\"
        - \"review-*\"
\n

.skillignore for repositories​

\n

If you publish a skill repository, add a .skillignore file to exclude internal/test skills from installation:

\n
# .skillignore — skills to exclude during install
internal-testing
experimental
debug-*
\n

Patterns support exact names, group prefixes, and trailing wildcards.

\n

Tips for Effective Skills​

\n
    \n
  1. Keep the description under 1024 characters — Codex enforces this limit
    2. \n
  2. Use headers for structure — AI tools parse Markdown headers for context
    3. \n
  3. Be imperative — \"Check for X\" not \"It would be good to check for X\"
    4. \n
  4. Include examples — Show the AI what good output looks like
    5. \n
  5. Use targets to scope — Not every skill makes sense for every tool
    6. \n
\n

Resources​

\n", "url": "https://skillshare.runkids.cc/blog/write-your-first-skill", "title": "Writing Your First Skill: A Step-by-Step Guide", "summary": "Skills are just Markdown files with frontmatter. If you can write a README, you can write a skill. Here's how to create one from scratch, audit it, and share it.", "date_modified": "2026-02-26T00:00:00.000Z", "author": { "name": "runkids", "url": "https://github.com/runkids" }, "tags": [ "skill-authoring", "tutorial" ] } ] }