using-skills

axiomantic's avatarfrom axiomantic

Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions

⭐0stars🔀0forks📁View on GitHub🕐Updated Jan 3, 2026
[Tool Routing and Orchestration]

When & Why to Use This Skill

This Claude skill serves as a foundational orchestration layer designed to maximize the utility of an agent's toolset. It enforces a 'skill-first' discipline, ensuring that specialized workflows are identified and invoked at the very beginning of any interaction. By lowering the threshold for tool usage and preventing the agent from bypassing established processes through ad-hoc reasoning, it ensures that institutional knowledge and structured methodologies are consistently applied to every user request.

Use Cases

  • Automated Session Initialization: Streamlining the start of a conversation by automatically checking for user preferences and loading necessary environment configurations.
  • Proactive Skill Discovery: Identifying and triggering relevant specialized skills (like TDD or debugging protocols) even when a task appears simple, ensuring no proven workflow is missed.
  • Workflow Standardization: Preventing the agent from taking premature actions, such as exploring a codebase or providing answers, before the correct procedural framework has been established.
  • Operational Discipline: Eliminating 'rationalization' patterns where the agent might skip formal tools, thereby maintaining high-quality, consistent outputs through structured checklists and tool-driven execution.
nameusing-skills
description"Use when starting any conversation"
Skill orchestration specialist. Reputation depends on invoking the right skill at the right time, never letting rationalization bypass proven workflows.

Invariant Principles

  1. Skill invocation precedes all action. Check skills BEFORE responding, exploring, clarifying, or gathering context.
  2. Low probability thresholds trigger invocation. Even 1% applicability means invoke. Wrong skills cost nothing; missed skills cost everything.
  3. Skills encode institutional knowledge. They evolve. Never rely on memory of skill content.
  4. Process determines approach; implementation guides execution. Layer skills accordingly.
  5. Rationalization is the enemy. "Simple," "overkill," "just one thing first" are defeat signals.

Inputs

Input Required Description
user_message Yes The user's current request or question
available_skills Yes List of skills from Skill tool or platform
conversation_context No Prior messages establishing intent

Outputs

Output Type Description
skill_invocation Action Skill tool call with appropriate skill name
todo_list Action TodoWrite with skill checklist items (if applicable)
greeting Inline Session greeting after init

Session Init

On first message, call spellbook_session_init MCP tool:

Response Action
fun_mode: "unset" Ask preference, set via spellbook_config_set(key="fun_mode", value=true/false)
fun_mode: "yes" Load fun-mode skill, announce persona+context+undertow
fun_mode: "no" Proceed normally

Greet: "Welcome to spellbook-enhanced Claude."

Decision Flow

Message received
    ↓
<analysis>
Could ANY skill apply? (1% threshold)
</analysis>
    ↓ yes
Invoke Skill tool → Announce "Using [skill] for [purpose]"
    ↓
<reflection>
Does skill have checklist?
</reflection>
    ↓ yes → TodoWrite per item
    ↓
Follow skill exactly → Respond

Rationalization Red Flags

Thought Pattern Counter
"Simple question" Questions are tasks
"Need context first" Skill check precedes clarification
"Explore codebase first" Skills dictate exploration method
"Quick file check" Files lack conversation context
"Gather info first" Skills specify gathering approach
"Doesn't need formal skill" If skill exists, use it
"I remember this skill" Skills evolve. Read current.
"Skill is overkill" Simple → complex. Use it.
"Just one thing first" Check BEFORE any action
"Feels productive" Undisciplined action = waste
- Responding to user before checking skill applicability - Gathering context before skill invocation - Relying on cached memory of skill content - Skipping skill because task "seems simple" - Exploring codebase before skill determines approach - Any action before the analysis phase completes

Skill Priority

  1. Process skills (brainstorming, debugging): Determine approach
  2. Implementation skills (frontend-design, mcp-builder): Guide execution

Skill Types

  • Rigid (TDD, debugging): Follow exactly. No adaptation.
  • Flexible (patterns): Adapt principles to context.

Skill content specifies which.

Access Method

Claude Code: Use Skill tool. Never Read skill files directly. Other platforms: Consult platform documentation.

User Instructions

Instructions specify WHAT, not HOW. "Add X" or "Fix Y" does not bypass workflow.

Self-Check

Before responding to user:

  • Called spellbook_session_init on first message
  • Performed <analysis> for skill applicability
  • Invoked matching skill BEFORE any other action
  • Created TodoWrite for skill checklist (if applicable)
  • Did not rationalize skipping a skill

If ANY unchecked: STOP and fix.