Use when implementation is complete, all tests pass, and you need to decide how to integrate the work.

Use when receiving code review feedback, before implementing suggestions. Requires technical rigor and verification, not blind implementation.

Use when completing tasks, implementing major features, or before merging to verify work meets requirements.

Use when executing implementation plans with independent tasks in the current session. Dispatches fresh subagent per task.

Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes. Requires root cause investigation first.

Use when implementing any feature or bugfix, before writing implementation code. Enforces RED-GREEN-REFACTOR cycle.

Use when starting any conversation. Establishes how to find and use skills, requiring skill invocation before any response.

Use when you have a spec or requirements for a multi-step task, before touching code. Creates bite-sized TDD implementation plans with dependency tracking.

Chain-of-thought and step-by-step reasoning prompts for complex problem solving

Constitutional AI and safety guardrail prompts for aligned LLM behavior

Content moderation API integration using OpenAI Moderation, Perspective API, and others

CrewAI multi-agent orchestration setup for collaborative AI systems

Entity and fact extraction for user profiling and personalization

Few-shot example generation and optimization for improved LLM performance

Guardrails AI validation framework setup for LLM applications. Implement input/output validation, safety checks, and structured output enforcement.

LangChain memory integration including ConversationBufferMemory, ConversationSummaryMemory, and vector-based memory

LangChain retriever implementation with various retrieval strategies for RAG applications

LangGraph checkpoint and persistence configuration for stateful workflow management

LangSmith tracing and debugging setup for LLM applications. Configure observability, capture traces, and enable debugging for LangChain/LangGraph agents.

LlamaIndex agent and query engine setup for RAG-powered agents

Mem0 memory layer integration for AI agents. Implement persistent, semantic memory for long-term context retention and personalization.

Conversation summarization for memory compression and context management

OpenTelemetry instrumentation for LLM applications with distributed tracing

Arize Phoenix observability platform setup for LLM debugging and evaluation

PII detection and redaction utilities for privacy-compliant conversational AI

Structured prompt template creation with variables, formatting, and version control

Batch embedding generation with caching, rate limiting, and multiple provider support

Hybrid search combining semantic and keyword retrieval for RAG pipelines. Implement BM25 + dense vector search with fusion strategies.

Query expansion, HyDE, and multi-query generation for improved retrieval

Cross-encoder reranking and MMR diversity filtering for improved retrieval quality

Rasa NLU pipeline configuration and training for intent and entity extraction

Redis backend for conversation state persistence and caching

Microsoft Semantic Kernel planner and plugin setup for orchestrated AI

Zep memory server integration for long-term conversation memory and user profiling

Generate visual representations of algorithm execution

Profile code performance and identify bottlenecks

Manage and generate competitive programming templates

Interface with Codeforces API for contest data, problem sets, and submissions

Automated Big-O complexity analysis of code and algorithms. Performs static analysis of loop structures, recursive call trees, space complexity estimation, and amortized analysis with detailed derivation documents.

Apply advanced DP optimizations automatically

Implement computational geometry algorithms

Provide robust computational geometry primitives

Select optimal graph algorithm based on problem constraints

Curated bank of interview problems organized by company, pattern, and difficulty. Provides problem recommendations, coverage tracking, weak area identification, and premium problem alternatives for FAANG interview preparation.

Identify and verify loop invariants for correctness proofs

Fetch and parse LeetCode problems with metadata, constraints, examples, hints, difficulty ratings, and related problems. Integrates with LeetCode API for comprehensive problem data retrieval.

Apply language-specific micro-optimizations

Generate optimized prime sieves and factorization routines

Assist in constructing algorithm correctness proofs

Generate customized segment tree implementations