name: agentic-advisor description: Detects agentic opportunities in code and explains options with flowcharts trigger_phrases:

"process in background"
"monitor"
"check every"
"alert when"
"generate template"
"surface"
"prioritize"
"filter by context" auto_activate: true

Agentic Advisor Skill

Purpose

Detect when code would benefit from Agent SDK, MCP, or Skills and explain options clearly with visual flowcharts. This skill activates automatically when certain code patterns are detected.

Auto-Activation Rules

This skill activates when ANY of these conditions are met:

Condition 1: Background Processing Keywords

// Triggers on:
- "async function process"
- "background job"
- "queue"
- "worker"
- "pipeline"

Condition 2: Context-Aware Logic

// Triggers on:
- "filter by context"
- "prioritize based on"
- "surface when"
- "smart filtering"
- "relevant to user"

Condition 3: Repeating Patterns

// Triggers on:
- "generate template"
- "create form"
- "format consistently"
- "same structure"

Condition 4: External Monitoring

// Triggers on:
- "setInterval"
- "watch for"
- "monitor"
- "fetch every"
- "check periodically"

Condition 5: Autonomous Behavior

// Triggers on:
- "automatically"
- "when X happens, do Y"
- "without user action"
- "scheduled task"

Detection Rules (Code Analysis)

Rule 1: Background Processing

// Pattern match
if (code.includes('async') &&
    (code.includes('process') || code.includes('extract'))) {
  // Likely candidate for Agent SDK
  presentOptions('background_processing');
}

Rule 2: External Monitoring

// Pattern match
if (code.includes('fetch') &&
    (code.includes('setInterval') || code.includes('monitor'))) {
  // Needs MCP + Agent
  presentOptions('external_monitoring');
}

Rule 3: Template Generation

// Pattern match
if (code.includes('template') ||
    code.includes('generate') && code.includes('form')) {
  // Needs Skill
  presentOptions('repeatable_pattern');
}

Rule 4: Context-Aware Decisions

// Pattern match
if (code.includes('filter') && code.includes('context')) {
  // Candidate for Agent SDK
  presentOptions('context_aware');
}

Response Template

When pattern detected, generate this structure:

┌─────────────────────────────────────────────┐
│   AGENTIC OPPORTUNITY DETECTED              │
└─────────────────────────────────────────────┘

Pattern: [Name]
Location: [File/function]
Complexity: [Low/Medium/High]

┌─── OPTION A: Simple Function ───────────────┐
│                                             │
│  User Action                                │
│      ↓                                      │
│  Function Runs                              │
│      ↓                                      │
│  Returns Result                             │
│                                             │
│  Pros: Fast, simple, testable              │
│  Cons: No autonomy, no learning            │
└─────────────────────────────────────────────┘

┌─── OPTION B: Agent SDK ─────────────────────┐
│                                             │
│  Trigger (time/event)                       │
│      ↓                                      │
│  Agent Gathers Context (MCP)                │
│      ↓                                      │
│  Agent Decides Action (AI)                  │
│      ↓                                      │
│  Agent Executes (Tools)                     │
│      ↓                                      │
│  Agent Verifies (Loop)                      │
│                                             │
│  Pros: Autonomous, learns, integrates       │
│  Cons: Complex, needs setup                 │
└─────────────────────────────────────────────┘

Recommendation: [Context-specific advice]

Questions to help decide:
1. Will this run without user trigger? → Agent
2. Does this need external data? → MCP
3. Does this repeat often? → Skill
4. Is this MVP or production? → Simple vs Agent

Would you like me to:
1. Build Option A (simple) with upgrade path
2. Build Option B (agentic) now
3. Show more architecture details

HTML Flowchart Generation

For complex decisions, generate interactive HTML:

<!DOCTYPE html>
<html>
<head>
  <title>[Feature Name]: Agentic Decision</title>
  <style>
    body { font-family: Arial; max-width: 1200px; margin: 40px auto; }
    .comparison { display: grid; grid-template-columns: 1fr 1fr; gap: 20px; }
    .option { border: 3px solid #ddd; border-radius: 8px; padding: 20px; }
    .option.simple { border-color: #27ae60; }
    .option.agent { border-color: #3498db; }
    h2 { text-align: center; }
    .pros { color: #27ae60; }
    .cons { color: #e74c3c; }
    .flow { background: #f8f9fa; padding: 15px; margin: 10px 0;
            border-left: 4px solid #333; font-family: monospace; }
  </style>
</head>
<body>
  <h1>[Feature Name]: Choose Your Approach</h1>

  <div class="comparison">
    <div class="option simple">[Option A content]</div>
    <div class="option agent">[Option B content]</div>
  </div>

  <div class="recommendation">
    <h3>Recommended Path</h3>
    <p>Start with Option A, upgrade to B when:</p>
    <ul>
      <li>[Specific trigger for upgrade]</li>
      <li>[Another trigger]</li>
    </ul>
    <p><strong>Key:</strong> Build with agent-ready interface</p>
    <pre>[Show interface code that works for both]</pre>
  </div>
</body>
</html>

Save to: .claude/decisions/[feature-name]-decision.html

Example Patterns for BizzyForge

Pattern: Task Surfacing

Trigger: "surface tasks based on context"
Pattern Detected: Context-Aware Decisions
Recommendation:
  - Option A: Simple filter function with Supabase hooks
  - Option B: Agent SDK with weather MCP + pattern learning
  - Upgrade trigger: When weather integration requested

Pattern: Grain Price Monitoring

Trigger: "watch grain prices and alert"
Pattern Detected: External Monitoring
Recommendation:
  - Option A: NOT RECOMMENDED (can't monitor without agent)
  - Option B: Agent SDK + DTN MCP required
  - This MUST be agentic from start

Pattern: Spray Record Generation

Trigger: "generate spray records"
Pattern Detected: Repeating Pattern
Recommendation:
  - Option A: React component with props
  - Option B: Skill with templates
  - Upgrade trigger: When variations exceed 3 types

Decision Logging

Log every decision to .claude/decisions/agentic-decisions.json:

{
  "decisions": [
    {
      "feature": "task-surfacing",
      "detected_pattern": "context-aware-decisions",
      "chosen_approach": "simple-function-with-upgrade-path",
      "reasoning": "MVP first, agent later when patterns clear",
      "upgrade_trigger": "when we add weather integration",
      "timestamp": "2026-01-21T10:30:00Z",
      "decision_file": ".claude/decisions/task-surfacing-decision.html"
    }
  ]
}

For Non-Technical Users (Farming Context)

When explaining to farmers:

"Think of it like hiring help on the farm:

Simple Function = You tell someone exactly when to do a task

You: 'Process this document now'
They: Process it and report back
Good for: One-time tasks, testing

Agent = You hire someone to watch and decide

You: 'Keep an eye on grain prices'
They: Check prices, decide when to alert you, learn patterns
Good for: Ongoing monitoring, intelligent decisions

MCP = Giving your helper access to tools

Like giving them access to weather apps, price feeds
They make smarter decisions with more information

Skill = Teaching them the farm's way

'This is how we format spray records'
They do it consistently every time"

Critical Reminders

Always activate on patterns - Don't wait to be asked
Present both options - Even if one is clearly better
Generate HTML artifact - Visual aids help decision-making
Log decisions - Track what was chosen and why
Reference AI_ARCHITECTURE_REFERENCE.md - Stay aligned with core patterns

Integration with Existing Skills

This skill works alongside:

agentic-opportunity-spotter.md - Uses the 5 signals
agentic-patterns.md - Provides implementation patterns
AI_ARCHITECTURE_REFERENCE.md - Provides MCP/Skills/Agent rules

Activation Examples

Example 1: Task Surfacing

User: "Build task surfacing that shows relevant tasks"
AI: [Detects "surface" + "relevant"]
    [Loads agentic-advisor skill]
    [Presents options with flowchart]
    [Waits for decision]

Example 2: Document Processing

User: "Process uploaded documents in background"
AI: [Detects "process" + "background"]
    [Loads agentic-advisor skill]
    [Presents Agent SDK option]
    [Shows verification loop pattern]

Example 3: Price Monitoring

User: "Monitor grain prices every 15 minutes"
AI: [Detects "monitor" + interval]
    [Loads agentic-advisor skill]
    [Recommends Agent + MCP (required)]
    [Explains why simple function won't work]

Usage: This skill activates automatically. No need to call it explicitly. Override: Say "just build it simple" or "build it agentic" to skip. Files Created: .claude/decisions/*.html and .claude/decisions/agentic-decisions.json

agentic-advisor

SKILL.md