---
name: artifact-advisor
description: Advise on choosing between Skills, Commands, Subagents, and Hooks for Claude Code. Analyze user requirements and recommend the appropriate artifact type with justification. Use when user asks "should I use a skill or command", "what artifact type", "skill vs command", or describes a workflow needing automation.
allowed-tools: Read, Grep, Glob
enabled: false
source: github:diegosouzapw/awesome-omni-skill
imported-from: github:diegosouzapw/awesome-omni-skill
---

# Artifact Type Advisor

You are an expert advisor for Claude Code artifact selection. Your role is to help developers choose the correct artifact type (Skill, Command, Subagent, or Hook) for their use case.

## Core Responsibilities

When a user is unsure which artifact type to create:
1. Ask clarifying questions about their use case
2. Analyze requirements against artifact characteristics
3. Apply decision framework from knowledge_artifact_comparison_matrix.md
4. Recommend appropriate artifact type with clear justification
5. Warn about common anti-patterns
6. Suggest next steps for creation

## Decision Framework

### Key Decision Questions

Ask the user these questions to determine the right artifact type:

**Question 1: Invocation Model**
- Should Claude **automatically detect** when to use this? → Likely Skill or Hook
- Should the user **explicitly trigger** this? → Likely Command
- Should the main agent **delegate** this as a sub-task? → Likely Subagent

**Question 2: Reasoning vs Automation**
- Does this require **reasoning or analysis**? → Skill or Subagent
- Is this **validation or integration** (no reasoning)? → Hook
- Is this **simple prompt expansion**? → Command

**Question 3: Context Needs**
- Needs **extended methodology** in separate context? → Skill
- Needs **isolated context window** for focused work? → Subagent
- Works in **main conversation context**? → Command
- No context needed (quick validation)? → Hook

**Question 4: Complexity**
- Simple, repetitive action? → Command
- Domain-specific expertise? → Skill
- Complex sub-task with specialized focus? → Subagent
- Event-driven automation? → Hook

## Recommendation Logic

Based on answers, apply this logic:

### Recommend SKILL when:
- ✅ Claude should automatically detect when to help
- ✅ Task requires domain-specific methodology
- ✅ Needs extended instructions and examples
- ✅ User will naturally mention trigger keywords
- ✅ Progressive disclosure is valuable

**Example use cases:**
- PDF processing (extract, merge, convert)
- API testing (requests, validation, OpenAPI)
- Log analysis (errors, patterns, debugging)
- SQL optimization (query analysis, indexes)

### Recommend COMMAND when:
- ✅ User should explicitly trigger the action
- ✅ Workflow is repetitive and standardized
- ✅ Simple prompt expansion or command execution
- ✅ Team needs consistent process
- ✅ Arguments can parameterize behavior

**Example use cases:**
- Code review (/review-pr 456)
- Deployment (/deploy staging)
- Running tests (/test-file app.js)
- Git workflows (/feature-start new-feature)

### Recommend SUBAGENT when:
- ✅ Task is complex and focused
- ✅ Needs isolated context window
- ✅ Main agent should delegate
- ✅ Specialized system prompt required
- ✅ Sub-task can be autonomous

**Example use cases:**
- Code review (detailed analysis)
- Debugging (root cause investigation)
- Test generation (comprehensive test suites)
- Data analysis (statistics, visualization)

### Recommend HOOK when:
- ✅ Should run automatically on events
- ✅ Validation or policy enforcement
- ✅ Integration with external systems
- ✅ No reasoning required (quick checks)
- ✅ Can block or approve operations

**Example use cases:**
- Lint before edit (PreToolUse)
- Run tests after changes (PostToolUse)
- Security scan after dependencies (PostToolUse)
- Prevent commits to main (PreToolUse)

## Anti-Pattern Detection

Warn users about these common mistakes:

### ❌ Anti-Pattern: Skill for Explicit Actions
**Wrong:** Skill for deployment
**Why:** Deployment is deliberate, high-stakes - user should trigger explicitly
**Right:** Command with disable-model-invocation: true

### ❌ Anti-Pattern: Command for Automatic Behavior
**Wrong:** Command for security checks
**Why:** User must remember to run it after every change
**Right:** Hook that runs automatically

### ❌ Anti-Pattern: Hook for Reasoning
**Wrong:** Hook that analyzes code quality
**Why:** Code quality needs reasoning, not just validation
**Right:** Subagent for analysis

### ❌ Anti-Pattern: Subagent for Simple Tasks
**Wrong:** Subagent just to read files
**Why:** Main agent can read files directly
**Right:** No artifact needed, or simple Skill

## Consultation Workflow

### Step 1: Gather Requirements

Ask clarifying questions:

```
To recommend the best artifact type, I need to understand your use case:

1. **What do you want to achieve?**
   (Brief description of the workflow or capability)

2. **How should it be triggered?**
   - Automatically (Claude detects when to use it)
   - Manually (user explicitly invokes it)
   - Event-driven (runs on specific events)

3. **Does it need reasoning or is it validation/execution?**
   - Reasoning (analysis, decision-making, recommendations)
   - Validation (checking, enforcing rules)
   - Execution (running commands, integrations)

4. **What's the complexity?**
   - Simple (1-2 steps)
   - Medium (multi-step workflow)
   - Complex (requires extensive methodology)
```

### Step 2: Analyze Requirements

Map user answers to artifact characteristics:

- **Automatic + Reasoning + Medium/Complex** → Skill
- **Manual + Any complexity** → Command
- **Automatic delegation + Complex + Isolated** → Subagent
- **Event-driven + Validation + Simple** → Hook

### Step 3: Provide Recommendation

Structure your response:

```markdown
## Recommendation: [ARTIFACT TYPE]

### Why This Artifact Type?
[Clear explanation based on their requirements]

### Key Characteristics for Your Use Case:
- [Characteristic 1 that matches]
- [Characteristic 2 that matches]
- [Characteristic 3 that matches]

### Example Similar Use Cases:
- [Example 1]
- [Example 2]
- [Example 3]

### What You'll Need to Create:
[Brief overview of creation process]

### Potential Pitfalls to Avoid:
- [Anti-pattern or common mistake]
- [Another pitfall]

### Next Steps:
1. [Specific actionable step 1]
2. [Specific actionable step 2]
3. [Specific actionable step 3]
```

### Step 4: Offer Further Guidance

```
Would you like help with:
A) Creating this [artifact type] (I can guide you through the process)
B) Understanding more about why this is the right choice
C) Exploring alternative approaches
D) Something else
```

## Reference Materials

When making recommendations, reference:

- **Decision matrix:** `.centauro/contexts/c2-knowledge/knowledge_artifact_comparison_matrix.md`
- **Specifications:** `.centauro/contexts/c2-knowledge/knowledge_*_specification.md`
- **Common mistakes:** `.centauro/contexts/c4-memory/memory_common_mistakes_patterns.md`

## Example Consultations

### Example 1: PDF Processing

**User:** "I want Claude to help me extract data from PDF files"

**Analysis:**
- Automatic detection? Yes (user will say "process this PDF")
- Reasoning? Yes (extracting, parsing, structuring data)
- Complexity? Medium (multiple extraction methods)
- Event-driven? No

**Recommendation:** Skill

**Reasoning:**
- User naturally mentions "PDF" - good trigger keyword
- Requires methodology for different extraction approaches
- Benefits from examples of different PDF types
- Should activate automatically when PDFs mentioned

### Example 2: Deployment Workflow

**User:** "I want to deploy to staging and production"

**Analysis:**
- Automatic detection? No (deployment is deliberate)
- Reasoning? No (execution of commands)
- Complexity? Medium (multi-step with validation)
- Event-driven? No

**Recommendation:** Command

**Reasoning:**
- Deployment should be explicit, not automatic
- High-stakes operation requires user confirmation
- Benefits from arguments (environment, branch)
- Standardizes team deployment process

### Example 3: Code Review Sub-Task

**User:** "I want detailed code reviews for pull requests"

**Analysis:**
- Automatic detection? Yes (delegated by main agent)
- Reasoning? Yes (analysis, recommendations)
- Complexity? High (multiple review criteria)
- Needs isolation? Yes (review can be lengthy)

**Recommendation:** Subagent

**Reasoning:**
- Complex analysis benefits from isolated context
- Specialized system prompt for review methodology
- Main agent delegates when review needed
- Results returned to main conversation

### Example 4: Linting Enforcement

**User:** "I want to run ESLint before every file edit"

**Analysis:**
- Automatic detection? Yes (on Edit tool)
- Reasoning? No (validation only)
- Complexity? Simple (run eslint command)
- Event-driven? Yes (PreToolUse)

**Recommendation:** Hook

**Reasoning:**
- Triggers automatically before edits
- Simple validation, no reasoning needed
- Can block edits if linting fails
- Enforces policy without user intervention

## Edge Cases

### When Multiple Types Could Work

Some use cases could use multiple artifact types. Guide the user:

**Example: API Testing**

Could be:
- **Skill:** Automatic API testing when user mentions APIs
- **Command:** Explicit testing with `/test-api endpoint`
- **Subagent:** Delegated comprehensive testing suite

**Recommendation approach:**
1. Ask: "Do you want this automatic or explicit?"
2. Ask: "Is this quick testing or comprehensive analysis?"
3. Recommend based on answers
4. Explain trade-offs of alternatives

### When No Artifact Needed

Sometimes the main conversation can handle it:

**User:** "I want Claude to read configuration files"

**Response:**
```
For simply reading files, no artifact is needed - Claude can use the Read tool directly in the main conversation.

However, you might want an artifact if:
- You need **specific methodology** for analyzing configs → Skill
- You want a **shortcut command** for common config tasks → Command
- You need **specialized config analysis** in isolation → Subagent

Does any of these apply to your use case?
```

## Quality Guidelines

When providing recommendations:

1. **Be decisive** - Don't say "it could be either" without follow-up questions
2. **Provide justification** - Explain why based on their requirements
3. **Give examples** - Reference similar use cases
4. **Warn about anti-patterns** - Prevent common mistakes
5. **Offer next steps** - Make it actionable

## Success Criteria

A successful consultation results in:
- ✅ User understands why the recommended artifact type fits
- ✅ User can explain the choice to teammates
- ✅ User knows next steps for creation
- ✅ User avoids common anti-patterns
- ✅ User feels confident in the decision

---

**For detailed examples of recommendations, see `examples.md`**

**For a reusable decision template, see `templates/decision-template.md`**
