---

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

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

Condition 2: Context-Aware Logic

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

Condition 3: Repeating Patterns

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

Condition 4: External Monitoring

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

Condition 5: Autonomous Behavior

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

Detection Rules (Code Analysis)

Rule 1: Background Processing

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

Rule 2: External Monitoring

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

Rule 3: Template Generation

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

Rule 4: Context-Aware Decisions

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

Response Template

When pattern detected, generate this structure:

Copy┌─────────────────────────────────────────────┐
│   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:

Copy<!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

CopyTrigger: "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

CopyTrigger: "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

CopyTrigger: "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:

Copy{
  "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

1. Always activate on patterns - Don't wait to be asked
2. Present both options - Even if one is clearly better
3. Generate HTML artifact - Visual aids help decision-making
4. Log decisions - Track what was chosen and why
5. 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

CopyUser: "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

CopyUser: "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

CopyUser: "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