AI-Native Development

Overview

AI-Native Development focuses on building applications where AI is a first-class citizen, not an afterthought. This skill provides comprehensive patterns for integrating LLMs, implementing RAG (Retrieval-Augmented Generation), using vector databases, building agentic workflows, and optimizing AI application performance and cost.

When to use this skill:

• Building chatbots, Q&A systems, or conversational interfaces
• Implementing semantic search or recommendation engines
• Creating AI agents that can use tools and take actions
• Integrating LLMs (OpenAI, Anthropic, open-source models) into applications
• Building RAG systems for knowledge retrieval
• Optimizing AI costs and latency
• Implementing AI observability and monitoring

Why AI-Native Development Matters

Traditional software is deterministic; AI-native applications are probabilistic:

• Context is Everything: LLMs need relevant context to provide accurate answers
• RAG Over Fine-Tuning: Retrieval is cheaper and more flexible than fine-tuning
• Embeddings Enable Semantic Search: Move beyond keyword matching to understanding meaning
• Agentic Workflows: LLMs can reason, plan, and use tools autonomously
• Cost Management: Token usage directly impacts operational costs
• Observability: Debugging probabilistic systems requires new approaches
• Prompt Engineering: How you ask matters as much as what you ask

Core Concepts

1. Embeddings & Vector Search

Embeddings are vector representations of text that capture semantic meaning. Similar concepts have similar vectors.

Key Capabilities:

• Convert text to high-dimensional vectors (1536 or 3072 dimensions)
• Measure semantic similarity using cosine similarity
• Find relevant documents through vector search
• Batch process for efficiency

Detailed Implementation: See references/vector-databases.md for:

• OpenAI embeddings setup and batch processing
• Cosine similarity algorithms
• Chunking strategies (500-1000 tokens with 10-20% overlap)

2. Vector Databases

Store and retrieve embeddings efficiently at scale.

Popular Options:

• Pinecone: Serverless, managed service ($0.096/hour)
• Chroma: Open source, self-hosted
• Weaviate: Flexible schema, hybrid search
• Qdrant: Rust-based, high performance

Detailed Implementation: See references/vector-databases.md for:

• Complete setup guides for each database
• Upsert, query, update, delete operations
• Metadata filtering and hybrid search
• Cost comparison and best practices

3. RAG (Retrieval-Augmented Generation)

RAG combines retrieval systems with LLMs to provide accurate, grounded answers.

Core Pattern:

1. Retrieve relevant documents from vector database
2. Construct context from top results
3. Generate answer with LLM using retrieved context

Advanced Patterns:

• RAG with citations and source tracking
• Hybrid search (semantic + keyword)
• Multi-query RAG for better recall
• HyDE (Hypothetical Document Embeddings)
• Contextual compression for relevance

Detailed Implementation: See references/rag-patterns.md for:

• Basic and advanced RAG patterns with full code
• Citation strategies
• Hybrid search with Reciprocal Rank Fusion
• Conversation memory patterns
• Error handling and validation

4. Function Calling & Tool Use

Enable LLMs to use external tools and APIs reliably.

Capabilities:

• Define tools with JSON schemas
• Execute functions based on LLM decisions
• Handle parallel tool calls
• Stream responses with tool use

Detailed Implementation: See references/function-calling.md for:

• Tool definition patterns (OpenAI and Anthropic)
• Function calling loops
• Parallel and streaming tool execution
• Input validation with Zod
• Error handling and fallback strategies

5. Agentic Workflows

Enable LLMs to reason, plan, and take autonomous actions.

Patterns:

• ReAct: Reasoning + Acting loop with observations
• Tree of Thoughts: Explore multiple reasoning paths
• Multi-Agent: Specialized agents collaborating on complex tasks
• Autonomous Agents: Self-directed goal achievement

Detailed Implementation: See references/agentic-workflows.md for:

• Complete ReAct loop implementation
• Tree of Thoughts exploration
• Multi-agent coordinator patterns
• Agent memory management
• Error recovery and safety guards

5.1 Multi-Agent Orchestration (Opus 4.5)

Advanced multi-agent patterns leveraging Opus 4.5's extended thinking capabilities.

When to Use Extended Thinking:

• Coordinating 3+ specialized agents
• Complex dependency resolution between agent outputs
• Dynamic task allocation based on agent capabilities
• Conflict resolution when agents produce contradictory results

Orchestrator Pattern:

interface AgentTask {
  id: string;
  type: 'research' | 'code' | 'review' | 'design';
  input: unknown;
  dependencies: string[]; // Task IDs that must complete first
}

interface AgentResult {
  taskId: string;
  output: unknown;
  confidence: number;
  reasoning: string;
}

async function orchestrateAgents(
  goal: string,
  availableAgents: Agent[]
): Promise<AgentResult[]> {
  // Step 1: Use extended thinking to decompose goal into tasks
  const taskPlan = await planTasks(goal, availableAgents);

  // Step 2: Build dependency graph
  const dependencyGraph = buildDependencyGraph(taskPlan.tasks);

  // Step 3: Execute tasks respecting dependencies
  const results: AgentResult[] = [];
  const completed = new Set<string>();

  while (completed.size < taskPlan.tasks.length) {
    // Find tasks with satisfied dependencies
    const ready = taskPlan.tasks.filter(task =>
      !completed.has(task.id) &&
      task.dependencies.every(dep => completed.has(dep))
    );

    // Execute ready tasks in parallel
    const batchResults = await Promise.all(
      ready.map(task => executeAgentTask(task, availableAgents))
    );

    // Validate results - use extended thinking for conflicts
    const validatedResults = await validateAndResolveConflicts(
      batchResults,
      results
    );

    results.push(...validatedResults);
    ready.forEach(task => completed.add(task.id));
  }

  return results;
}

Task Planning with Extended Thinking:

Based on Anthropic's Extended Thinking documentation:

import Anthropic from '@anthropic-ai/sdk';

const anthropic = new Anthropic();

async function planTasks(
  goal: string,
  agents: Agent[]
): Promise<{ tasks: AgentTask[]; rationale: string }> {
  // Extended thinking requires budget_tokens < max_tokens
  // Minimum budget: 1,024 tokens
  const response = await anthropic.messages.create({
    model: 'claude-opus-4-5-20251101', // Or claude-sonnet-4-5-20250929
    max_tokens: 16000,
    thinking: {
      type: 'enabled',
      budget_tokens: 10000 // Extended thinking for complex planning
    },
    messages: [{
      role: 'user',
      content: `
        Goal: ${goal}

        Available agents and their capabilities:
        ${agents.map(a => `- ${a.name}: ${a.capabilities.join(', ')}`).join('\n')}

        Decompose this goal into tasks. For each task, specify:
        1. Which agent should handle it
        2. What input it needs
        3. Which other tasks it depends on
        4. Expected output format

        Think carefully about:
        - Optimal parallelization opportunities
        - Potential conflicts between agent outputs
        - Information that needs to flow between tasks
      `
    }]
  });

  // Response contains thinking blocks followed by text blocks
  // content: [{ type: 'thinking', thinking: '...' }, { type: 'text', text: '...' }]
  return parseTaskPlan(response);
}

Conflict Resolution:

async function validateAndResolveConflicts(
  newResults: AgentResult[],
  existingResults: AgentResult[]
): Promise<AgentResult[]> {
  // Che