skill-developer

Auto-activates Claude Code skills based on triggers in prompts and code context.

3|1|Updated Oct 27, 2025
One-click install
npx skills add https://github.com/bartolli/codanna-profiles --skill skill-developer-bartolli
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: skill-developer
Source: https://github.com/bartolli/codanna-profiles/tree/main/.codanna-profile/profiles/codanna/.claude/skills/skill-developer
Command: npx skills add https://github.com/bartolli/codanna-profiles --skill skill-developer-bartolli

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires npx, tsx, jq, and includes references (resource) components.

What problem does it solve?

Developing and maintaining AI skills can be complex, involving intricate trigger patterns, hook mechanisms, and adherence to best practices. This skill streamlines the entire lifecycle of Claude Code skill development, from creation to debugging, ensuring efficient and compliant automation.

Core Features & Use Cases

  • Skill Creation & Management: Guides you through structuring new skills, defining triggers, and configuring enforcement levels.
  • Hook System Mastery: Understand and debug UserPromptSubmit and PreToolUse hooks for proactive suggestions and guardrail enforcement.
  • Best Practices & Compliance: Ensures skills adhere to Anthropic's 500-line rule and progressive disclosure patterns, optimizing for token efficiency and clarity.
  • Use Case: You need to create a new "database-verification" guardrail skill. Use this skill to quickly set up the SKILL.md, define fileTriggers and contentPatterns for SQL files, configure a block enforcement, and test its activation, all while ensuring it follows best practices.

Quick Start

I want to create a new skill to help users with "React component development".

Frequently Asked Questions about skill-developer

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I create a Claude Code skill with triggers and hooks?

Claude Code skills use trigger patterns and hooks to auto-activate automation. Define triggers in `skill-rules.json` to match keywords or file patterns, configure enforcement levels (block, suggest, warn), and bind logic to `UserPromptSubmit` or `PreToolUse` hooks. Test activation by simulating prompts or file edits that match your trigger patterns.

What's the best way to structure a guardrail skill for file type enforcement?

Structure guardrail skills by defining `fileTriggers` and `contentPatterns` targeting specific file types (e.g., SQL files), setting enforcement to `block` or `suggest`, and configuring session-aware checks via `skill-rules.json`. Include references to document trigger syntax and progressive disclosure rules to keep skills under the 500-line limit.

How do trigger patterns and intent matching work in skill development?

Trigger patterns match keywords, file paths, and content within prompts or code context. Intent patterns detect semantic purpose. Hooks like `UserPromptSubmit` intercept prompts for evaluation; `PreToolUse` validates tool requests. Session tracking enables stateful enforcement across multiple interactions within a single session.

Can I debug skill activation and hook execution in Claude Code?

Debug skills by testing trigger matching with sample prompts and files, inspecting `skill-rules.json` configuration for enforcement levels, and validating hook orchestration across `UserPromptSubmit` and `PreToolUse` stages. Use `jq` to parse rule configurations and trace progressive disclosure outputs.

What are the constraints when building domain and guardrail skills?

Skills must stay under 500 lines, follow progressive disclosure patterns to avoid token bloat, and use session-aware guardrails for consistency. Trigger matching must be precise to avoid false positives; enforcement levels must align with use case severity to balance automation with user control.

Do I need tsx and npx to develop and test Claude Code skills?

Yes. `npx` manages skill dependencies and tooling, `tsx` executes TypeScript-based skill logic, and `jq` parses `skill-rules.json` configurations during development and testing. These dependencies enable rapid iteration on trigger patterns and hook logic.