skills.json

{
  "schema_version": 1,
  "repo": "cobusgreyling/agent-skills",
  "generated_by": "scripts/build_index.py",
  "agent_compat_legend": {
    "native": "Loads as-is in the agent's native skill mechanism.",
    "loadable": "Content is portable; include via the agent's context-reference mechanism.",
    "convertible": "Content is portable; requires a per-agent format conversion (e.g. Cursor MDC)."
  },
  "skills": [
    {
      "name": "agent-architecture-patterns",
      "path": "skills/agent-architecture-patterns",
      "description": "Choose the right architecture for an LLM agent or multi-agent system. Use when the user is designing, comparing, or debugging agentic workflows and mentions ReAct, Reflexion, Plan-and-Execute, Router, Supervisor, Hierarchical, multi-agent, tool-use loop, agent graph, LangGraph, AutoGen, CrewAI, or asks \"which agent pattern should I use\" / \"how should this agent be structured\".",
      "tags": [
        "architecture",
        "patterns",
        "multi-agent",
        "design"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": true,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    },
    {
      "name": "agent-cost-modeling",
      "path": "skills/agent-cost-modeling",
      "description": "Model the cost of an LLM agent before it ships, and after. Use when the user is planning a deployment, comparing patterns, choosing a model tier, or justifying a budget and mentions tokens per task, cost per task, unit economics, cost ceiling, cache hit rate, ReAct cost, multi-agent cost, or asks \"how much will this cost?\" / \"is this economical at scale?\".",
      "tags": [
        "cost",
        "production",
        "architecture",
        "economics"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": false,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    },
    {
      "name": "agent-evaluation-harness",
      "path": "skills/agent-evaluation-harness",
      "description": "Design an evaluation harness for an LLM agent before shipping it. Use when the user is building or rewriting an agent, deciding ship/no-ship, debugging regressions, or mentions golden sets, eval suites, regression tests, trace-level evals, LLM-as-judge, scoring rubrics, or asks \"how do I test this agent?\" / \"how do I know if my agent got better?\".",
      "tags": [
        "evaluation",
        "production",
        "regression",
        "quality"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": false,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    },
    {
      "name": "agent-observability",
      "path": "skills/agent-observability",
      "description": "Instrument an LLM agent so failures are diagnosable, traces are replayable, and evals can run against production data. Use when the user is moving an agent past prototype and mentions tracing, spans, OpenTelemetry, LangSmith, Langfuse, Arize, OpenLLMetry, structured logs, GenAI semantic conventions, or asks \"how do I debug this agent in production?\" / \"what should I log?\".",
      "tags": [
        "observability",
        "tracing",
        "production",
        "opentelemetry"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": false,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    },
    {
      "name": "context-window-hygiene",
      "path": "skills/context-window-hygiene",
      "description": "Manage what enters and stays in the context window — pruning, compaction, summary fidelity, ordering — so the agent stays coherent on long runs without inflating cost. Use when the user is hitting context limits, running long agentic loops, paying for full-history replays, or asks \"how do I keep context manageable?\" / \"the agent forgets things after N turns\".",
      "tags": [
        "context-engineering",
        "cost",
        "latency",
        "architecture"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": false,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    },
    {
      "name": "guardrails-and-safety",
      "path": "skills/guardrails-and-safety",
      "description": "Design guardrails for an LLM agent that handles user input, calls real tools, or operates in a regulated domain. Use when the user is building a user-facing agent and mentions guardrails, jailbreaks, prompt injection, content moderation, PII redaction, output validation, red-teaming, safety filters, or asks \"how do I keep this agent from doing X?\" / \"how do I make this production-safe?\".",
      "tags": [
        "safety",
        "guardrails",
        "red-teaming",
        "production"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": false,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    },
    {
      "name": "human-in-the-loop",
      "path": "skills/human-in-the-loop",
      "description": "Design where, when, and how a human gates, reviews, or rescues an LLM agent — without turning the agent into a button labelled \"approve\". Use when the user is building an agent that takes irreversible actions or operates in regulated workflows and mentions human-in-the-loop, HITL, approval gate, escalation, review queue, oversight, or asks \"when should a human approve this?\" / \"how do I add review without killing the agent's speed?\".",
      "tags": [
        "safety",
        "oversight",
        "production",
        "workflow"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": false,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    },
    {
      "name": "latency-budgeting",
      "path": "skills/latency-budgeting",
      "description": "Budget and engineer latency for an LLM agent — TTFT, tokens-per-second, tool round-trips, parallelism, streaming. Use when the user is building a user-facing or real-time agent and mentions latency, p50, p95, p99, TTFT, streaming, throughput, time-to-first-token, slow agent, or asks \"why is my agent slow?\" / \"how do I hit a 2-second latency target?\".",
      "tags": [
        "latency",
        "production",
        "performance",
        "user-experience"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": false,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    },
    {
      "name": "llm-as-judge",
      "path": "skills/llm-as-judge",
      "description": "Design and validate LLM-as-judge scoring — pairwise vs pointwise, bias correction, anchor calibration, and the cases where a judge is the wrong tool. Use when the user is building an eval, scoring open-ended outputs, or comparing model versions and mentions LLM-as-judge, model grader, pairwise comparison, position bias, length bias, judge calibration, meta-eval, or asks \"how do I score open-ended responses?\" / \"is my LLM-judge biased?\".",
      "tags": [
        "evaluation",
        "scoring",
        "quality",
        "production"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": false,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    },
    {
      "name": "memory-design",
      "path": "skills/memory-design",
      "description": "Design memory for an LLM agent — what to keep, where to keep it, and when memory hurts more than it helps. Use when the user is adding memory to an agent and mentions short-term memory, long-term memory, episodic, semantic, conversation history, summary memory, vector memory, memory store, mem0, Letta, MemGPT, or asks \"should this agent remember?\" / \"why is the agent recalling the wrong thing?\".",
      "tags": [
        "memory",
        "architecture",
        "context-engineering",
        "production"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": false,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    },
    {
      "name": "model-routing",
      "path": "skills/model-routing",
      "description": "Pick the right model per call, not per project — route Opus/Sonnet/Haiku, GPT-5/4o/mini, Gemini Pro/Flash by task, and cut cost without losing quality. Use when the user is choosing model tiers, building a router, or debating Opus-only vs mixed-tier deployments and mentions model selection, model router, cascade, fallback, cheap-first, draft-then-verify, or asks \"which model should I use?\" / \"do I need Opus for this?\".",
      "tags": [
        "cost",
        "latency",
        "architecture",
        "model-selection"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": false,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    },
    {
      "name": "multi-agent-orchestration",
      "path": "skills/multi-agent-orchestration",
      "description": "Decide when to split work across multiple agents vs one agent with tools, and design the handoffs when you do. Use when the user is sketching a multi-agent system or debugging one, and mentions handoff, delegation, supervisor, swarm, crew, sub-agent, agent-to-agent, A2A, manager-worker, team of agents, or asks \"should I split this into multiple agents?\" / \"why do my agents talk forever and never finish?\".",
      "tags": [
        "multi-agent",
        "orchestration",
        "architecture",
        "handoff"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": false,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    },
    {
      "name": "prompt-caching",
      "path": "skills/prompt-caching",
      "description": "Use prompt caching correctly across Anthropic, OpenAI, Bedrock, and Gemini to cut cost and latency on hot paths. Use when the user is building a production LLM app and mentions prompt caching, cache hits, cache key, cache TTL, ephemeral cache, system-prompt caching, or asks \"why is my cache hit rate low?\" / \"should I cache this?\".",
      "tags": [
        "caching",
        "cost",
        "latency",
        "production",
        "claude"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": false,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    },
    {
      "name": "prompt-injection-defense",
      "path": "skills/prompt-injection-defense",
      "description": "Defend an LLM agent against prompt injection — direct, indirect, tool-result, and document-borne. Use when the user is building an agent that reads untrusted content (web pages, emails, documents, tool outputs) or exposes user-provided text to a downstream agent, and mentions prompt injection, indirect injection, jailbreak via document, tool-result injection, untrusted input, instruction override, or asks \"how do I stop the agent from following injected instructions?\" / \"is RAG safe from injection?\".",
      "tags": [
        "security",
        "injection",
        "safety",
        "production"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": false,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    },
    {
      "name": "rag-vs-context-engineering",
      "path": "skills/rag-vs-context-engineering",
      "description": "Decide between RAG, long-context, structured tool retrieval, and prompt-only approaches for grounding an LLM in private or fresh data. Use when the user is designing a knowledge-grounded agent or chatbot and mentions RAG, vector search, embeddings, retrieval, chunking, long context, context window, tool retrieval, hybrid search, rerank, or asks \"do I need RAG?\" / \"should I just use a big context window?\".",
      "tags": [
        "rag",
        "retrieval",
        "context-engineering",
        "architecture"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": false,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    },
    {
      "name": "structured-output-reliability",
      "path": "skills/structured-output-reliability",
      "description": "Get reliable structured output (JSON, typed objects) out of an LLM without regex repair, retry loops, or silent corruption. Use when the user is parsing model output, fighting malformed JSON, comparing JSON mode vs function calling vs structured outputs, or asks \"why does the model keep breaking my schema?\" / \"how do I force valid JSON?\".",
      "tags": [
        "structured-output",
        "reliability",
        "tool-use",
        "production"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": false,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    },
    {
      "name": "tool-failure-handling",
      "path": "skills/tool-failure-handling",
      "description": "Design retry, idempotency, timeout, and recovery behaviour for an agent's tool calls — not the schema (that's a separate skill), but the runtime semantics. Use when the user is building or debugging an agent's tool loop and mentions retries, idempotency keys, timeouts, exponential backoff, compensation, partial failure, tool unavailable, 429, 503, flaky tool, or asks \"how should the agent retry?\" / \"the tool failed mid-call, now what?\".",
      "tags": [
        "tool-use",
        "reliability",
        "production",
        "error-handling"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": false,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    },
    {
      "name": "tool-use-schema-design",
      "path": "skills/tool-use-schema-design",
      "description": "Design tool schemas (function-calling definitions) that LLMs can use reliably. Use when the user is defining tools for Claude, GPT, Gemini, or any function-calling agent and mentions tool definitions, function calling, JSON schema, tool descriptions, parameters, structured outputs, MCP tools, or asks \"why is the model calling my tool wrong?\" / \"how should I design this tool?\".",
      "tags": [
        "tool-use",
        "function-calling",
        "mcp",
        "architecture"
      ],
      "has_examples": true,
      "has_transcript": true,
      "has_references": false,
      "agent_compat": {
        "claude-code": "native",
        "gemini-cli": "loadable",
        "cursor": "convertible",
        "codex": "loadable"
      }
    }
  ]
}