DEV Community: William Wang

Claude Code Skills vs MCP Servers — What to Use, How to Install, and the Best Ones in 2026

William Wang — Fri, 10 Apr 2026 09:05:32 +0000

Claude Code has two main extension systems: skills (Markdown files) and MCP servers (protocol-based tools). Both make Claude Code more powerful, but they work differently and are best for different use cases.

This guide covers what each one does, when to use which, how to install them, and the best ones I've found after months of daily use.

What Are Claude Code Skills?

Skills are Markdown files (.md) that you drop into .claude/commands/ in your project. They teach Claude Code how to perform specific tasks — no server, no API, no dependencies.

# Install a skill from TokRepo
npx tokrepo install <skill-name>
# Or manually: just copy a .md file into .claude/commands/

When you type /skillname in Claude Code, it loads the instructions from that file and follows them.

Best for: code review workflows, commit conventions, testing patterns, project-specific rules.

What Are MCP Servers?

MCP (Model Context Protocol) servers are standalone programs that expose tools, resources, and prompts to Claude Code over a standardized protocol. They can connect to databases, APIs, browsers, file systems — anything.

# Add an MCP server
claude mcp add <name> -- npx <package>

Best for: external integrations (databases, APIs, browsers), tools that need runtime state.

Skills vs MCP Servers — Quick Comparison

Feature	Skills	MCP Servers
Format	Markdown file	Standalone server process
Install	Copy `.md` file	`claude mcp add` command
Dependencies	None	Node.js/Python runtime
External access	No (text only)	Yes (APIs, DBs, browsers)
Portability	Copy-paste	Config per machine
Overhead	Zero	Process running in background
Best for	Workflows, rules	Integrations, tools

The 10 Best Claude Code Skills (Tested)

After testing 30+ skills on production codebases, these are the ones I actually keep installed:

1. GSD (Get Stuff Done)

Project management with phase planning, verification, and atomic commits. The most comprehensive skill I've used.

npx tokrepo install gsd

2. Frontend Design

Generates production-grade UI components with proper responsive design. Output quality is noticeably better than unguided Claude.

npx tokrepo install frontend-design

3. Simplify

Reviews your changed code for reuse and efficiency, then auto-fixes. My favorite "set and forget" skill.

4. Commit

Analyzes staged changes and writes why-focused commit messages. Saves 30 seconds per commit.

5. Webapp Testing

Playwright-based testing. Point at localhost, describe what to verify, get working tests.

6. Doc Coauthoring

Structured documentation workflow. Asks the right questions before writing.

7. PDF / XLSX / PPTX

File format skills — read, create, and manipulate office documents from the terminal.

8. Claude API

If you're building with the Anthropic SDK, this skill knows latest patterns and model IDs.

9. MCP Builder

Scaffolds new MCP servers with proper JSON schema. Saved me hours.

10. Skill Creator

Meta: creates new skills. Useful for packaging your team's workflows.

The 8 Best MCP Servers (Tested)

1. Playwright MCP (Microsoft)

Browser automation from Claude Code. Navigate, click, fill forms, take screenshots.

claude mcp add playwright -- npx @anthropic-ai/mcp-playwright

2. GitHub MCP

Full GitHub API access — create PRs, review code, manage issues.

claude mcp add github -- npx @modelcontextprotocol/server-github

3. Filesystem MCP

Secure file operations with configurable access controls.

4. PostgreSQL MCP

Read-only database access with schema inspection. Great for data exploration.

5. Firecrawl MCP

Web scraping and crawling from Claude Code.

6. TokRepo MCP

Search and install AI assets (skills, prompts, workflows) directly from Claude Code. 500+ assets indexed.

claude mcp add tokrepo -- npx tokrepo-mcp-server

7. Sentry MCP

Retrieve and analyze issues from Sentry directly in your coding flow.

8. Memory MCP

Persistent memory across Claude Code sessions using a knowledge graph.

How to Find More Skills and MCP Servers

The hardest part isn't installing — it's finding good ones. Here's where I look:

TokRepo — Free registry with 500+ skills, MCP servers, and workflows. Searchable by category with install commands. Also has step-by-step guides.
GitHub Awesome Lists — awesome-mcp-servers (84K+ stars) and awesome-claude-skills (52K+ stars).
Official MCP Registry — Anthropic's own registry at modelcontextprotocol/registry.

FAQ

How many skills can I install at once?

No hard limit, but each active skill consumes context window space. Keep 5-10 active, disable others when not needed.

Do skills work with Cursor and Codex CLI?

Most Markdown-based skills are portable. TokRepo skills follow the SKILL.md standard that works across Claude Code, Cursor (as .cursorrules), Codex CLI (as AGENTS.md), and Gemini CLI.

Are MCP servers secure?

Each MCP server runs as a separate process with its own permissions. The MCP protocol enforces clear boundaries — servers can't access your filesystem unless you explicitly configure them to.

Can I create my own skill?

Yes! Create a .md file in .claude/commands/ with instructions. See the full tutorial on creating skills.

What's the difference between skills, MCP servers, and CLAUDE.md rules?

Skills = reusable slash commands (per-project or global)
MCP servers = external tool integrations (databases, APIs, browsers)
Rules = always-on project instructions (coding standards, conventions)

See the complete comparison guide for details.

What skills and MCP servers are you using? Drop your setup in the comments — I'm always looking for new ones to test.

5 Claude Code Skills That Actually Save Time (Free, Open Source)

William Wang — Fri, 10 Apr 2026 06:52:00 +0000

If you're using Claude Code, you've probably noticed it supports skills — reusable instruction sets that teach the AI how to handle specific tasks.

The problem? Most people write their own from scratch every time. I've been collecting and testing skills from the community, and here are 5 that genuinely saved me hours.

1. Git Commit Conventions Skill

Teaches Claude Code to follow Conventional Commits format automatically. No more "fix stuff" messages.

What it does: Analyzes your staged changes, picks the right prefix (feat:, fix:, refactor:), and writes a meaningful commit message.

2. Code Review Skill

Turns Claude into a senior reviewer. It checks for security issues, performance problems, and style violations — then explains why something is a problem, not just what.

3. Test Generation Skill

Point it at a function, and it generates edge-case-aware tests. Supports Jest, pytest, Go testing, and more. Especially useful when you're retrofitting tests onto existing code.

4. Documentation Writer Skill

Generates docs that actually match your code's style. It reads your existing README patterns and follows them, instead of producing generic boilerplate.

5. Database Migration Skill

Handles schema changes with rollback safety. Generates up/down migrations and validates them before you apply anything.

Where to find more

I've been curating these (and 700+ other AI assets) at tokrepo.com — it's a free, open library of prompts, skills, MCP configs, scripts, and agent setups for Claude Code, Cursor, and other AI tools.

You can browse the Skill Factory section for 130+ Claude Code skills:
👉 tokrepo.com/en/featured

Every asset is free to use, copy, and modify. No signup wall.

What skills are you using with Claude Code? Drop them in the comments — always looking for new ones to add to the collection.

Agent Skills in 2026: How to Customize Claude Code, Codex CLI & Gemini CLI

William Wang — Wed, 08 Apr 2026 10:06:02 +0000

AI coding agents like Claude Code, OpenAI Codex CLI, and Google Gemini CLI are powerful out of the box. But they become dramatically better when you teach them your workflows through Agent Skills — simple Markdown files that encode reusable instructions.

I've been using skills daily for the past few months, and the difference is night and day. Here's everything I've learned about customizing these three major CLI tools.

What Are Agent Skills?

An Agent Skill is a Markdown file (typically SKILL.md, AGENTS.md, or GEMINI.md) that tells an AI coding agent how to perform a specific task. Think of it as a reusable prompt with structure.

Unlike MCP servers (which require running code) or simple rules files (which are just text constraints), skills sit in a sweet spot: powerful enough for complex workflows, simple enough that anyone can create one.

---
name: Code Review
description: "Thorough adversarial code review"
---

## Steps
1. Read all changed files
2. Check for bugs, security issues, performance problems
3. Output findings grouped by severity

That's it. Drop this file in your project, and your AI agent knows how to do a thorough code review every time.

For a deeper comparison of when to use skills vs MCP vs rules, check out this complete breakdown.

Claude Code: The SKILL.md Ecosystem

Claude Code looks for SKILL.md files in .claude/commands/ or your project root. As of April 2026, the ecosystem has exploded — there are hundreds of community-built skills covering everything from deployment automation to video production.

Getting Started

# Install a skill from a registry
claude install @tokrepo/code-review# Or just create your own
mkdir -p .claude/commands
touch .claude/commands/SKILL.md

Best Skills I've Tested

After testing dozens of skills, here are the ones that actually made a difference in my daily workflow:

Adversarial Code Review — catches bugs that standard review misses
Token-Saving Compact — reduces context usage by 40-50%
Git Commit Conventions — consistent, meaningful commit messages
Test Generator — writes tests that actually cover edge cases
Documentation Writer — generates docs that stay in sync with code

I wrote a full ranked list with install commands: 15 Best Claude Code Skills in 2026.

OpenAI Codex CLI: AGENTS.md

Codex CLI uses AGENTS.md files — similar concept, slightly different format. The good news: most SKILL.md files work with Codex with minimal changes.

# Install Codex CLI
npm install -g @openai/codex# Create an agent skill
touch AGENTS.md

Codex's strength is its sandbox execution model — it runs code in an isolated environment by default, which makes it great for skills that involve running tests or builds.

If you're getting started with Codex skills, I put together a setup guide: Getting Started with Codex CLI Skills.

Google Gemini CLI: GEMINI.md

Google's entry into the CLI agent space (launched 2026) uses GEMINI.md files. It's the newest of the three, but it already has a growing extension ecosystem with 40+ official Google-built extensions.

# Install Gemini CLI
npm install -g @anthropic-ai/gemini-cli# Create a skill
touch GEMINI.md

Gemini CLI's advantage is tight integration with Google Cloud services — if your stack is on GCP, the built-in extensions for BigQuery, Cloud Run, and Firebase are excellent.

Full setup guide here: Gemini CLI Agent Skills Guide.

Cross-Platform Skills

Here's the interesting part: the skill formats are converging. A well-written SKILL.md works on Claude Code, Codex CLI, and Gemini CLI with zero or minimal changes. This means you can write once and use across all three tools.

The key fields that work everywhere:

name and description in frontmatter
Markdown-structured instructions
Step-by-step workflows
Code blocks with examples

If you want to learn how to create your own cross-platform skill from scratch, here's a step-by-step tutorial: How to Create Your First Agent Skill.

Where to Find Skills

Building your own skills is great, but there's no need to start from scratch for common workflows. Several registries have emerged:

TokRepo — 600+ curated skills, MCP configs, and prompts with one-click install
GitHub — search for SKILL.md or AGENTS.md files
Claude Code's /powerup — built-in tutorial that teaches skill basics

The Token Cost Problem (and How Skills Solve It)

One thing nobody talks about enough: AI coding agents are expensive. Claude Opus costs $15/$75 per million tokens. A heavy coding session can easily burn through $20-50.

Skills help because they:

Replace repetitive prompts — encode once, reuse forever
Reduce context size — focused instructions instead of rambling conversations
Minimize iteration — better first-pass results mean fewer back-and-forth cycles

I measured the difference: How to Cut Claude Code Token Costs by 50%.

What's Next

The agent skills ecosystem is still early but growing fast. The convergence across Claude Code, Codex, and Gemini CLI means that skills you write today will likely work with whatever new tool comes out tomorrow.

If you're not using skills yet, start with one. Install a code review skill, use it for a week, and see the difference. Then create your own for your most repetitive workflow.

All the skills and guides mentioned in this article are available on TokRepo — a registry of 600+ curated AI assets for coding agents.

After /powerup: 10 Skills & Tools to Level Up Each Claude Code Lesson

William Wang — Wed, 08 Apr 2026 05:45:26 +0000

Claude Code v2.1.90 (released April 1, 2026) shipped a new command called /powerup. It's an interactive tutorial that walks you through 10 core capabilities — from talking to your codebase to dialing model effort. Each lesson is concise and hands-on.

But once you finish a lesson, the natural question is: what now? How do you actually put this into practice on a real project?

I went through all 10 lessons and matched each one with a specific open-source skill or tool from TokRepo that extends what you just learned. Think of this as a companion guide — /powerup teaches the concept, and these tools help you apply it at scale.

1. Talk to your codebase → LLM Wiki Memory Upgrade Prompt

What /powerup teaches: You can reference files with @filename, point to specific lines, and have Claude reason about your codebase structure. It's the foundation of everything else.

What takes it further: The LLM Wiki Memory Upgrade Prompt gives your agent a structured memory schema — a personal wiki that persists across sessions. Instead of re-explaining your architecture every time, the agent already knows your project layout, naming conventions, and key decisions. It turns "talk to your codebase" from a one-shot interaction into a continuous relationship.

2. Steer with modes → Claude Code Templates (600+ Agents, Commands & MCPs)

What /powerup teaches: Shift+Tab toggles between plan mode and auto mode. You can steer how aggressively Claude acts — from careful planning to full autonomy.

What takes it further: Modes are powerful but generic. Claude Code Templates gives you 600+ pre-configured agent setups, slash commands, and MCP integrations. Instead of manually switching modes per task, you get purpose-built workflows — a code reviewer agent that always plans first, a refactoring agent that runs autonomously, and so on.

3. Undo anything → CC Status Board (Smart Status Bar)

What /powerup teaches: /rewind rolls back to any previous state. Double-tap Escape cancels the current operation. You always have an escape hatch.

What takes it further: The problem is knowing when to hit rewind. CC Status Board adds a smart status bar that shows what Claude is doing in real time — which files it's touching, how many tokens it's burning, and whether it's going off track. You catch problems before they need rewinding.

4. Run in the background → Awesome n8n Workflow Automation Templates

What /powerup teaches: You can spin up background tasks with /tasks and let Claude work on multiple things in parallel. It's like having extra hands.

What takes it further: Background tasks inside Claude are great, but some work belongs outside your editor entirely. Awesome n8n is a curated collection of workflow automation templates — CI/CD triggers, Slack notifications on PR reviews, scheduled code quality scans. Pair Claude's background tasks with n8n for anything that should run on a schedule or in response to external events.

5. Teach Claude your rules → Awesome Cursor Rules

What /powerup teaches: CLAUDE.md files and /memory let you define project-specific rules — coding standards, forbidden patterns, architectural constraints. Claude follows them automatically.

What takes it further: Writing good rules from scratch is hard. Awesome Cursor Rules collects 30+ stack-specific rule templates (React, Python, Go, Rust, and more). They were written for Cursor, but the format translates directly to CLAUDE.md. Fork a template, adapt the rules, and you skip the blank-page problem entirely.

6. Extend with tools → Chrome MCP Background Proxy

What /powerup teaches: MCP (Model Context Protocol) servers let Claude use external tools — databases, APIs, browsers. /mcp manages your connections.

What takes it further: The single biggest MCP pain point is browser automation stealing window focus. Every time Claude uses a Chrome MCP tool, the browser pops to the foreground and interrupts your work. Chrome MCP Background Proxy solves this by routing MCP calls through a background proxy. Claude browses, scrapes, and tests without ever stealing your screen.

7. Automate your workflow → Lark CLI Skill: Skill Maker

What /powerup teaches: Skills are reusable capabilities you can teach Claude — custom slash commands, hooks that fire on events, repeatable procedures stored as markdown.

What takes it further: Skill Maker is a meta-skill: it helps you create new skills faster. Describe what you want in plain English, and it generates the skill file with proper frontmatter, parameter definitions, and step-by-step instructions. Instead of hand-writing skill markdown, you scaffold it in seconds.

8. Multiply yourself → GPT Researcher (Autonomous Research Agent)

What /powerup teaches: Subagents let Claude delegate work to child agents. /agents manages them. You can parallelize research, code review, and testing across multiple agents.

What takes it further: Subagents are only as good as their specialization. GPT Researcher is a purpose-built autonomous research agent that searches the web, aggregates sources, and produces structured reports. Use it as a subagent when Claude needs to answer questions that go beyond your codebase — competitor analysis, library comparisons, or technical deep dives.

9. Code from anywhere → Tabby (Self-Hosted AI Coding Assistant)

What /powerup teaches: /remote-control and /teleport let you use Claude Code from your phone, another machine, or any browser. Your dev environment goes wherever you go.

What takes it further: Remote Claude is great, but sometimes you want local AI completions too — especially when you're offline or working on sensitive code. Tabby is a self-hosted AI coding assistant that runs on your own hardware. Use Claude remotely for heavy tasks, Tabby locally for fast inline completions. They complement each other.

10. Dial the model → Agent Skills Standard (Cross-Platform AI Skills)

What /powerup teaches: /model switches between Claude models. /effort adjusts how hard Claude thinks. You can optimize for speed or depth depending on the task.

What takes it further: Once you start switching models, you realize your skills and prompts might be model-dependent. Agent Skills Standard defines a cross-platform skill format that works across Claude, Codex, Gemini, and others. Write your skills once using this standard, and they work regardless of which model you've dialed in — no rewrites needed when you switch.

Keep going

/powerup is a great starting point, but the real leverage comes from the tools and skills the community builds on top. All the resources linked above — and hundreds more — are browsable at tokrepo.com. Filter by your stack, grab what fits, and skip the setup work that someone else already solved.

If you've built a skill or workflow that pairs well with a /powerup lesson, drop a link in the comments. The best dev tools are the ones people actually share.

Top 10 Agent Skills Registries for Claude Code, Codex & Gemini CLI (2026)

William Wang — Tue, 07 Apr 2026 13:09:14 +0000

The AI coding agent ecosystem exploded in 2026. Claude Code, OpenAI Codex CLI, Google Gemini CLI, Cursor, and GitHub Copilot all now support Agent Skills — modular markdown files (SKILL.md) that teach AI assistants new capabilities.

But where do you actually find good skills to install? Here are the 10 best agent skills registries and directories in 2026.

1. TokRepo — Open Agent Skills Registry

🔗 tokrepo.com

500+ skills across 6 categories: Skills, MCP Servers, Prompts, Scripts, Workflows, and Configs.

What makes TokRepo stand out:

Community-ranked — skills sorted by votes and real usage
Cross-platform — works with Claude Code, Codex CLI, Gemini CLI, Cursor
One-command install — every skill includes a ready-to-use install command
Searchable — full-text search with category filtering
Bilingual — English + Chinese interface

Best for: Developers who want a web-based registry with search, filtering, and community curation instead of browsing raw GitHub repos.

👉 Also check: Best MCP Servers | AI Prompts

2. Anthropic Official Skills Repository

🔗 github.com/anthropics/skills

The official skills repo from the creators of Claude Code and the SKILL.md specification. Contains the reference implementation and spec documentation.

Best for: Understanding the SKILL.md standard and finding officially maintained skills.

3. alirezarezvani/claude-skills

🔗 github.com/alirezarezvani/claude-skills

220+ skills covering engineering, marketing, product, compliance, and C-level advisory. Compatible with Claude Code, Codex, Gemini CLI, Cursor, and 8 more agents.

Best for: Finding specialized professional skills beyond just coding.

4. VoltAgent/awesome-agent-skills

🔗 github.com/VoltAgent/awesome-agent-skills

Community-curated awesome list featuring official skills from Anthropic, Google Labs, Vercel, Stripe, and community contributions.

Best for: Discovering officially published skills from major dev teams.

5. SkillsMP (Skills Marketplace)

🔗 skillsmp.com

Claims 700,000+ agent skills with intelligent filtering by occupation, author, and popularity. All skills use the open SKILL.md standard.

Best for: Sheer volume — if it exists, SkillsMP probably has it.

6. Antigravity Awesome Skills

🔗 github.com/sickn33/antigravity-awesome-skills

1,370+ skills with a CLI installer. Install everything at once with:

npx antigravity-awesome-skills --claude

Best for: Bulk installing a large skill library in one command.

7. OpenAI Codex Skills Catalog

🔗 github.com/openai/skills

Official skills catalog for OpenAI Codex CLI. Includes installation guides and the Codex-specific skill format (compatible with SKILL.md).

Best for: Codex CLI users who want officially supported skills.

8. LobeHub Skills Marketplace

🔗 lobehub.com/skills

Part of the LobeHub ecosystem. Features skills for Claude Code, Codex, and other agents with a polished marketplace UI.

Best for: Visual discovery with a clean marketplace interface.

9. Cursor Marketplace

🔗 cursor.com/marketplace

Launched February 2026. Official Cursor plugin marketplace bundling MCP servers, skills, subagents, hooks, and rules.

Best for: Cursor users who want one-click plugin installs directly in the editor.

10. SkillRegistry.io

🔗 skillregistry.io

Dedicated SKILL.md file registry. Find and install skills for Claude, ChatGPT, and other AI agents.

Best for: Focused SKILL.md discovery without the noise of general-purpose marketplaces.

How to Install Agent Skills

All of these registries use the SKILL.md open standard (published by Anthropic at agentskills.io). Installation is typically one command:

Claude Code:

claude skill add <skill-name>

Codex CLI:

codex plugin install <skill-name>

Gemini CLI:

# Copy to ~/.gemini/skills/ or .agents/skills/

Cursor:

/add-plugin <plugin-name>

Which Registry Should You Use?

Registry	Best For	Skills Count
TokRepo	Search + community ranking	500+
Anthropic Official	Reference skills	~50
alirezarezvani	Professional skills	220+
SkillsMP	Volume	700K+
Antigravity	Bulk install	1,370+
Cursor Marketplace	Cursor users	Growing

My recommendation: Start with TokRepo for curated, community-ranked skills, then explore the GitHub collections for niche needs.

What's your favorite skills registry? Drop a comment below!

5 Claude Code Skills That Saved Me Hours This Week (With Install Commands)

William Wang — Tue, 07 Apr 2026 03:34:52 +0000

Last week I spent 14 hours on repetitive dev tasks — writing boilerplate tests, reviewing PRs, generating docs, debugging deploys. This week I spent 3. The difference? Five Claude Code skills I found (and one I built myself) that automate the painful parts.

Here are the exact skills, what they do, and how to install them in under 30 seconds.

1. Code Review — The Adversarial Reviewer

The problem: Self-reviewing your own PRs is like proofreading your own essay. You see what you meant to write, not what you actually wrote.

What this skill does: Runs a senior-engineer-level adversarial review on your changed files. It checks for logic bugs, security issues, performance problems, missing edge cases, and naming inconsistencies. Not a linter — it thinks about your code the way a skeptical colleague would.

Real example: I had a Go handler that returned 200 OK on a database write failure because the error check was on the wrong variable. The skill caught it in 4 seconds. A human reviewer might have missed it on a Friday afternoon.

Install:

npx tokrepo search code review
npx tokrepo install <skill-id>

Or browse it at tokrepo.com and copy the one-liner from the asset page.

2. Git Workflow — Commit Messages That Actually Help

The problem: git log full of "fix stuff", "WIP", and "update things". Six months later you have no idea why anything changed.

What this skill does: Analyzes your staged changes, generates a conventional commit message with scope, explains the why not just the what, and optionally creates a PR description. It follows your repo's existing commit style.

Real example: I staged 4 files across 2 directories. Instead of writing "update auth and fix redirect", the skill generated:

fix(auth): resolve OAuth callback redirect loop when session cookie expires

The callback handler was not clearing stale session tokens before
writing new ones, causing an infinite redirect on expired sessions.

That's a message future-me will actually thank present-me for.

Install:

npx tokrepo search git workflow
npx tokrepo install <skill-id>

3. Test Generation — Coverage Without the Tedium

The problem: You know you should write tests. You also know it's 6pm and you'd rather do literally anything else.

What this skill does: Reads your implementation, identifies the critical paths and edge cases, then generates test files with proper setup/teardown. Supports Jest, Vitest, Go testing, and pytest. It doesn't just test the happy path — it generates boundary tests, error cases, and concurrency scenarios.

Real example: For a Nuxt 3 composable that fetches and caches API data, it generated 11 test cases covering: successful fetch, network failure, cache hit, cache expiry, concurrent requests, malformed response, and empty result set. Took me 90 seconds to review and merge vs. 40 minutes to write myself.

Install:

npx tokrepo search test generation
npx tokrepo install <skill-id>

4. Documentation — From Code to Readable Docs

The problem: Your code is self-documenting (it's not). Your teammates can just read the source (they won't). The README was last updated in 2024.

What this skill does: Scans your codebase structure, public APIs, and type definitions, then generates documentation that's actually useful. It creates function references, architecture overviews, setup guides, and API docs. It respects JSDoc/GoDoc/docstring conventions.

Real example: I pointed it at a Go-Zero microservice with 23 endpoints. In 2 minutes I had a complete API reference with request/response examples, auth requirements, and error codes. Previously this was a "we'll do it later" task that never got done.

Install:

npx tokrepo search documentation
npx tokrepo install <skill-id>

5. Deployment — Pre-flight Checks That Catch Problems Early

The problem: "Works on my machine" followed by a 2am production incident.

What this skill does: Runs a structured pre-deployment checklist: environment variable validation, dependency audit, build verification, migration status check, and smoke test generation. It's not a CI/CD replacement — it's the human checklist you forget to follow when you're rushing to ship.

Real example: Before deploying a Nuxt 3 SSR app, the skill caught that my .env.production was missing a new API key I'd added during development. Without it, the app would have booted fine but silently failed on every authenticated request. That's a subtle bug that takes hours to diagnose in production.

Install:

npx tokrepo search deployment
npx tokrepo install <skill-id>

Where These Skills Live

All five are available on TokRepo — an open registry of 200+ AI skills, prompts, MCP configs, and scripts. Think of it as npm for AI workflows.

You can browse the full catalog at tokrepo.com/en/featured or search from your terminal:

npx tokrepo search <keyword>

Each asset page has a one-click install command. Skills get saved to your Claude Code config, and you can start using them immediately.

What I Learned

The skills that save the most time aren't the flashy ones. They're the ones that automate the tasks you already know how to do but dread doing. Code review, commit messages, test writing, docs, deploy checks — none of these are hard. They're just tedious enough that you cut corners.

The compound effect is real. Five skills, each saving 30-60 minutes per week, adds up to an extra day of productive work every month.

If you've built a skill that saves you time, consider sharing it on TokRepo. The registry is open and every contribution helps the community.

What Claude Code skills are you using? Drop them in the comments — I'm always looking for new ones to try.

The Rise of AI Asset Marketplaces: Why Developers Need a Registry for Skills, Prompts, and MCP Configs

William Wang — Mon, 06 Apr 2026 09:58:27 +0000

The AI tooling ecosystem is growing faster than anyone can keep up with. New MCP servers appear daily. Claude Code skills are being shared in GitHub gists, Discord channels, and random blog posts. System prompts and agent workflows are scattered across dozens of repos with no standard format.

If you have worked with AI coding assistants for more than a few months, you know the pain: you had a perfect MCP config for Supabase three projects ago, but now you cannot find it. Someone shared a great code review skill on Discord, but the message is buried. You wrote a deployment workflow prompt that worked perfectly, but it lives in a repo you archived.

The npm Moment for AI Assets

Every developer tooling ecosystem eventually needs a registry. JavaScript had npm. Python had PyPI. Ruby had RubyGems. The pattern is always the same:

Tools get created and shared informally
The ecosystem grows past the point where informal sharing works
Someone builds a searchable, installable registry
The ecosystem accelerates because discovery and reuse become trivial

AI assets — skills, prompts, MCP configs, workflows — are at stage 2 right now. There are thousands of useful assets out there, but finding them requires knowing the right GitHub repos, Discord servers, or blog authors.

What an AI Asset Registry Looks Like

I have been building TokRepo, an open registry that aims to solve this problem. Here is what I think the minimum viable registry needs:

Structured metadata: Every asset should have a type (skill, prompt, MCP config, workflow), compatibility info (which tools it works with), and a description that is actually useful for search.

One-command install: Finding an asset should lead directly to using it. No manual copy-paste from README files.

npx tokrepo search "git workflow"
npx tokrepo install <uuid>

Agent-native access: If the whole point is to make AI assistants more capable, the registry itself should be accessible to AI assistants. TokRepo ships an MCP server so Claude Code can search and install assets mid-conversation:

claude mcp add tokrepo -- npx tokrepo-mcp-server

Once connected, your AI can search the registry directly. Say "find me a database migration skill" and it returns matching results with install commands.

Quality curation: Unlike a package registry where everything is code that either runs or does not, AI assets are more subjective. A prompt that works great for one use case might be terrible for another. Curation and community feedback matter.

Categories That Matter

After curating 200+ assets on TokRepo, I have seen clear patterns in what developers search for:

MCP Server Configs — The most popular category. Developers want ready-to-use configurations for database connectors, browser automation, search tools, and API integrations. The value is not the server itself (those are open source) but the tested, documented config that just works.

Claude Code Skills — CLAUDE.md rules and behaviors that teach Claude Code how to handle specific tasks: code reviews, git workflows, documentation generation, test writing. These are surprisingly powerful — a well-written skill can transform how an AI assistant approaches your codebase.

System Prompts — Instruction sets for specialized tasks. Technical writing, API design review, security auditing, data analysis. Good prompts encode domain expertise in a reusable format.

Workflows — Multi-step processes that combine tools and prompts. "Research a topic, draft an article, format for publishing" or "analyze a codebase, find issues, create fix PRs."

Why This Matters for the AI Ecosystem

The current state of AI asset sharing is roughly where JavaScript was before npm or where Python was before PyPI. Developers are doing amazing work, but the results are trapped in silos.

A good registry does not just make existing assets easier to find. It creates a feedback loop:

Developers publish assets that work well
Other developers find and use them, providing feedback
Assets improve based on real-world usage
More developers contribute because publishing is easy
The quality of the entire ecosystem rises

We are at the beginning of this cycle. The tools are still young, the formats are still evolving, and the best assets have not been written yet. But the trajectory is clear: AI development will be defined not just by the models, but by the ecosystem of reusable assets built on top of them.

Try It

If you work with Claude Code, Cursor, or any MCP-compatible tool:

# Search the registry
npx tokrepo search "code review"

# Add the MCP server to Claude Code
claude mcp add tokrepo -- npx tokrepo-mcp-server

Browse the full collection at tokrepo.com. Everything is free and open — no signup required to search or install.

What AI assets do you find yourself recreating across projects? I am curious what kinds of skills, prompts, or configs you would want in a registry like this.

Top 10 MCP Servers Every AI Developer Should Know About

William Wang — Mon, 06 Apr 2026 07:58:52 +0000

The Model Context Protocol (MCP) has quietly become the standard way to give AI coding assistants superpowers. Instead of being limited to reading and writing files, MCP lets tools like Claude Code, Cursor, and Codex connect to databases, browsers, APIs, and more.

But with dozens of MCP servers out there, which ones are actually worth setting up? Here are 10 that I use regularly and recommend to every developer working with AI tools.

1. Filesystem

What it does: Gives your AI assistant controlled read/write access to files and directories outside the default workspace.

Why it matters: Essential when your AI needs to access config files, logs, or assets in other directories.

claude mcp add filesystem -- npx @anthropic/mcp-filesystem ~/projects ~/configs

2. GitHub

What it does: Search repos, read issues, create PRs, manage branches — all through your AI assistant.

Why it matters: You can say "check my open PRs" or "create an issue for this bug" without leaving your terminal.

claude mcp add github -- npx @anthropic/mcp-github```
{% endraw %}
Requires a GitHub personal access token set as {% raw %}`GITHUB_TOKEN`{% endraw %}.

## 3. Brave Search

**What it does**: Web search through the Brave Search API — your AI can look things up in real time.

**Why it matters**: When your AI needs current documentation, error messages, or API references that aren't in its training data.
{% raw %}


```bash
claude mcp add brave-search -- npx @anthropic/mcp-brave-search```

Requires a free API key from [brave.com/search/api](https://brave.com/search/api/).

## 4. SQLite

**What it does**: Query and modify SQLite databases directly from your AI session.

**Why it matters**: Perfect for prototyping, exploring local databases, or building data-driven features. Your AI can write and run SQL queries, inspect schemas, and analyze results.



```bash
claude mcp add sqlite -- npx @anthropic/mcp-sqlite --db-path ./mydb.sqlite

5. TokRepo

What it does: Search, browse, and install from a registry of 200+ curated AI assets — skills, MCP configs, prompts, and workflows.

Why it matters: Instead of googling for "best Claude Code skill for code review" or digging through GitHub, your AI can search TokRepo directly and install assets in one step.

claude mcp add tokrepo -- npx tokrepo-mcp-server

Once connected, you get tools like tokrepo_search, tokrepo_trending, and tokrepo_install. Say "find me a good git workflow" and it returns matching assets from the registry with install commands. No API key needed.

6. Puppeteer

What it does: Browser automation — navigate pages, take screenshots, click elements, fill forms.

Why it matters: Great for testing web apps, scraping data, or debugging UI issues. Your AI can literally look at your app and tell you what's wrong.

claude mcp add puppeteer -- npx @anthropic/mcp-puppeteer```
{% endraw %}
## 7. Memory

**What it does**: Persistent key-value memory that survives across sessions using a local knowledge graph.

**Why it matters**: Your AI can remember project decisions, coding conventions, and context between conversations. No more re-explaining your architecture every session.
{% raw %}


```bash
claude mcp add memory -- npx @anthropic/mcp-memory```
{% endraw %}
## 8. Fetch

**What it does**: Makes HTTP requests — GET, POST, PUT, DELETE — to any URL.

**Why it matters**: Your AI can test APIs, pull data from endpoints, check if services are running, or interact with webhooks.
{% raw %}


```bash
claude mcp add fetch -- npx @anthropic/mcp-fetch```
{% endraw %}
## 9. Sequential Thinking

**What it does**: Provides a structured thinking framework that helps your AI break down complex problems step by step.

**Why it matters**: For architectural decisions, debugging complex issues, or planning multi-step implementations, this server helps the AI reason more carefully instead of jumping to solutions.
{% raw %}


```bash
claude mcp add sequential-thinking -- npx @anthropic/mcp-sequential-thinking```
{% endraw %}
## 10. PostgreSQL

**What it does**: Connect to PostgreSQL databases — run queries, inspect schemas, analyze data.

**Why it matters**: If your production or staging database is PostgreSQL, this lets your AI understand your data model, write queries, and help debug data issues.
{% raw %}


```bash
claude mcp add postgres -- npx @anthropic/mcp-postgres postgresql://user:pass@localhost/mydb```
{% endraw %}
---## How to Set Up Multiple MCP Servers

You can add MCP servers one by one with {% raw %}`claude mcp add`{% endraw %}, or configure them all at once in your {% raw %}`.mcp.json`{% endraw %}:
{% raw %}


```json
{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["@anthropic/mcp-filesystem", "~/projects"]
    },
    "github": {
      "command": "npx",
      "args": ["@anthropic/mcp-github"]    },
    "tokrepo": {
      "command": "npx",
      "args": ["tokrepo-mcp-server"]
    }
  }
}

Start with 2-3 that match your workflow, then add more as needed. Each server runs as a lightweight subprocess — they don't consume resources until your AI actually calls them.

Wrapping Up

MCP servers turn your AI assistant from a code-completion tool into something closer to a full development partner. The ones listed here cover the most common needs: file access, search, databases, browsers, APIs, and asset management.

What MCP servers are you using? I'm always looking for new ones to try — drop your favorites in the comments.

How I Built a Searchable Registry of 200+ Claude Code Skills and MCP Configs

William Wang — Mon, 06 Apr 2026 06:21:37 +0000

Last year I hit a wall.

I had dozens of Claude Code skills, MCP server configs, system prompts, and automation scripts scattered across different repos, gists, Notion pages, and Slack threads. Every time I started a new project, I'd spend 20 minutes hunting for "that one MCP config that worked perfectly with Supabase" or "the git workflow prompt I wrote three months ago."

Sound familiar?

I'm William, and I build developer tools. After losing the same configs for the third time, I decided to solve this properly. The result is TokRepo — an open registry for AI assets that works like npm, but for skills, prompts, MCP configs, and workflows.

The Problem: AI Config Sprawl Is Real

The MCP ecosystem is exploding. There are hundreds of MCP servers, thousands of Claude Code skills being shared on GitHub, and new agent workflows popping up every week. But there's no central place to find and install them.

Right now, if you want a good MCP config, you either:

Google it and hope someone wrote a blog post
Dig through GitHub repos with inconsistent README formats
Ask in Discord and wait for someone to paste a JSON snippet
Copy from a colleague's dotfiles

None of these are searchable. None are installable with one command. And none tell you if the config actually works with your setup.

What I Built

TokRepo is a searchable registry of curated AI assets — currently hosting 200+ entries across several categories:

Skills — Claude Code skills (CLAUDE.md rules and behaviors)
MCP Configs — Server configurations for Claude, Cursor, Codex, Gemini CLI
Prompts — System prompts and instruction templates
Scripts — Automation scripts for AI-assisted workflows
Configs — Editor configs, rules files, agent settings

Every asset has structured metadata, install instructions, and a detail page. You can browse the full collection on the featured page.

How It Works: CLI + MCP Server

1. CLI Search and Install

# Search for git-related workflows
npx tokrepo search "git workflow"

# Search for MCP server configs
npx tokrepo search "database mcp"

2. MCP Server (Agent-Native)

# Add to Claude Code
claude mcp add tokrepo -- npx tokrepo-mcp-server

Or add to your MCP config:

{
  "mcpServers": {
    "tokrepo": {
      "command": "npx",
      "args": ["tokrepo-mcp-server"]
    }
  }
}

Once connected, your AI assistant can search, browse trending, get details, and install assets — all from within your coding session.

What's Inside

Popular MCP configs: Database connectors, browser automation, search tools, and development tools.

Claude Code skills: Code review, git automation, documentation generators, test writing assistants.

System prompts: Technical writing, code refactoring, API design review, security auditing.

Browse the featured assets to see what's popular.

Try It Out

npx tokrepo search "code review"
claude mcp add tokrepo -- npx tokrepo-mcp-server

Browse at tokrepo.com. Feedback welcome — drop a comment.

5 robots.txt Mistakes That Make Your Site Invisible to AI Search

William Wang — Tue, 31 Mar 2026 10:33:20 +0000

AI search engines like ChatGPT, Perplexity, and Claude now answer millions of queries daily. But here's the thing — they can only cite your site if their crawlers can actually reach it.

I've scanned thousands of sites and these are the 5 most common robots.txt mistakes I see:

1. Blanket Disallow for unknown user agents

Many sites default to blocking all unrecognized bots. Problem: GPTBot, ClaudeBot, and PerplexityBot are relatively new. If your robots.txt has a catch-all block, you're invisible to AI search.

2. Blocking /api/ paths that contain public content

Some sites serve blog content through API routes. Blocking /api/ might seem like good security practice, but if your content lives there, AI crawlers can't see it.

3. No explicit Allow for AI crawlers

Even if you don't block them, explicitly allowing AI bots signals that you welcome their indexing. Add these to your robots.txt:

User-agent: GPTBot
Allow: /

User-agent: ClaudeBot
Allow: /

User-agent: PerplexityBot
Allow: /

User-agent: Google-Extended
Allow: /

4. Aggressive Crawl-delay values

Setting Crawl-delay: 30 means a bot waits 30 seconds between requests. For large sites, this means AI crawlers may only index a fraction of your content before timing out.

5. Forgetting to update after CMS migrations

Moved from WordPress to Next.js? Your old robots.txt rules might still be blocking paths that no longer exist — while failing to protect paths that should be private.

How to check

You can manually review your robots.txt, or run a free scan at geoscoreai.com — it checks all 9 AI search readiness signals including crawler access, structured data, and content structure. Takes about 60 seconds.

What robots.txt mistakes have you encountered? Drop them in the comments.

How I Built an AI Trading Discipline Scorer (and Why Profit Isn't the Right Metric)

William Wang — Sun, 29 Mar 2026 12:11:43 +0000

90% of traders lose money. Not because they can't read charts — but because they can't follow their own rules.

I've been building KeepRule, a trading journal that uses AI to score your discipline rather than just tracking profit and loss. Here's the story behind it and the tech that powers it.

The Problem

Every trader has experienced this cycle:

Market dips → panic sell
Price bounces back → regret
Buy high on FOMO → repeat

The problem isn't strategy. It's execution. Warren Buffett's Rule #1 is "Never lose money" — but how do you actually implement that?

The Solution: Score Discipline, Not Profit

KeepRule works in three steps:

1. Record

Before every trade, the user logs their thesis AND their emotional state. Not just "I bought AAPL at $150" but "I bought AAPL because of strong earnings, and I'm feeling confident but not FOMO-driven."

2. Refine

Over time, wins and losses become patterns. The app helps extract personal trading rules like:

"Never risk more than 2% on a single position"
"Don't trade within 30 minutes of market open"
"Don't trade on FOMO"

3. AI Discipline Score

Here's where it gets interesting. An AI reviews each trade and scores whether the trader followed their own rules — not whether they made money. A disciplined loss is better than a lucky win.

Tech Stack

Frontend: Nuxt 3 (SSR for SEO)
Backend: Go-Zero (high-performance Go microservice framework)
AI Scoring: Claude API for analyzing trade journals against personal rules
Database: MySQL with structured trade logs

The Explainer Video

I also built an explainer video using Remotion (React-based programmatic video framework) with Edge-TTS for voiceover generation. The whole video is code — every animation, transition, and scene is a React component.

Key lesson from video production: never use CSS filter: blur() in Remotion — it causes frame-to-frame flickering in headless Chrome's multi-threaded rendering. Use radial-gradient and textShadow instead, and render with --concurrency=1.

What I Learned

The biggest insight: traders don't need more information. They need a system that makes their existing knowledge actionable even when emotions are running high.

If you're interested, try it free at keeprule.com. Would love feedback from the dev community!

Built by William Wang — also building GEOScore AI for AI search visibility.

From Invisible to Cited: How One Website Improved Their GEO Score from 23 to 87

William Wang — Fri, 27 Mar 2026 10:17:45 +0000

By William Wang, Founder of GEOScore AI

This is the story of how a mid-sized B2B SaaS company went from being completely invisible to AI search engines to being regularly cited by ChatGPT, Perplexity, and Google's AI Overviews — in 8 weeks.

The company (which asked to remain anonymous) sells project management software. They had strong traditional SEO — ranking on page 1 for several competitive keywords. But when they tested queries about their product category in ChatGPT and Perplexity, they were never mentioned. Their competitors were.

The Starting Point: GEO Score 23/100

When they ran their first scan through GEOScore AI, the results were sobering:

Overall GEO Score: 23/100 (Grade: F)
AI Crawler Access: Blocked — robots.txt was blocking GPTBot, ClaudeBot, and PerplexityBot
llms.txt: Missing entirely
Schema Markup: Only basic Organization schema, no Article or FAQ markup
Content Structure: Long-form content buried answers under lengthy introductions
Author Signals: No author bylines on blog posts

The diagnosis was clear: their site was technically invisible to AI search engines, and even if crawlers could access it, the content was not structured for citation.

Week 1-2: Technical Foundation

Fix 1: robots.txt (Impact: Critical)

They updated robots.txt to explicitly allow all major AI crawlers. This single change was the most important — without it, nothing else would matter.

Before:

User-agent: *
Disallow: /api/
Disallow: /admin/
# No AI-specific rules = default allow, BUT...
# Their Cloudflare WAF was blocking unknown user agents

After:

User-agent: GPTBot
Allow: /

User-agent: ChatGPT-User
Allow: /

User-agent: ClaudeBot
Allow: /

User-agent: PerplexityBot
Allow: /

User-agent: Google-Extended
Allow: /

User-agent: *
Disallow: /api/
Disallow: /admin/

They also updated their Cloudflare WAF rules to whitelist AI crawler user agents.

GEO Score after Week 2: 41/100

Fix 2: llms.txt (Impact: High)

They created a comprehensive llms.txt file listing their product pages, key blog posts, documentation, and case studies.

Time to implement: 30 minutes

Week 3-4: Content Restructuring

Fix 3: Direct Answer Format

They restructured their top 15 blog posts to lead with direct answers. Instead of:

"In today's fast-paced business environment, project management has become increasingly complex..."

They rewrote openings like:

"The best project management methodology for remote teams in 2026 is a hybrid approach combining async Kanban boards with weekly synchronous sprint reviews. Here is why, and how to implement it."

Fix 4: FAQ Sections

They added FAQ sections with Schema.org FAQPage markup to their 10 most-visited pages. Each FAQ contained 5-8 questions that mapped to real queries users ask AI search engines.

Fix 5: Factual Density

They audited content for vague claims and replaced them with specifics:

"Improves productivity" → "Reduces project delivery time by 31% based on data from 2,400 teams"
"Many companies use our tool" → "Used by 8,500+ teams including 12 Fortune 500 companies"

GEO Score after Week 4: 62/100

Week 5-6: Authority Building

Fix 6: Author Bylines

Every blog post got a proper author byline with credentials, photo, and link to the author's LinkedIn. They also created individual author pages.

Fix 7: Schema Markup Expansion

They added:

Article schema to all blog posts (with author, datePublished, dateModified)
FAQPage schema to FAQ sections
Organization schema with comprehensive company details
Product schema to product pages

GEO Score after Week 6: 74/100

Week 7-8: Optimization and Monitoring

Fix 8: Internal Linking

They improved internal linking to ensure their most important content was discoverable within 2 clicks from the homepage.

Fix 9: Content Freshness

They updated dates on all evergreen content and added "Last updated" timestamps.

Final GEO Score: 87/100 (Grade: A)

The Results

Within 4 weeks of reaching GEO Score 87:

ChatGPT started citing their blog posts in responses about project management best practices
Perplexity began including their product in comparison queries ("best project management tools for remote teams")
Google AI Overviews started featuring snippets from their FAQ sections

They estimated the AI search traffic represented approximately 15% additional organic traffic on top of their existing traditional search traffic — and this percentage was growing monthly.

Key Takeaways

robots.txt is the #1 blocker — If AI crawlers cannot access your site, nothing else matters. This accounted for the biggest single score jump (23 → 41).
Content structure matters more than content quality — Their content was already high quality. The problem was that it was not structured for AI extraction.
Small changes compound — No single fix transformed their score. It was the combination of 9 targeted improvements that moved them from 23 to 87.
Speed matters — The sooner you fix technical blockers, the sooner AI systems start indexing your content. They wished they had started 6 months earlier.
Measurement drives improvement — Running regular GEOScore scans after each change let them see which fixes had the most impact and prioritize accordingly.

Your Turn

Want to know your GEO score? Run a free scan at geoscoreai.com — takes 60 seconds, no signup. You will get your score, top 3 blocking issues, and a clear starting point for improvement.

William Wang is the founder of GEOScore AI. He writes about AI search optimization and helping websites get found by the next generation of search engines.