# AgentsCamp

> A curated hub for everything AI — agents, skills, guides, tools, and commands for building with AI coding agents.

Everything here is copy-paste/installable and format-validated for use with AI coding agents (Claude Code). Each page below has a clean Markdown twin at the same URL with a `.md` suffix.

## Agents

Drop-in Claude Code subagents with focused system prompts — code review, debugging, architecture, and more.

- [API Architect](https://agentscamp.com/agents/core-development/api-architect.md): Use this agent to design APIs — resource modeling, versioning, pagination, error contracts, REST vs GraphQL. Examples — designing a public API, reviewing an API spec, planning a breaking change.
- [Backend Developer](https://agentscamp.com/agents/core-development/backend-developer.md): Use this agent to build server-side features — endpoints, business logic, data access, background jobs. Examples — a new REST/GraphQL endpoint, a queue worker, a database integration.
- [Database Architect](https://agentscamp.com/agents/core-development/database-architect.md): Use this agent to design data models and storage strategy from access patterns — schema design, normalization vs deliberate denormalization, relational vs document vs key-value vs wide-column vs graph selection, indexing, partitioning/sharding, transaction boundaries, and consistency models. Examples — modeling a new feature's schema, choosing a database for a write-heavy event workload, reviewing a schema for missing indexes or scaling cliffs, planning how to shard a table that no longer fits one node.
- [Frontend Developer](https://agentscamp.com/agents/core-development/frontend-developer.md): Use this agent to build UI — responsive layouts, components, accessibility, and design-system work. Examples — implementing a Figma design, fixing a11y issues, building a reusable component.
- [GraphQL Architect](https://agentscamp.com/agents/core-development/graphql-architect.md): Use this agent to design GraphQL schemas and resolvers — types, nullability, connections, dataloaders, federation, depth/complexity limits. Examples — designing a new schema from requirements, killing N+1 queries in resolvers, planning a deprecation, hardening a public graph.
- [Mobile Developer](https://agentscamp.com/agents/core-development/mobile-developer.md): Use this agent to build cross-platform mobile apps with React Native + Expo — screens, navigation, native modules, and shipping via EAS. Examples — adding a tab-based navigation flow, fixing a janky FlatList, shipping a build to TestFlight with EAS.
- [System Architect](https://agentscamp.com/agents/core-development/system-architect.md): Use this agent for high-level system design — service boundaries, data flow, scaling, trade-offs. Examples — designing a new system, evaluating a monolith-to-services split, a scalability review.
- [Agent Tool Integration Engineer](https://agentscamp.com/agents/data-ai/agent-tool-integration-engineer.md): Use this agent to wire tools and function-calling into an agent loop reliably — clean tool schemas, errors fed back as observations, retries with limits, idempotency, and parallel calls. Examples — "connect our APIs as agent tools", "our agent calls tools wrong / ignores tool errors", "add function-calling with proper error recovery to our agent".
- [Browser Agent Engineer](https://agentscamp.com/agents/data-ai/browser-agent-engineer.md): Use this agent to build, harden, or debug browser-automation agents — web tasks via Browser Use, Stagehand, Skyvern, or Playwright-based stacks. Examples: automate a portal workflow, make a flaky browser agent reliable, add verification and guardrails to web automation, choose between vision and DOM grounding.
- [Data Engineer](https://agentscamp.com/agents/data-ai/data-engineer.md): Use this agent to build and maintain data pipelines — ingestion, ELT/ETL, warehouse modeling, orchestration, and data-quality tests. Examples — building an idempotent ingestion job, modeling a fact/dimension table in dbt, writing a safe backfill for a changed schema.
- [Data Scientist](https://agentscamp.com/agents/data-ai/data-scientist.md): Use this agent for data analysis — exploration, statistics, SQL, and clear findings. Examples — analyzing a dataset, writing an analytical SQL query, summarizing experiment results.
- [Finetuning Engineer](https://agentscamp.com/agents/data-ai/finetuning-engineer.md): Use this agent to fine-tune an open-weight model end to end — confirming fine-tuning is the right tool, preparing the dataset, choosing the method (LoRA/QLoRA vs. full), running training, and proving the result beats the prompted baseline on a held-out eval set. Examples — "fine-tune a small model to match our support tone and answer format", "we have 800 labeled examples — LoRA-tune and show it beats prompting", "our fine-tune overfits and forgot general ability — fix the data and run".
- [LLM Cost Optimizer](https://agentscamp.com/agents/data-ai/llm-cost-optimizer.md): Use this agent to cut the cost and latency of an application's LLM API usage without losing quality — audit where the tokens and dollars go, then apply caching, model right-sizing, prompt trimming, batching, and budgets, proven against an eval bar. Examples — "our OpenAI bill tripled, find where the spend is and cut it", "this endpoint's p95 is 8s, bring it down", "right-size models per task and add prompt caching to our chat feature".
- [LLM Evaluation Engineer](https://agentscamp.com/agents/data-ai/llm-evaluation-engineer.md): Use this agent to make an LLM feature's quality measurable — building the dataset, choosing metrics, setting a baseline, and turning evals into a CI gate so prompt and model changes are scored, not guessed. Examples — "we changed the prompt and don't know if it's better, set up evals", "add a regression gate for our extraction feature", "our RAG quality is drifting, build an eval suite".
- [LLM Inference Engineer](https://agentscamp.com/agents/data-ai/llm-inference-engineer.md): Use this agent to serve and optimize self-hosted LLM inference — sizing GPUs, configuring a serving engine like vLLM (continuous batching, PagedAttention, tensor parallelism), applying quantization, and tuning throughput and tail latency against a cost and p95 budget. Examples — "serve Llama-3-70B at p95 under 2s on our GPUs", "our self-hosted model is slow and the GPUs sit half-idle — raise throughput", "quantize this model to fit one GPU without wrecking quality".
- [LLM Integration Engineer](https://agentscamp.com/agents/data-ai/llm-integration-engineer.md): Use this agent to add an LLM feature to an application and make it production-grade — typed/structured output, streaming, provider fallback and retries, caching, and cost/latency controls. Examples — "add an AI summary endpoint to our app", "our LLM calls return unparseable JSON and break, make them reliable", "add streaming and a fallback provider to our chat feature".
- [LLM Observability Engineer](https://agentscamp.com/agents/data-ai/llm-observability-engineer.md): Use this agent to make a production LLM app observable — tracing every step, scoring live traffic with online evals, and monitoring quality, cost, and latency — so you can debug agent runs and catch regressions in production. Examples — "add tracing to our RAG/agent so we can debug bad answers", "set up online evals and cost/latency dashboards", "production quality is slipping and we're flying blind".
- [ML Engineer](https://agentscamp.com/agents/data-ai/ml-engineer.md): Use this agent for production ML — pipelines, training, serving, evaluation, and MLOps. Examples — building a training pipeline, deploying a model, setting up evaluation.
- [Postgres Migration Engineer](https://agentscamp.com/agents/data-ai/postgres-migration-engineer.md): Use this agent to plan and execute a zero-downtime Postgres schema migration — decomposing a breaking change into expand-contract steps, writing batched backfills, building indexes CONCURRENTLY, validating constraints online, and keeping every step reversible with the project's migration tooling. Examples — "add a NOT NULL column to a 200M-row table without downtime", "rename a column safely across a rolling deploy", "split this risky migration into reversible expand/contract steps".
- [Prompt Engineer](https://agentscamp.com/agents/data-ai/prompt-engineer.md): Use this agent to design and iterate the prompts behind an LLM-powered product feature — instructions, few-shot examples, tool schemas, and the evals that prove a change actually helped. Examples — "this classification prompt is flaky, make it reliable", "design the system prompt and function schema for our support agent", "our extraction prompt regressed after I tweaked it, set up evals so this stops happening".
- [Rag Pipeline Engineer](https://agentscamp.com/agents/data-ai/rag-pipeline-engineer.md): Use this agent to design, build, and harden a production retrieval-augmented generation (RAG) pipeline end to end — ingestion, chunking, embeddings, indexing, retrieval, reranking, and grounded generation — with evals that prove each stage works. Examples — "stand up RAG over our docs", "our RAG hallucinates and misses obvious answers, fix the pipeline", "take our prototype RAG to production with evals and citations".
- [Retrieval Engineer](https://agentscamp.com/agents/data-ai/retrieval-engineer.md): Use this agent to raise the retrieval quality of a search or RAG system — recall and precision, hybrid (dense + sparse) search, reranking, query transformation, and metadata filtering — measured against a labeled eval set. Examples — "our RAG retrieves irrelevant chunks, fix recall", "add hybrid search and reranking and prove it helps", "queries with acronyms/IDs return nothing, fix it".
- [Vector Search Engineer](https://agentscamp.com/agents/data-ai/vector-search-engineer.md): Use this agent to design, build, and tune the vector-database layer of a search or RAG system — schema and index design (HNSW/IVF + quantization), metadata/payload filtering, hybrid (dense + sparse) search, and ingestion/upsert pipelines — sized to a real latency, recall, and cost budget. Examples — "set up pgvector for our docs with HNSW and filtered search", "our Qdrant queries are slow and recall dropped after quantization", "add metadata filtering so search only returns the current tenant's documents".
- [Voice Agent Engineer](https://agentscamp.com/agents/data-ai/voice-agent-engineer.md): Use this agent to build or fix a real-time voice agent — the streaming STT → LLM → TTS pipeline, conversational (mouth-to-ear) latency, turn-taking, barge-in/interruptions, and per-stage provider selection. Examples — "our voice bot feels laggy and talks over people, fix the turn-taking and latency", "build a phone agent that transcribes, answers with our LLM, and speaks back", "get our voice agent's response time under a second".
- [CLI Tooling Engineer](https://agentscamp.com/agents/developer-tools/cli-tooling-engineer.md): Use this agent to design or build a command-line tool — subcommand and flag layout, --help and error UX, exit codes, --json/machine output, config precedence, stdin/stdout/stderr and pipe behavior, TTY/color/NO_COLOR detection, and CLI testing. Examples — "design the command and flag surface for our new deploy CLI", "this tool prints errors to stdout and returns 0 on failure — fix its ergonomics", "make our command pipe-friendly and add a --json mode for CI".
- [Dependency Manager](https://agentscamp.com/agents/developer-tools/dependency-manager.md): Use this agent to upgrade project dependencies safely — batching low-risk bumps apart from breaking majors and verifying each step. Examples — clearing months of stale packages, taking a single major version with migration notes, resolving a peer-dependency conflict.
- [Documentation Engineer](https://agentscamp.com/agents/developer-tools/documentation-engineer.md): Use this agent to write and maintain technical docs that stay true to the code — READMEs, how-to guides, API references, and runbooks. Examples — updating a stale README after a refactor, documenting a new public API from its signatures, writing an on-call runbook for a service.
- [Git Github Expert](https://agentscamp.com/agents/developer-tools/git-github-expert.md): Use this agent for Git and GitHub workflows — rebases, conflict resolution, history surgery, PRs, and Actions. Examples — resolving a messy merge, rewriting history safely, fixing a workflow file.
- [MCP Server Engineer](https://agentscamp.com/agents/developer-tools/mcp-server-engineer.md): Use this agent to build, harden, or productionize a Model Context Protocol (MCP) server — designing tools/resources/prompts, choosing stdio vs. Streamable HTTP, taking a server remote with OAuth and stateless scaling, and testing it with the MCP Inspector. Examples — "wrap our internal API as an MCP server with three tools", "take our stdio server remote so the team can share it", "our tools confuse the model — fix the names, schemas, and descriptions".
- [Refactoring Specialist](https://agentscamp.com/agents/developer-tools/refactoring-specialist.md): Use this agent to safely restructure code without changing behavior — extracting, renaming, decoupling. Examples — breaking up a god object, removing duplication, improving testability.
- [CI/CD Engineer](https://agentscamp.com/agents/infrastructure-devops/ci-cd-engineer.md): Use this agent to design, speed up, and harden CI/CD pipelines on any provider (GitHub Actions, GitLab CI, CircleCI, Buildkite). Examples — setting up a build→test→deploy pipeline from scratch, cutting a 25-minute CI run down with caching and matrix parallelism, adding a canary or blue-green deploy with automatic rollback, or reviewing a workflow for leaked secrets, over-broad tokens, and unpinned third-party actions.
- [Cloud Architect](https://agentscamp.com/agents/infrastructure-devops/cloud-architect.md): Use this agent to design a cloud architecture on AWS, GCP, or Azure — compute, networking, data stores, IAM, and cost trade-offs. Examples — choosing serverless vs containers for a new service, designing a multi-account network boundary, picking a database and estimating its monthly cost.
- [DevOps Engineer](https://agentscamp.com/agents/infrastructure-devops/devops-engineer.md): Use this agent for CI/CD, infrastructure, and automation. Examples — writing a CI pipeline, containerizing an app, infrastructure-as-code changes.
- [Incident Responder](https://agentscamp.com/agents/infrastructure-devops/incident-responder.md): Use this agent during a live production incident to restore service fast and learn from it — triage and severity, mitigation-first action (roll back, fail over, shed load), change correlation, status updates, and the blameless postmortem. Examples — an alert just fired and the API is 5xx-ing, a deploy broke checkout and you need to decide rollback vs. forward-fix, latency is climbing and the pager is going off, or you're writing the postmortem the morning after.
- [Kubernetes Specialist](https://agentscamp.com/agents/infrastructure-devops/kubernetes-specialist.md): Use this agent for Kubernetes — manifests, Helm, troubleshooting, scaling, and resource tuning. Examples — debugging a CrashLoopBackOff, writing a Deployment, tuning requests/limits.
- [SRE Engineer](https://agentscamp.com/agents/infrastructure-devops/sre-engineer.md): Use this agent to make reliability measurable: SLIs/SLOs and error budgets, observability, symptom-based alerting, incident response, and capacity. Examples — defining an SLO for a checkout API, fixing a noisy pager, writing a blameless postmortem.
- [Terraform Specialist](https://agentscamp.com/agents/infrastructure-devops/terraform-specialist.md): Use this agent for Terraform and infrastructure-as-code — module design, remote state, plan/apply safety, drift, and provider pinning. Examples — reviewing a plan for destroys before apply, designing a reusable module, resolving state drift after a console change.
- [C# Pro](https://agentscamp.com/agents/language-specialists/csharp-pro.md): Use this agent for modern C#/.NET 8+ — records, pattern matching, nullable reference types, correct async/await, LINQ, Span<T>, and source generators — plus ASP.NET Core and EF Core. Examples — building a minimal-API service, fixing an EF Core N+1 or tracking leak, hunting a deadlock from sync-over-async, or turning on nullable reference types across a project.
- [Golang Pro](https://agentscamp.com/agents/language-specialists/golang-pro.md): Use this agent for idiomatic Go — concurrency, errors, small interfaces, stdlib-first design, and profiling. Examples — fixing a goroutine leak, designing a context-aware API, profiling a hot path with pprof.
- [Java Pro](https://agentscamp.com/agents/language-specialists/java-pro.md): Use this agent for idiomatic, modern Java (17/21+) — records, sealed types, pattern matching, virtual threads and structured concurrency, the Streams API, and JVM/GC performance. Examples — modernizing a legacy POJO-and-thread-pool service to records and virtual threads, diagnosing a GC pause or allocation hotspot, reviewing concurrency correctness, or fixing a Spring Boot service that blocks the wrong threads.
- [Kotlin Pro](https://agentscamp.com/agents/language-specialists/kotlin-pro.md): Use this agent for idiomatic Kotlin — null safety, coroutines and structured concurrency, Flow, sealed classes with exhaustive when, data classes, and extension functions — on Android and the JVM. Examples — fixing a coroutine leak, replacing callbacks with Flow, removing !! null-safety holes.
- [Php Pro](https://agentscamp.com/agents/language-specialists/php-pro.md): Use this agent for idiomatic, modern PHP 8.3+ — strict types, enums, readonly and promoted properties, Composer/PSR-4 autoloading, and safe PDO data access. Examples — modernizing a PHP 5-era class, killing an ORM N+1, hardening a query against SQL injection.
- [Python Pro](https://agentscamp.com/agents/language-specialists/python-pro.md): Use this agent for idiomatic, performant Python — typing, async, packaging, and stdlib mastery. Examples — refactoring to idiomatic Python, async I/O, packaging a library.
- [React Specialist](https://agentscamp.com/agents/language-specialists/react-specialist.md): Use this agent for React architecture — hooks, state, performance, Server Components, and patterns. Examples — fixing re-render issues, designing component state, adopting RSC.
- [Rust Pro](https://agentscamp.com/agents/language-specialists/rust-pro.md): Use this agent for idiomatic Rust — ownership, lifetimes, error handling, traits, async with tokio, and the cargo toolchain. Examples — fixing borrow-checker errors, designing a trait API, making async code compile cleanly under tokio.
- [SQL Pro](https://agentscamp.com/agents/language-specialists/sql-pro.md): Use this agent for SQL itself — correct joins and window functions, indexing, EXPLAIN plans, schema design, and safe migrations on Postgres/MySQL. Examples — making a slow query fast, designing a normalized schema, writing a reversible migration.
- [Swift Pro](https://agentscamp.com/agents/language-specialists/swift-pro.md): Use this agent for modern Swift 6 — value semantics, optionals done right, async/await and actors, Sendable/data-race safety, and idiomatic SwiftUI. Examples — fixing a data race under strict concurrency, untangling force-unwrap crashes, making a SwiftUI list scroll smoothly.
- [Typescript Pro](https://agentscamp.com/agents/language-specialists/typescript-pro.md): Use this agent for advanced TypeScript — generics, type-level programming, strictness, and inference. Examples — typing a tricky API, fixing type errors, designing a type-safe library surface.
- [Agent Architect](https://agentscamp.com/agents/meta-orchestration/agent-architect.md): Use this agent to design a new Claude Code subagent or review an existing one — scoping, description, toolset, model, and output contract. Examples — "design an agent that triages flaky tests", "review my code-reviewer agent for scope creep", "why won't Claude auto-delegate to my agent?".
- [Agent Reliability Reviewer](https://agentscamp.com/agents/meta-orchestration/agent-reliability-reviewer.md): Use this agent to make an AI agent production-ready — reviewing its loops, cost controls, error handling, tool use, human-in-the-loop gates, checkpointing, and observability, then reporting concrete failure modes and fixes. Examples — "is our agent safe to ship?", "our agent loops forever / burns tokens, harden it", "add guardrails and recovery before we put this agent in front of users".
- [Context Engineer](https://agentscamp.com/agents/meta-orchestration/context-engineer.md): Use this agent to engineer what an LLM agent carries in its context window — deciding what to include vs exclude vs retrieve on demand, designing project/agent memory (CLAUDE.md), compacting growing history, and allocating the token budget across system prompt, memory, retrieved docs, tool results, and conversation. Examples — "my agent forgets the schema we agreed on three turns ago", "the agent gets dumber and more inconsistent as the chat grows", "we're burning 60k tokens of tool output every turn", "what should this support agent always know vs look up?".
- [Eval Driven Developer](https://agentscamp.com/agents/meta-orchestration/eval-driven-developer.md): Use this agent to drive AI feature development with evals the way TDD drives code with tests — define success criteria and a representative eval set BEFORE iterating on prompts/models, then optimize against measured scores instead of vibes. Examples — "make the summarizer better" (turn it into measurable criteria first), "our prompt change keeps regressing quality, set up a loop that catches it", "add an eval gate to CI so a model swap can't silently degrade output", "we tweak prompts and pray — give us a baseline and a change-by-change scoreboard".
- [Workflow Orchestrator](https://agentscamp.com/agents/meta-orchestration/workflow-orchestrator.md): Use this agent to break large tasks into coordinated multi-step plans and delegate to other agents. Examples — planning a multi-file refactor, orchestrating a migration, decomposing an epic.
- [Accessibility Auditor](https://agentscamp.com/agents/quality-security/accessibility-auditor.md): Use this agent to audit web UI against WCAG 2.2 AA — semantics, keyboard, ARIA, contrast, forms, and motion. Examples — auditing a new component for keyboard traps, checking a form for accessible errors, running a pre-ship a11y pass on a page.
- [Code Reviewer](https://agentscamp.com/agents/quality-security/code-reviewer.md): Use this agent to review code changes for correctness, security, and maintainability before merging. Examples — reviewing a PR diff, auditing a new module, checking a refactor for regressions.
- [Debugger](https://agentscamp.com/agents/quality-security/debugger.md): Use this agent to diagnose failing tests, runtime errors, or unexpected behavior by forming and testing hypotheses. Examples — a stack trace to root-cause, a flaky test, a "works locally but not in CI" bug.
- [Performance Engineer](https://agentscamp.com/agents/quality-security/performance-engineer.md): Use this agent to profile and optimize performance — latency, throughput, memory, bundle size. Examples — a slow endpoint, an N+1 query, a heavy render, a large JS bundle.
- [Prompt Injection Auditor](https://agentscamp.com/agents/quality-security/prompt-injection-auditor.md): Use this agent to audit an LLM app or agent for prompt-injection exposure — mapping where untrusted content enters the model's context (user, RAG, tools, web), assessing the blast radius if an injection succeeds, probing with adversarial inputs, and recommending architectural mitigations. Examples — "audit our RAG agent for indirect prompt injection", "what's the blast radius if our agent gets injected — which tools and credentials are exposed?", "review our LLM app's trust boundaries and tell us what to fix".
- [QA Automation Engineer](https://agentscamp.com/agents/quality-security/qa-automation-engineer.md): Use this agent for end-to-end and UI test automation — building flake-resistant Playwright/Cypress suites, stabilizing flaky browser tests, structuring page objects and fixtures, and reviewing E2E suites. Examples — adding E2E coverage for a checkout or signup flow, killing a test that fails 1-in-5 in CI, choosing a framework and folder structure, replacing sleeps with web-first waits, or auditing a suite that's slow and brittle.
- [Security Auditor](https://agentscamp.com/agents/quality-security/security-auditor.md): Use this agent to find security vulnerabilities — injection, auth flaws, secrets, unsafe deserialization, dependency risks. Examples — auditing an API surface, reviewing auth code, pre-release security pass.
- [Test Engineer](https://agentscamp.com/agents/quality-security/test-engineer.md): Use this agent to write and improve automated tests — unit, integration, and edge cases. Examples — adding coverage to an untested module, writing regression tests for a bug, designing a test plan.

## Skills

Packaged SKILL.md capabilities that extend Claude with on-demand expertise.

- [CORS Configurator](https://agentscamp.com/skills/api/cors-configurator.md): Diagnose and fix a failing cross-origin browser request — read the exact console error, work out whether it's a simple or preflighted request, and set the minimal correct Access-Control-* response headers (including the wildcard-with-credentials trap and the OPTIONS preflight) on the server. Use when the browser blocks a fetch/XHR with a CORS error but the API itself works from curl or Postman.
- [GraphQL Schema Designer](https://agentscamp.com/skills/api/graphql-schema-designer.md): Design a clean, evolvable GraphQL schema (SDL) that won't paint you into a corner — model the graph around domain types and their relationships rather than as RPC-over-GraphQL, set nullability deliberately, standardize lists with Relay connections, plan DataLoader batching for per-parent fields, and evolve by adding + @deprecated instead of versioning. Use when designing a new GraphQL API, reviewing an SDL, or migrating REST endpoints to a graph.
- [Idempotency Designer](https://agentscamp.com/skills/api/idempotency-designer.md): Make unsafe, retryable API operations idempotent so a client retry or a network hiccup can't double-charge, double-create, or double-send — design a client-supplied idempotency key, an atomic store-and-check (unique constraint or conditional write), in-flight conflict handling, and a retention policy. Use when a POST/mutation can be retried (payments, order creation, sends, webhooks), or when duplicate side effects have already shown up in production.
- [LLM Output Schema Generator](https://agentscamp.com/skills/api/llm-output-schema-generator.md): Turn an example of the data you want from an LLM into a precise, validated output schema (Pydantic / Zod / JSON Schema) and wire it into structured-output calls. Use when adding typed LLM output, replacing brittle JSON parsing, or designing an extraction shape.
- [MCP Server Scaffolder](https://agentscamp.com/skills/api/mcp-server-scaffolder.md): Scaffold a new Model Context Protocol (MCP) server from a description — pick the SDK and transport, generate a typed first tool with a strict schema, and wire up MCP Inspector testing and the client-registration command. Use when starting a new MCP server and you want a correct, runnable skeleton instead of copying a README.
- [Pagination Designer](https://agentscamp.com/skills/api/pagination-designer.md): Design correct, scalable pagination (plus the filtering and sorting that ride with it) for a list endpoint — pick cursor (keyset) vs offset and justify it, define an opaque cursor with a unique tiebreaker so no row is skipped or repeated, return a consistent envelope, bound page size, and name the indexes the sort actually needs. Use when adding a list endpoint, when OFFSET pagination crawls on a large table, or when clients see duplicate or missing rows while paging.
- [Provider Fallback Wrapper](https://agentscamp.com/skills/api/provider-fallback-wrapper.md): Wrap LLM calls so a provider outage, rate limit, or timeout degrades gracefully — with multi-provider fallback, bounded retries with backoff, and timeouts. Use when an app depends on a single model/provider and needs production resilience.
- [Rate Limiter Designer](https://agentscamp.com/skills/api/rate-limiter-designer.md): Design and implement API rate limiting that actually holds under load — pick the algorithm (token bucket vs sliding-window-counter vs fixed window) and justify it, choose the limiting key and per-tier limits, use cross-instance atomic storage, and return standard 429 signals. Use when protecting an API from abuse or scrapers, enforcing per-tier quotas, or replacing an in-memory limiter that breaks behind multiple replicas.
- [Tool Definition Generator](https://agentscamp.com/skills/api/tool-definition-generator.md): Generate clean function/tool schemas for an LLM agent from existing code or a spec — accurate JSON Schema, model-facing descriptions, honest required fields, and enums that make invalid calls impossible. Use when wiring functions into an agent's tool-calling loop.
- [Webhook Handler Scaffolder](https://agentscamp.com/skills/api/webhook-handler-scaffolder.md): Scaffold a robust inbound webhook handler that verifies the signature on the raw body first, dedupes on the provider's event id, acknowledges fast, and processes asynchronously — the four things naive handlers get wrong. Use when wiring up events from a third party (Stripe, GitHub, Shopify, Slack, Twilio), when a provider keeps retrying because your endpoint times out or 500s, or when duplicate events are double-charging or double-creating records.
- [Agent Trajectory Evaluator](https://agentscamp.com/skills/data/agent-trajectory-evaluator.md): Evaluate a multi-step AI agent's whole run — tool calls, intermediate steps, and final result — not just final-answer correctness, so you can pinpoint WHERE it went wrong. Use when building or debugging a tool-using or multi-step agent, when final-answer-only evals can't explain failures, or when a prompt/model change quietly makes the agent less efficient or more error-prone even though the answer still looks right.
- [Chunking Strategy Optimizer](https://agentscamp.com/skills/data/chunking-strategy-optimizer.md): Find the chunking strategy and size that maximizes retrieval quality for a specific corpus, by sweeping configurations against a fixed eval set instead of guessing. Use when RAG answers miss obvious content, when standing up a new corpus, or when picking chunk size/overlap.
- [Embedding Set Inspector](https://agentscamp.com/skills/data/embedding-set-inspector.md): Diagnose the health of an embedding set before blaming the retriever — checking normalization, dimensionality, near-duplicates, degenerate vectors, and corpus/query distribution mismatch. Use when retrieval quality is poor, after a re-embed, or before shipping a new index.
- [Finetune Dataset Builder](https://agentscamp.com/skills/data/finetune-dataset-builder.md): Turn raw examples into a training-ready fine-tuning dataset — normalize to the trainer's chat/instruction format, deduplicate (including near-duplicates), strip PII, balance, validate the schema and token lengths, and carve a leak-free eval split. Use when you have raw examples and need a clean, formatted, split dataset before training.
- [Graphrag Scaffolder](https://agentscamp.com/skills/data/graphrag-scaffolder.md): Stand up a GraphRAG experiment the disciplined way: audit whether your failed queries are actually connection-shaped, scope a minimal entity/relationship ontology, build extraction → graph → community-summary indexing on a corpus slice, and measure against vector-RAG baselines before committing. Use when multi-hop or whole-corpus questions keep failing plain RAG.
- [Hallucination Evaluator](https://agentscamp.com/skills/data/hallucination-evaluator.md): Detect and measure ungroundedness in LLM and RAG outputs — claims the source doesn't support — by decomposing answers into atomic claims and checking each for entailment, so you can quantify faithfulness and gate on it instead of eyeballing it. Use when a RAG/LLM feature makes confident wrong claims, before shipping anything that must be factual, or to add a groundedness gate to evals/CI.
- [LLM As Judge Scorer](https://agentscamp.com/skills/data/llm-as-judge-scorer.md): Design a reliable LLM-as-judge metric — a calibrated rubric, a clear scoring scale, and bias controls — and validate it against human labels before trusting it. Use when grading open-ended LLM output (summaries, answers, tone) that exact-match can't score.
- [LLM Eval Suite Scaffolder](https://agentscamp.com/skills/data/llm-eval-suite-scaffolder.md): Stand up an evaluation suite for an LLM feature from scratch — a representative dataset, the right metrics, a baseline score, and a CI gate — using DeepEval, promptfoo, or RAGAS. Use when a feature has no evals, before tuning a prompt, or when adding an LLM feature to CI.
- [Model Router Designer](https://agentscamp.com/skills/data/model-router-designer.md): Design a model router that sends each LLM request to the cheapest model that can handle it and escalates only the hard cases to the strongest — cutting cost and latency without tanking quality, gated by an eval set so the savings don't come from silently worse answers. Use when one expensive model serves all traffic (most of it easy), when LLM cost or latency is too high, or when balancing quality against spend across a range of request difficulty.
- [Multimodal Document Extractor](https://agentscamp.com/skills/data/multimodal-document-extractor.md): Extract structured data from documents and images with a vision-language model — define the target schema, prompt the VLM to fill it from the page (invoices, forms, receipts, statements, IDs), and verify critical fields against the source. Use when you need reliable structured output from messy, varied, or scanned documents that defeat template-based OCR.
- [Prompt Regression Tester](https://agentscamp.com/skills/data/prompt-regression-tester.md): Build a regression test harness for an LLM prompt so a prompt edit or model upgrade can't silently degrade quality — a fixed eval set, checkable assertions, and a diff against a committed baseline. Use when changing a production prompt, migrating model versions, or any time 'I tweaked the prompt' needs to be backed by evidence instead of eyeballing two outputs.
- [Qlora Finetune Runner](https://agentscamp.com/skills/data/qlora-finetune-runner.md): Run a QLoRA (4-bit LoRA) fine-tune of an open-weight model from a prepared dataset — set up the config, train memory-efficiently (e.g. with Unsloth/PEFT), watch for overfitting, save the adapter, and run a quick eval against the prepared split. Use when you have a clean dataset and want to execute a parameter-efficient fine-tune on a single GPU.
- [Semantic Cache Designer](https://agentscamp.com/skills/data/semantic-cache-designer.md): Design a semantic cache for LLM responses — serve a cached answer when a new query is similar enough to a past one — to cut cost and latency on repetitive traffic, with the similarity threshold calibrated on real query pairs and a cache key that prevents cross-user/model leaks. Use when an LLM app sees many near-duplicate prompts (FAQs, support, search), when token spend on repetitive queries is high, or when latency on common questions matters.
- [SQL Optimizer](https://agentscamp.com/skills/data/sql-optimizer.md): Diagnose a slow SQL query from its execution plan and propose a verified optimization — finding the real bottleneck (sequential scan, missing or unused index, bad join order, app-side N+1) and measuring the fix before and after. Use when a query is slow and you need a fix backed by EXPLAIN ANALYZE, not a guess.
- [Token Usage Profiler](https://agentscamp.com/skills/data/token-usage-profiler.md): Measure and attribute LLM token usage and cost across an app — input vs output tokens by feature, route, model, and tenant — then rank the waste and the specific lever to cut it. Use when LLM spend is high or climbing with no clear cause, before scaling a feature that calls a model, or when you need per-feature or per-tenant cost attribution for billing or budgets.
- [Web Research Pipeline](https://agentscamp.com/skills/data/web-research-pipeline.md): Run a structured web-research pass on a question: plan the searches, find sources via search APIs, fetch and read the best ones, cross-check claims, and synthesize a cited answer — with source quality and disagreements surfaced honestly. Use for 'research X and tell me what's actually true' tasks that need more than one search and less than a day.
- [Connection Pool Tuner](https://agentscamp.com/skills/database/connection-pool-tuner.md): Size and tune a database connection pool from the real constraint — the database's shared max_connections and its core count — so total connections (per-instance pool × instance count) stay safely under the cap and a too-large pool stops adding latency. Use when the app throws 'too many connections' or pool-acquire timeouts, when the DB is saturated by connection count, or when deploying to serverless.
- [Deadlock Diagnoser](https://agentscamp.com/skills/database/deadlock-diagnoser.md): Diagnose a database deadlock from the engine's own deadlock report, reconstruct the lock cycle (A holds 1 wants 2, B holds 2 wants 1), name the root cause — almost always two code paths locking the same rows in different orders — and fix it with consistent lock ordering, shorter transactions, and a retry-the-victim safeguard. Use when the DB logs deadlock errors, when transactions intermittently fail under load, or when queries mysteriously block each other.
- [Embedding Index Tuner](https://agentscamp.com/skills/database/embedding-index-tuner.md): Tune a vector index — HNSW graph parameters and quantization — to hit a recall target at the lowest latency and memory, by sweeping settings against a fixed query set instead of trusting defaults. Use when vector search is slow or memory-hungry, when recall dropped after enabling quantization, or when standing up an index and you need defensible parameters.
- [Migration Writer](https://agentscamp.com/skills/database/migration-writer.md): Write a safe, reversible, zero-downtime database migration using expand-contract — add the new shape, backfill in batches, switch reads/writes, then drop the old — so every deploy stays compatible with the running app version. Use when adding or changing schema on a live system, renaming/dropping a column, adding NOT NULL or a foreign key on a large table, or when a migration risks locks, table rewrites, or an unrevertable step.
- [Postgres Index Strategist](https://agentscamp.com/skills/database/postgres-index-strategist.md): Recommend the right Postgres index for a query or workload — choosing B-Tree vs. GIN vs. BRIN vs. partial/covering/expression, checking for redundant or unused indexes, and verifying the choice against the query plan. Use when a query needs an index, when deciding an index type for jsonb/array/full-text/time-series data, or when auditing an over-indexed table.
- [Query Plan Analyzer](https://agentscamp.com/skills/database/query-plan-analyzer.md): Read a slow query's execution plan and turn it into a concrete fix — the exact index to add, the rewrite, or the ANALYZE to run — by getting the REAL plan with EXPLAIN ANALYZE (actual rows + timing, not estimates), finding the offending node, and confirming the fix removes it. Use when one specific query is slow and you need to know WHY, not just that it is.
- [Adr Writer](https://agentscamp.com/skills/docs/adr-writer.md): Write an Architecture Decision Record capturing a decision the user describes, in Michael Nygard ADR format (Status, Context, Decision, Consequences) with an added Considered Alternatives section. Use when recording a significant architectural or technology choice.
- [Architecture Diagram Generator](https://agentscamp.com/skills/docs/architecture-diagram-generator.md): Generate accurate architecture diagrams as Mermaid — straight from the codebase, not from imagination — by first choosing which view answers the question (container/component, sequence, ER, or state) and then reading the real entry points, module boundaries, service calls, and schema. Use when onboarding to an unfamiliar repo, documenting a system, or visualizing one complex flow.
- [Onboarding Guide Writer](https://agentscamp.com/skills/docs/onboarding-guide-writer.md): Write a developer onboarding guide that gets a new contributor from clone to first merged change fast — a verified golden path, a quick architecture map, the real workflow conventions, and the gotchas that live only in senior engineers' heads. Use when a repo has no onboarding doc, when new hires keep asking the same setup questions, or when the README is a marketing page instead of a contributor guide.
- [OpenAPI Doc Writer](https://agentscamp.com/skills/docs/openapi-doc-writer.md): Produce and maintain OpenAPI documentation for an HTTP API. Use when documenting endpoints, request/response schemas, or generating API reference docs.
- [Readme Generator](https://agentscamp.com/skills/docs/readme-generator.md): Generate or refresh a project README grounded in the actual repository. Use when a project has no README, a stale one, or you want install/usage/scripts/structure sections that match the real code.
- [Runbook Writer](https://agentscamp.com/skills/docs/runbook-writer.md): Write an operational runbook a half-asleep on-call engineer can execute at 3am — scoped to ONE alert, leading with how to confirm the problem, the copy-pasteable mitigation that stops user pain, then diagnosis, escalation, and verification. Use when an alert has no documented response, after an incident exposed a missing procedure, or when standing up on-call for a service.
- [Branch Rebaser](https://agentscamp.com/skills/git/branch-rebaser.md): Rebase the current branch onto its base and walk every conflict methodically, resolving each by understanding both sides. Use when your feature branch has fallen behind main and you want a clean, linear history without clobbering changes.
- [Commit Splitter](https://agentscamp.com/skills/git/commit-splitter.md): Split one big, mixed-up change into a series of small, atomic commits — each a single logical change that builds and passes tests on its own — by grouping hunks by intent and staging them piecemeal. Use when a working tree or a fat commit mixes a feature, a refactor, a bug fix, and formatting, or before opening a PR you want reviewers to actually read.
- [Conventional Commits](https://agentscamp.com/skills/git/conventional-commits.md): Generate clear Conventional Commits messages from staged changes. Use when committing code and you want a well-structured, consistent commit message.
- [Git Blame Investigator](https://agentscamp.com/skills/git/git-blame-investigator.md): Reconstruct why a line of code exists from Git history — find the originating commit, read its message and full diff for intent, and see through reformatting/rename commits with ignore-revs and the pickaxe — before you change or delete it. Use when a line looks wrong or pointless and you want to remove it, when tracing a regression to its commit, or when onboarding to unfamiliar code.
- [PR Description](https://agentscamp.com/skills/git/pr-description.md): Draft a clear pull request description from the branch diff against its base. Use when you have a finished branch and want a reviewer-ready PR body before opening the PR.
- [Alerting Rules Tuner](https://agentscamp.com/skills/observability/alerting-rules-tuner.md): Cut alert noise and make every page mean something — rewrite alerting rules to fire on user-felt symptoms (error rate, latency SLO burn, failed requests) instead of causes (high CPU, full disk), with duration windows and severity routing so only urgent, actionable conditions reach a human. Use when on-call is fatigued by low-value pages, when real incidents get missed in the noise, or when alerts fire on causes rather than impact.
- [Dashboard Designer](https://agentscamp.com/skills/observability/dashboard-designer.md): Design a service dashboard that answers one question at a glance — is the service healthy, and if not, where's the problem? — by structuring panels around RED/USE instead of dumping every metric. Use when a service has no dashboard, when the existing one is an unreadable metric wall, or during incident-readiness prep.
- [Distributed Tracing Instrumenter](https://agentscamp.com/skills/observability/distributed-tracing-instrumenter.md): Instrument a service (or a chain of services) with OpenTelemetry so a single request can be followed end-to-end — context propagated across every hop including async/queue boundaries, spans at the boundaries that matter, deliberate trace-wide sampling, and trace_id stamped on log lines. Use when latency or failures span multiple services, when you have logs but can't reconstruct a request's full path, or when adopting OpenTelemetry.
- [SLO Definer](https://agentscamp.com/skills/observability/slo-definer.md): Turn a vague reliability goal into concrete SLIs, SLOs, an error budget, and burn-rate alerts — service-level indicators measured at the user-facing boundary, targets over a rolling window, and a written policy for what happens when the budget runs out. Use when a service has no defined reliability target, when on-call is noisy and alert-fatigued, or before you commit to an SLA you can't measure.
- [Structured Logging Designer](https://agentscamp.com/skills/observability/structured-logging-designer.md): Design a structured (JSON) logging strategy with a stable field schema, correlation-ID propagation, and a disciplined level policy — then migrate ad-hoc string logs toward it. Use when logs are unsearchable plain text, when debugging a request across services means grepping multiple log streams by hand, or when standing up logging for a new service.
- [Bundle Analyzer](https://agentscamp.com/skills/performance/bundle-analyzer.md): Analyze a JS/TS production bundle and surface the biggest size wins — heavy dependencies, duplicate packages, missing code-splitting, oversized polyfills, and dev/server code leaking into the client. Use when a bundle is too large and you need a ranked, actionable reduction plan.
- [Cold Start Optimizer](https://agentscamp.com/skills/performance/cold-start-optimizer.md): Cut cold-start latency for serverless functions and slow-booting apps by measuring the init breakdown, then attacking the dominant phase — artifact size, eager imports, eager connections, or under-provisioned memory — instead of reflexively buying provisioned concurrency. Use when serverless p99 spikes on the first request, when a function times out during init, or when scale-to-zero is hurting user-facing latency.
- [Flamegraph Analyzer](https://agentscamp.com/skills/performance/flamegraph-analyzer.md): Turn a CPU profile or flamegraph into a concrete optimization instead of guessing where the time goes: capture under a realistic workload with a sampling profiler, read the graph correctly (width = time, depth ≠ time), find the widest self-time leaves, ask if that work is necessary/redundant/algorithmically wrong, fix the biggest contributor, then re-profile. Use when code is CPU-bound and slow, a function is hot but you don't know which part, or you have a profile you can't interpret.
- [Load Test Designer](https://agentscamp.com/skills/performance/load-test-designer.md): Design a defensible load test — a realistic workload model, a deliberate test type, and SLO-tied pass/fail thresholds — instead of a meaningless tight-loop script that hammers one endpoint. Use when validating capacity or SLOs before a launch or scaling event, when sizing infrastructure, or when an existing load test reports averages that nobody trusts.
- [Memory Leak Hunter](https://agentscamp.com/skills/performance/memory-leak-hunter.md): Find and fix a memory leak in a running app: confirm it's a real leak under steady load, diff two heap snapshots to name the growing object and its retention path, cut the root reference that blocks collection, and re-run to confirm memory plateaus. Use when RSS climbs until OOM/restart, heap grows unbounded across a steady workload, or GC pauses worsen the longer the process runs.
- [Prompt Cache Optimizer](https://agentscamp.com/skills/performance/prompt-cache-optimizer.md): Restructure an LLM call to maximize prompt-cache hit rate and add response/semantic caching — move the stable prefix (system prompt, instructions, few-shot, context) to the front and variable input to the end, set cache breakpoints, and measure the hit rate and savings. Use when repeated calls share large common context and token cost or latency is too high.
- [React Render Profiler](https://agentscamp.com/skills/performance/react-render-profiler.md): Find and fix wasteful React re-renders by classifying the cause — unstable prop/callback/object identities, context value churn, state lifted too high, expensive work in render, or unvirtualized lists — confirming it with a measurement, then applying the one targeted fix and re-measuring. Use when a React UI is janky, slow to type in, or re-renders far more than the data actually changed.
- [Web Vitals Optimizer](https://agentscamp.com/skills/performance/web-vitals-optimizer.md): Diagnose and fix Core Web Vitals — LCP, CLS, and INP — by treating real-user field data at p75 as the source of truth, using Lighthouse/WebPageTest only to find the at-fault element, script, or shift, then applying the one targeted fix per metric and re-measuring. Use when a page feels slow, scores poorly on PageSpeed/Lighthouse, or fails CWV in CrUX/RUM field data.
- [Circular Dependency Breaker](https://agentscamp.com/skills/refactor/circular-dependency-breaker.md): Detect and break a circular import — map the exact cycle with a real tool, then break the right edge by extracting the shared piece into a leaf module, inverting a layering dependency, merging two falsely-split modules, or (last resort) deferring an import. Use when you hit an import cycle error, an undefined-on-import or 'cannot access before initialization' bug, or a bundler/linter flags a cycle.
- [Dead Code Finder](https://agentscamp.com/skills/refactor/dead-code-finder.md): Find genuinely unused code — unreferenced exports, unreachable files, and unused dependencies — and remove it safely with build/test verification. Use when trimming a codebase or untangling years of accreted cruft.
- [Dependency Upgrade Planner](https://agentscamp.com/skills/refactor/dependency-upgrade-planner.md): Plan and de-risk a major dependency, framework, or runtime upgrade — map the full version path, read every intermediate migration guide, and pin the breaking changes to your actual call sites instead of bumping the number and hoping. Use when a key dependency is several majors behind, when a security advisory forces an upgrade, or before a framework migration.
- [Extract Module](https://agentscamp.com/skills/refactor/extract-module.md): Split an overgrown file into cohesive, well-bounded modules — find the natural seams, design each new module's public interface before moving a line, then relocate one unit at a time keeping tests green. Use when a file has grown too large, mixes unrelated responsibilities, or every change to it forces unrelated diffs and merge conflicts.
- [Feature Flag Retirer](https://agentscamp.com/skills/refactor/feature-flag-retirer.md): Retire stale feature flags by confirming each flag's decided final state, then collapsing every conditional to the winning branch and deleting the loser plus the now-dead code it reached. Use when temporary flags have outlived their rollout, when flag conditionals clutter the code, or during a flag-debt cleanup.
- [Strangler Fig Migrator](https://agentscamp.com/skills/refactor/strangler-fig-migrator.md): Plan the incremental replacement of a legacy module or service using the strangler-fig pattern — grow new code around the old behind an interception seam until the old is dead, instead of a big-bang rewrite. Use when a legacy system is too risky to rewrite at once, or when migrating off a deprecated framework/dependency gradually while staying shippable and rollback-able at every step.
- [Type Coverage Improver](https://agentscamp.com/skills/refactor/type-coverage-improver.md): Raise TypeScript type strictness incrementally — measure the any/implicit-any baseline, enable one strict sub-flag at a time, and fix the fallout per flag instead of all at once, keeping the typecheck green at every step. Use when a codebase is loosely typed, when you want strict mode on without a big-bang break, or when `any` keeps hiding bugs that surface in production.
- [Canary Release Planner](https://agentscamp.com/skills/release/canary-release-planner.md): Design a canary / progressive rollout so a bad release reaches 1% of users instead of 100% — staged traffic with bake times, gating metrics compared against the concurrently-running stable baseline, and automated promote-or-rollback. Use when shipping a risky change, when you want automatic rollback on regression, or when moving off all-at-once deploys.
- [Changelog From PRs](https://agentscamp.com/skills/release/changelog-from-prs.md): Draft a release changelog by summarizing merged pull requests since the last tag. Use when preparing a release or writing release notes.
- [Release Notes Writer](https://agentscamp.com/skills/release/release-notes-writer.md): Write user-facing release notes — the curated 'what's new and what it means for you' — by starting from the real changes (git log / merged PRs / the changelog since the last release) and translating developer-speak into user impact, grouped by what the user cares about with breaking changes and required actions surfaced first. Use when shipping a release to users or customers and the raw commit log isn't something a user should read, when you need a published GitHub-release / blog / in-app announcement, or when a breaking change must be made unmissable so upgrades don't break.
- [SemVer Advisor](https://agentscamp.com/skills/release/semver-advisor.md): Decide the correct semantic-version bump — major, minor, or patch — by diffing a release range, mapping the changes onto the public API surface, and classifying each as breaking, additive, or a fix. Use before cutting a release when you are unsure whether changes are breaking, when a teammate proposes a bump you want to sanity-check, or when a behavior change has no signature change and you need to know if it is still breaking.
- [Version Bumper](https://agentscamp.com/skills/release/version-bumper.md): Bump the project version everywhere it lives in one consistent pass — package.json, lockfile, nested/CLI package manifests, version constants, README badges, docs — then roll the changelog's Unreleased section under the new version and stage an annotated git tag. Use when you've already decided the new version (X.Y.Z or a pre-release like -rc.1) and need every artifact updated to the same value without drift, or before cutting a release.
- [Auth Flow Reviewer](https://agentscamp.com/skills/security/auth-flow-reviewer.md): Read-only review of authentication AND authorization flows — session/token model, cookie flags, CSRF, token rotation, password-reset/email-verification, OAuth redirect/state, and per-route object-level access checks — for exploitable gaps. Use before shipping login/session/token code, when adding a protected route or sharing-by-URL feature, or during a security pass. Reports findings by severity with location, impact, and the concrete fix; never edits code.
- [Dependency Audit](https://agentscamp.com/skills/security/dependency-audit.md): Audit project dependencies for known vulnerabilities and turn the raw scanner output into a triaged, prioritized upgrade plan. Use when an audit is noisy, a CVE was reported, or you need to know which advisories actually matter.
- [License Compliance Checker](https://agentscamp.com/skills/security/license-compliance-checker.md): Audit the licenses of a project's dependencies for compatibility with how the project is distributed — flagging copyleft (GPL/AGPL/LGPL), missing or unknown licenses, and other obligations that conflict with your own license or SaaS/proprietary model. Use before shipping or open-sourcing, when adding a dependency, or when legal/procurement asks for a license inventory. This is a licensing review, not a vulnerability scan.
- [LLM Guardrails Designer](https://agentscamp.com/skills/security/llm-guardrails-designer.md): Design input and output guardrails for an LLM app — decide what to check (injection patterns, PII, secrets, policy, schema, leakage, toxicity), place them as input vs. output rails, implement with a library like NeMo Guardrails or LLM Guard, and fail closed. Use when adding a safety/validation layer around an LLM, not relying on the prompt alone.
- [Prompt Pii Redactor](https://agentscamp.com/skills/security/prompt-pii-redactor.md): Detect and redact PII and secrets from prompts (and logs/traces) before they reach an LLM provider — mask or tokenize emails, phone numbers, names, IDs, and API keys, reversibly where the response needs the real values back. Use when sending user or document data to a third-party model, or when LLM request logs may capture sensitive data.
- [RBAC Designer](https://agentscamp.com/skills/security/rbac-designer.md): Design the authorization model itself — fine-grained permissions on resources composed into roles, with the right amount of resource/tenant scoping — instead of scattering role-name checks through handlers. Use when building multi-user or multi-tenant authorization, when `if user.isAdmin` checks are sprawling across the codebase, or when 'who can do what' needs a real model rather than ad-hoc gates.
- [Secret Scanner](https://agentscamp.com/skills/security/secret-scanner.md): Scan a repo or a diff for committed secrets — API keys, tokens, private keys, .env files, and high-entropy strings — then triage real leaks from fixtures. Use before pushing, in review, or when a credential may have leaked.
- [Security Headers Hardener](https://agentscamp.com/skills/security/security-headers-hardener.md): Audit and harden a web app's or API's HTTP security headers — Content-Security-Policy, HSTS, X-Content-Type-Options, frame-ancestors, Referrer-Policy, Permissions-Policy, and CORS — and produce a staged rollout that won't break the site. Use before a launch, during a security pass, or when a scanner (Mozilla Observatory, securityheaders.com, a pentest) flags missing or weak headers. Audits and edits header config; rolls CSP out Report-Only first.
- [Threat Model Builder](https://agentscamp.com/skills/security/threat-model-builder.md): Build a practical threat model for a feature or system using STRIDE — diagram the data flow, mark trust boundaries, enumerate concrete threats where data crosses them, and prioritize by likelihood × impact so security is reasoned about before shipping instead of bolted on after. Use when designing a feature that touches auth, money, or sensitive data, running a security design review, or hardening before a launch.
- [Contract Test Designer](https://agentscamp.com/skills/testing/contract-test-designer.md): Design consumer-driven contract tests between services so an API provider can't break its consumers unnoticed — without slow, flaky full end-to-end environments. Use when independent services or teams integrate over an API, when integration bugs only surface in staging or prod, or when E2E suites are too slow and brittle to catch breaking API changes.
- [Coverage Gap Finder](https://agentscamp.com/skills/testing/coverage-gap-finder.md): Run the project's coverage tool and identify the highest-value untested paths — error branches, edge cases, and critical modules — then propose specific test cases for each gap. Use when you have a coverage report but don't know where new tests will pay off most.
- [Integration Test Designer](https://agentscamp.com/skills/testing/integration-test-designer.md): Design integration tests that exercise components against REAL collaborators — actual database, queue, HTTP boundary — at a deliberately chosen seam, instead of a unit suite that mocks everything or a slow flaky full E2E. Use when bugs slip past green unit tests, when wiring or contracts between layers break in production, or when a mocked DB test passes but the real query/migration/serialization fails.
- [Mock Data Factory](https://agentscamp.com/skills/testing/mock-data-factory.md): Generate a typed mock/fixture factory for a given type, interface, or schema, inferring believable values from field names and types. Use when tests or local dev need realistic, type-safe sample data with per-field overrides.
- [Mutation Test Runner](https://agentscamp.com/skills/testing/mutation-test-runner.md): Measure whether a test suite actually catches bugs by running mutation testing — introduce small faults into the code and check which ones a test kills versus which slip through silently. Use when line coverage is high but bugs still ship, when you suspect tests assert weakly, or to find the exact assertions a suite is missing.
- [Property Test Designer](https://agentscamp.com/skills/testing/property-test-designer.md): Design property-based tests — generate hundreds of random inputs and assert invariants that must hold for ALL of them — to surface the edge cases hand-picked examples never reach. Use when code has a large input space (parsers, serializers, encoders, math, data transforms), when a bug keeps slipping through despite green example tests, or when you can't enumerate every case worth checking.
- [Test Scaffolder](https://agentscamp.com/skills/testing/test-scaffolder.md): Scaffold a test file with sensible cases for a given module or function. Use when adding tests to untested code and you want a fast, structured starting point.
- [Agent Memory Designer](https://agentscamp.com/skills/workflow/agent-memory-designer.md): Design a project's CLAUDE.md and memory hierarchy by exploring the repo to learn its real build/test/lint commands, architecture, and non-obvious gotchas, then writing a concise, skimmable memory that keeps only what belongs in context. Use when onboarding a repo to Claude Code with no CLAUDE.md, or when an existing one is bloated, stale, or being ignored.
- [Claude Settings Auditor](https://agentscamp.com/skills/workflow/claude-settings-auditor.md): Audit every Claude Code settings layer — user, project, local, and managed — and report the effective merged configuration with its risks: over-broad Bash allows, missing deny rules for secrets, bypassPermissions defaults, unvetted MCP servers and hooks, and rules that never match. Use before trusting a new repo's checked-in settings, or to harden your own before handing the agent more autonomy.
- [Dev Container Designer](https://agentscamp.com/skills/workflow/devcontainer-designer.md): Design a reproducible dev environment (Dev Container / Docker) so onboarding is one command and 'works on my machine' dies — by detecting the project's real stack and versions, authoring a devcontainer.json (+ Dockerfile/compose) that pins the runtime to what the repo targets, wires dependent services, caches dependencies, and injects secrets instead of baking them. Use when new contributors struggle to set up the project, when environment drift causes inconsistent behavior, or when standardizing tooling across a team.
- [Dockerfile Optimizer](https://agentscamp.com/skills/workflow/dockerfile-optimizer.md): Shrink and harden an existing Dockerfile — multi-stage builds, cache-friendly layer order, a lean pinned base image, a .dockerignore, and a non-root runtime user — without changing what the image runs. Use when an image is too large, builds are slow because the cache never hits, or a scan flags the container running as root.
- [GitHub Actions Optimizer](https://agentscamp.com/skills/workflow/github-actions-optimizer.md): Make a GitHub Actions workflow faster, cheaper, and harder to attack — by profiling where wall-clock and billed minutes actually go, then adding content-keyed caching, matrix/job parallelism, run-cancellation, and path filters, and hardening the supply chain (SHA-pinned actions, least-privilege GITHUB_TOKEN, safe fork-PR handling). Use when CI is slow or queues, when a repo burns Actions minutes, or before trusting a workflow that runs on untrusted pull requests.
- [Hook Writer](https://agentscamp.com/skills/workflow/hook-writer.md): Turn a plain-language automation request — 'format every file Claude edits', 'block writes to migrations', 'notify me when input is needed' — into a working Claude Code hook: the right event, a safe tested script, and the settings.json registration at the right scope. Use when you want a hook but don't want to hand-write the matcher, stdin JSON parsing, and exit-code plumbing.
- [Human In The Loop Gate](https://agentscamp.com/skills/workflow/human-in-the-loop-gate.md): Add a human approval checkpoint to an agent so it pauses before a risky or irreversible action (spending money, deleting data, sending messages, merging code) and resumes only after a human approves. Use when an agent acts autonomously on consequential operations.
- [Plugin Scaffolder](https://agentscamp.com/skills/workflow/plugin-scaffolder.md): Scaffold a complete, valid Claude Code plugin from a description — the .claude-plugin/plugin.json manifest, component directories (skills, agents, commands, hooks, MCP config), portable ${CLAUDE_PLUGIN_ROOT} wiring, a local test loop with --plugin-dir, and a marketplace.json for distribution. Use when turning scattered .claude/ customizations into one installable, versioned package.
- [Prompt Optimizer](https://agentscamp.com/skills/workflow/prompt-optimizer.md): Diagnose why a prompt underperforms and rewrite it with the technique that fixes it — clearer structure, few-shot examples, an explicit output contract, or reasoning scaffolding — returning an optimized prompt, the rationale for every change, and what to measure to confirm the lift. Use when a prompt is flaky, verbose, drifting in format, or just not good enough.
- [Skill Auditor](https://agentscamp.com/skills/workflow/skill-auditor.md): Audit an installed set of Claude Code skills for the failure modes that make them misfire — overlapping descriptions that misroute tasks, trigger phrasing that never matches, bloated bodies, missing boundaries, and over-broad tool grants — and return a prioritized fix list with rewritten descriptions. Use when a skill fires on the wrong tasks, never fires at all, or a skills folder has grown past what anyone reviews.

## Guides

Long-form guides and tutorials for building with AI coding agents.

- [Building an MCP Server](https://agentscamp.com/guides/advanced/building-an-mcp-server.md): An accurate introduction to the Model Context Protocol: server anatomy, transports, and connecting a tool to Claude Code.
- [Building Multi-Step Agent Workflows](https://agentscamp.com/guides/advanced/building-multi-step-workflows.md): Patterns for building multi-step agent workflows in Claude Code: decompose tasks, fan-out to parallel subagents, verify every step, and orchestrate.
- [Building Agents with the Claude Agent SDK](https://agentscamp.com/guides/advanced/claude-agent-sdk-tutorial.md): A working tutorial for the Claude Agent SDK in TypeScript and Python — query(), tool permissions, custom in-process MCP tools, subagents, hooks, and auth.
- [Running Claude Code in CI: Headless Mode & GitHub Actions](https://agentscamp.com/guides/advanced/claude-code-ci-github-actions.md): Claude Code without the terminal — claude -p flags, JSON and structured output, safe permission scoping, and the official GitHub Action responding to @claude.
- [LLM API Pricing in 2026: Every Major Model Compared](https://agentscamp.com/guides/advanced/llm-api-pricing-2026.md): Per-million-token prices for Claude, GPT, Gemini, DeepSeek, Mistral, and Grok — plus caching and batch discounts — verified against vendor pricing pages.
- [LLM Context Windows Compared (2026)](https://agentscamp.com/guides/advanced/llm-context-windows-compared.md): Context windows and max output tokens across Claude, GPT, Gemini, DeepSeek, and Grok — the million-token era, what it costs, and what fits in practice.
- [LLM Cost and Latency Engineering: Caching, Right-Sizing, and p95 Budgets](https://agentscamp.com/guides/advanced/llm-cost-latency-engineering.md): A practical playbook for cutting LLM cost and tail latency — caching, model right-sizing, prompt trimming, and enforced p95 budgets — without losing quality.
- [LLM Gateways Compared: Portkey vs Helicone vs LiteLLM for Caching & Cost Control](https://agentscamp.com/guides/advanced/llm-gateways-compared.md): How Portkey, Helicone, and LiteLLM compare for caching, cost control, and observability — each one's 2026 status and which fits self-hosted vs. hosted.
- [Multi-Agent Orchestration](https://agentscamp.com/guides/advanced/multi-agent-orchestration.md): Four patterns for coordinating multiple agents — fan-out, pipeline, orchestrator-worker, and verify/critic — and when each earns its overhead.
- [Parallel Claude Code Sessions with Git Worktrees](https://agentscamp.com/guides/advanced/parallel-claude-code-worktrees.md): Run several Claude Code sessions at once without edits colliding — the built-in claude --worktree flag, .worktreeinclude, subagent isolation, and cleanup.
- [Sandboxing AI-Generated Code: E2B vs Modal vs Daytona vs Vercel Sandbox](https://agentscamp.com/guides/advanced/sandboxing-ai-generated-code.md): Where should agent-written code run? E2B vs Modal vs Daytona vs Vercel Sandbox compared on isolation, persistence, and cost, plus rules for safe execution.
- [Are Claude Skills Safe? A Security Review Checklist](https://agentscamp.com/guides/ai-safety/are-claude-skills-safe.md): Skills are an instruction supply chain: what can go wrong with third-party SKILL.md files, and the review checklist before installing or distributing one.
- [Data Privacy for LLM Apps: Stop Leaking Sensitive Data](https://agentscamp.com/guides/ai-safety/data-privacy-for-llm-apps.md): Where LLM apps leak PII and secrets — prompts, logs, traces, vector stores, providers — and the controls (redaction, ZDR, tenant isolation) that stop it.
- [Defending Against Prompt Injection: A Practical Guide for LLM Apps](https://agentscamp.com/guides/ai-safety/defending-prompt-injection.md): Prompt injection can't be solved at the model layer — so you defend in depth: trust boundaries, least privilege, human approval, guardrails, and red-teaming.
- [Securing AI Agents: The OWASP Agentic Top 10 in Practice](https://agentscamp.com/guides/ai-safety/owasp-agentic-top-10.md): Agents add risks LLM-app security misses — autonomy, tools, memory, multi-agent trust. The key OWASP agentic threats and how to mitigate each in practice.
- [Aider vs Claude Code: Open-Source vs Anthropic's Agent (2026)](https://agentscamp.com/guides/comparisons/aider-vs-claude-code.md): Aider vs Claude Code — model-agnostic open-source pair-programmer vs Anthropic's tuned terminal harness. Which terminal coding agent fits your stack.
- [Best AI App Builders in 2026: v0 vs Lovable vs Bolt vs Replit](https://agentscamp.com/guides/comparisons/best-ai-app-builders-2026.md): The prompt-to-app builders compared — v0 for production UI, Lovable for full apps, Bolt for in-browser velocity, Replit for build-and-host in one place.
- [Best AI Code Review Tools in 2026](https://agentscamp.com/guides/comparisons/best-ai-code-review-tools-2026.md): The AI code reviewers worth running in 2026 — CodeRabbit, Greptile, and Qodo compared, plus open-source PR-Agent and when Copilot's review is enough.
- [Best Tools for Running LLMs Locally in 2026](https://agentscamp.com/guides/comparisons/best-local-llm-tools-2026.md): The local LLM stack, ranked by job: Ollama for serving tools, LM Studio and Jan for desktop exploration, llama.cpp for control, vLLM when it's real serving.
- [Best RAG Frameworks in 2026](https://agentscamp.com/guides/comparisons/best-rag-frameworks-2026.md): A roundup of the top RAG frameworks in 2026 — LlamaIndex, LangChain, Haystack, and DSPy — and which one fits your retrieval stack.
- [Browser Agents in 2026: Browser Use vs Stagehand vs Skyvern vs Playwright MCP](https://agentscamp.com/guides/comparisons/browser-agents-compared-2026.md): Four ways to give AI a browser — Browser Use, Stagehand, Skyvern, and Playwright MCP compared honestly on control, cost, and reliability for 2026.
- [Claude Code vs Codex CLI: Terminal Agents Compared (2026)](https://agentscamp.com/guides/comparisons/claude-code-vs-codex-cli.md): Claude Code vs OpenAI's Codex CLI — autonomy vs sandboxed control, extensibility vs open source, model ecosystems, and which terminal agent fits your work.
- [Claude Code vs Cursor: Which AI Coding Tool in 2026?](https://agentscamp.com/guides/comparisons/claude-code-vs-cursor.md): Claude Code vs Cursor compared honestly — terminal agent vs AI-first editor, autonomy vs inline control, pricing models, and when to run both.
- [Claude Code vs Gemini CLI: Which Terminal Agent (2026)](https://agentscamp.com/guides/comparisons/claude-code-vs-gemini-cli.md): Claude Code vs Gemini CLI: first-party stability and a deep programmable harness vs open-source TypeScript, a big free tier, and the Antigravity cutover.
- [Claude Code vs OpenCode: First-Party vs Open Source (2026)](https://agentscamp.com/guides/comparisons/claude-code-vs-opencode.md): Claude Code vs OpenCode — Anthropic's tuned first-party agent vs the most-starred open-source one with 75+ providers. Control vs polish, decided honestly.
- [Claude Skills vs Custom GPTs: Different Answers to Reuse](https://agentscamp.com/guides/comparisons/claude-skills-vs-custom-gpts.md): Claude Skills are portable procedures; Custom GPTs are packaged chatbots inside ChatGPT. How they differ on portability, API access, sharing, and where each wins.
- [Cursor vs Windsurf (Devin Desktop) in 2026](https://agentscamp.com/guides/comparisons/cursor-vs-windsurf.md): Cursor vs Windsurf — now Devin Desktop — compared: agent-first editing, Composer vs Devin Local, the Cognition rebrand, and which AI editor fits you.
- [DeepEval vs RAGAS: LLM Evaluation Frameworks Compared (2026)](https://agentscamp.com/guides/comparisons/deepeval-vs-ragas.md): DeepEval vs RAGAS — pytest-style general LLM testing vs RAG-specialized metrics. Which open-source eval framework fits your pipeline, or whether you need both.
- [Exa vs Tavily: Web Search APIs for AI Agents (2026)](https://agentscamp.com/guides/comparisons/exa-vs-tavily.md): Exa vs Tavily compared — neural semantic discovery vs agent-optimized RAG answers, pricing, MCP support, and which web search API fits your stack.
- [GitHub Copilot vs Cursor: Extension or Editor? (2026)](https://agentscamp.com/guides/comparisons/github-copilot-vs-cursor.md): GitHub Copilot vs Cursor compared — stay in your editor with an extension, or switch to an AI-first fork? Completion, agents, enterprise fit, and pricing shape.
- [LangChain vs LlamaIndex in 2026: Agents or Data?](https://agentscamp.com/guides/comparisons/langchain-vs-llamaindex.md): The classic framework confusion resolved — LangChain's agent loop and ecosystem vs LlamaIndex's data-and-documents depth — and when you'd genuinely use both.
- [Langfuse vs LangSmith: LLM Observability Compared (2026)](https://agentscamp.com/guides/comparisons/langfuse-vs-langsmith.md): Langfuse vs LangSmith — open-source self-hostable observability vs LangChain's first-party platform. Tracing, evals, prompt management, and which to adopt.
- [LangGraph vs CrewAI: Agent Frameworks Compared (2026)](https://agentscamp.com/guides/comparisons/langgraph-vs-crewai.md): LangGraph vs CrewAI — explicit state-machine control vs role-based crew abstractions. Which agent framework fits your reliability bar and team.
- [LiteLLM vs OpenRouter: One API for Every Model (2026)](https://agentscamp.com/guides/comparisons/litellm-vs-openrouter.md): LiteLLM vs OpenRouter compared — self-hosted gateway library vs hosted model marketplace. Keys, billing, control, and which unified LLM layer fits.
- [Mem0 vs Zep vs Letta: Agent Memory Compared (2026)](https://agentscamp.com/guides/comparisons/mem0-vs-zep-vs-letta.md): Three philosophies of agent memory — Mem0's drop-in layer, Zep's temporal knowledge graphs, Letta's self-managing agents — and which fits your architecture.
- [n8n vs Dify: Which AI Workflow Platform? (2026)](https://agentscamp.com/guides/comparisons/n8n-vs-dify.md): Automation-first vs AI-native: n8n's 400+ integrations and agent nodes vs Dify's LLM-app platform with built-in RAG. Licenses, pricing, and the fit test.
- [Ollama vs LM Studio: Running LLMs Locally (2026)](https://agentscamp.com/guides/comparisons/ollama-vs-lm-studio.md): Ollama vs LM Studio compared — CLI-first server for developers vs polished desktop app for exploring local models. Which local LLM tool fits how you work.
- [OpenAI Agents SDK vs LangGraph: Minimal vs Controllable (2026)](https://agentscamp.com/guides/comparisons/openai-agents-sdk-vs-langgraph.md): OpenAI Agents SDK's three-primitive minimalism vs LangGraph's explicit graph and durable state — which agent framework matches your reliability bar in 2026.
- [pgvector vs Pinecone: Do You Need a Vector Database? (2026)](https://agentscamp.com/guides/comparisons/pgvector-vs-pinecone.md): pgvector vs Pinecone compared — vector search inside the Postgres you already run vs a dedicated managed service. Scale thresholds, ops, and the honest default.
- [Qdrant vs Pinecone: Which Vector Database? (2026)](https://agentscamp.com/guides/comparisons/qdrant-vs-pinecone.md): Qdrant vs Pinecone compared — open-source control vs fully managed serverless, filtering and hybrid search, cost shape, and which fits your RAG stack.
- [v0 vs Lovable: AI App Builders Compared (2026)](https://agentscamp.com/guides/comparisons/v0-vs-lovable.md): v0 vs Lovable — Vercel's generative UI tool vs the full-app builder. Component quality vs end-to-end apps, code ownership, and who each serves best.
- [vLLM vs Ollama: Local Convenience or Serving Throughput? (2026)](https://agentscamp.com/guides/comparisons/vllm-vs-ollama.md): vLLM vs Ollama compared — developer-friendly local runtime vs high-throughput production inference engine. Concurrency, hardware, and when to graduate.
- [Weaviate vs Pinecone: Open-Source vs Managed Vector DB (2026)](https://agentscamp.com/guides/comparisons/weaviate-vs-pinecone.md): Weaviate vs Pinecone — BSD-3 open source you self-host vs fully managed serverless. Hybrid search, scaling, cost shape, and which fits your RAG stack.
- [Which Agent Framework in 2026? LangGraph vs CrewAI vs AutoGen vs OpenAI Agents SDK vs Claude Agent SDK](https://agentscamp.com/guides/concepts/agent-frameworks-2026.md): A decision guide to the major AI agent frameworks — control vs. abstraction, multi-agent models, state and durability, and which fits your project.
- [Agent Memory Architecture: Short-Term, Long-Term, and When to Use Each](https://agentscamp.com/guides/concepts/agent-memory-architecture.md): How AI agents remember — working memory vs. persistent long-term memory, what to store, how to retrieve it, and how to keep context small.
- [Agentic RAG: When Retrieval Needs an Agent in the Loop](https://agentscamp.com/guides/concepts/agentic-rag.md): What agentic RAG is — retrieval as a tool an agent uses iteratively, with query planning, self-correction, and multi-source routing — and when the upgrade pays.
- [AI Coding Statistics 2026: The Numbers That Are Actually Sourced](https://agentscamp.com/guides/concepts/ai-coding-statistics-2026.md): How much code AI writes, who uses the tools, and what it does to quality — every statistic dated and traced to its primary source, updated on a cadence.
- [Calling Any Model: Unified LLM Gateways & SDKs in 2026](https://agentscamp.com/guides/concepts/calling-any-model-gateways.md): Why teams put a unified layer in front of LLM providers — and how LiteLLM, OpenRouter, and the Vercel AI SDK compare for fallback and cost control.
- [Choosing Embeddings in 2026: OpenAI vs Cohere vs Voyage vs Open-Source](https://agentscamp.com/guides/concepts/choosing-embeddings-2026.md): A decision guide for picking an embedding model for retrieval — accuracy, dimensions, cost, multilingual and domain fit, self-hosting, and lock-in.
- [GraphRAG Explained: When Knowledge Graphs Beat Vector Search](https://agentscamp.com/guides/concepts/graph-rag.md): What GraphRAG is, how graph-based retrieval differs from vector RAG, the query shapes where it wins, and the honest costs before you build one.
- [How Computer-Use Agents Work](https://agentscamp.com/guides/concepts/how-computer-use-agents-work.md): Inside the perception-action loop that lets AI operate real software — screenshots in, clicks out — plus grounding, reliability, and when to use APIs instead.
- [How Embeddings Work: Vectors, Similarity, and Choosing a Model](https://agentscamp.com/guides/concepts/how-embeddings-work.md): What an embedding actually is, how similarity is measured, how the models are trained, and the practical rules for using embeddings well in search and RAG.
- [How RAG Actually Works: Ingestion, Chunking, Retrieval & Reranking](https://agentscamp.com/guides/concepts/how-rag-works.md): A clear, practical walkthrough of the retrieval-augmented generation pipeline — what each stage does, where it fails, and how the pieces fit together.
- [Hybrid Search & Reranking: From Top-50 Recall to Top-5 Precision](https://agentscamp.com/guides/concepts/hybrid-search-reranking.md): How production RAG combines dense and sparse search, fuses with RRF, and reranks — turning a wide candidate set into the few passages that actually answer.
- [Production Tool & Function Calling: Feed Errors Back as Observations](https://agentscamp.com/guides/concepts/production-tool-calling.md): How agents use tools — the call/observe/retry loop, why errors must return to the model, and the schemas, idempotency, and limits that keep it reliable.
- [RAG vs Long Context: Do Million-Token Windows Kill Retrieval?](https://agentscamp.com/guides/concepts/rag-vs-long-context.md): Million-token context windows promised the end of RAG. The honest 2026 answer: long context changed where retrieval starts paying, not whether it does.
- [Structured Output vs JSON Mode vs Function Calling: Which to Use in 2026](https://agentscamp.com/guides/concepts/structured-output-2026.md): The reliable ways to get typed data out of an LLM — what JSON mode, function calling, and native structured outputs each guarantee, and when to use which.
- [Getting Web Data into AI Agents: Search & Scraping APIs Compared](https://agentscamp.com/guides/concepts/web-data-for-ai-agents.md): The agent web-data layer — Exa for semantic search, Firecrawl for extraction at scale, Tavily for all-in-one, Jina Reader for zero-setup — and how they compose.
- [Claude Code Hooks: Automate Formatting, Tests, and Guardrails](https://agentscamp.com/guides/configuration/claude-code-hooks.md): How Claude Code hooks work — the major hook events, the settings.json configuration shape, exit codes and JSON output, plus three hooks worth copying.
- [Managing Claude Code Memory & Context: CLAUDE.md, /compact, and Auto-Memory](https://agentscamp.com/guides/configuration/claude-code-memory-context.md): How Claude Code remembers — every CLAUDE.md scope and load order, path-scoped rules, the auto-memory system, and the context commands that keep sessions sharp.
- [Claude Code Plugins: Install, Use, and Build Your Own](https://agentscamp.com/guides/configuration/claude-code-plugins.md): How Claude Code plugins work — what they can bundle, the /plugin and marketplace commands, the plugin.json manifest, and building and testing your own.
- [Claude Code Settings & Permissions: settings.json Explained](https://agentscamp.com/guides/configuration/claude-code-settings-permissions.md): Every Claude Code settings file and which one wins, the permission-rule syntax with its Bash matching gotchas, modes, and a safe starter settings.json.
- [CLAUDE.md Best Practices](https://agentscamp.com/guides/configuration/claude-md-best-practices.md): How to write a CLAUDE.md that actually helps — what to include, what to leave out, and how to keep it current.
- [Best Vector Database in 2026: pgvector vs Pinecone vs Qdrant vs Weaviate vs Milvus vs Chroma vs LanceDB](https://agentscamp.com/guides/database/best-vector-database-2026.md): A decision guide to vector databases — embedded, server, or managed; whether you already run Postgres; and which fits your scale, filtering, and RAG needs.
- [Indexing Postgres at Scale: B-Tree vs GIN vs BRIN and the Hidden Cost of Over-Indexing](https://agentscamp.com/guides/database/postgres-indexing-at-scale.md): A practical guide to choosing Postgres index types — B-Tree, GIN, BRIN, partial, and covering — and why every index you add taxes every write.
- [Vector Search at Scale: ANN Indexes, Quantization & Sharding](https://agentscamp.com/guides/database/vector-search-at-scale.md): How to run vector search over millions to billions of vectors without blowing latency, memory, or cost — index families, quantization, filtering, and sharding.
- [Zero-Downtime Postgres Migrations: The Expand-Contract Playbook for 2026](https://agentscamp.com/guides/database/zero-downtime-postgres-migrations.md): How to change a live Postgres schema without downtime or broken deploys — the expand-contract pattern, safe column changes, batched backfills, and CONCURRENTLY.
- [Best LLM & RAG Evaluation Tools in 2026: DeepEval vs RAGAS vs LangSmith vs Phoenix vs promptfoo](https://agentscamp.com/guides/evaluation/best-llm-eval-tools-2026.md): A decision guide to the LLM eval landscape — code-first frameworks vs. eval-and-observability platforms, open-source vs. hosted, and which fits your stack.
- [LLM Evaluation Metrics Explained: Which One to Use and When](https://agentscamp.com/guides/evaluation/llm-evaluation-metrics-explained.md): A practical map of LLM and RAG evaluation metrics — why BLEU/ROUGE fail open-ended text, how LLM-as-judge and RAG metrics work, and which to pick per task.
- [Write Evals for an LLM App: From Zero to a CI Gate](https://agentscamp.com/guides/evaluation/write-llm-evals.md): How to evaluate an LLM feature — build a dataset, choose metrics, set a baseline, score offline, add an LLM judge, and gate CI so quality changes are measured.
- [The AI Engineer Roadmap for 2026](https://agentscamp.com/guides/getting-started/ai-engineer-roadmap-2026.md): A staged path from API calls to production agents — the skills that matter in 2026, what to skip, and the guides and tools for each stage, in order.
- [The Best Claude Code Agents, Skills & Commands to Install First](https://agentscamp.com/guides/getting-started/best-claude-code-agents-skills.md): A curated starter kit from the AgentsCamp library — the subagents, skills, and slash commands that pay off immediately, by workflow.
- [Choosing the Right Model: Haiku vs Sonnet vs Opus](https://agentscamp.com/guides/getting-started/choosing-the-right-model.md): How to pick the right Claude model tier — Haiku, Sonnet, or Opus — for any Claude Code agent or task, with a clear decision rubric and per-agent examples.
- [25 Claude Code Tips, Shortcuts, and Power Features](https://agentscamp.com/guides/getting-started/claude-code-tips.md): The 25 highest-leverage Claude Code tips — keyboard shortcuts, bash and memory prefixes, session commands, model tricks, and power features most people miss.
- [Getting Started with Claude Code Agents](https://agentscamp.com/guides/getting-started/getting-started-with-agents.md): What Claude Code subagents are, why they help, and how to add your first one.
- [Installing Claude Code](https://agentscamp.com/guides/getting-started/installing-claude-code.md): Install Claude Code, authenticate, start a session in a real project, and add a minimal CLAUDE.md.
- [What Is Claude Code?](https://agentscamp.com/guides/getting-started/what-is-claude-code.md): A grounded explanation of Claude Code: an agentic command-line coding tool that reads files, runs commands, and works in a loop toward a goal.
- [Writing Your First Custom Agent](https://agentscamp.com/guides/getting-started/writing-a-custom-agent.md): A step-by-step guide to authoring a focused, effective custom subagent.
- [The Best MCP Servers in 2026](https://agentscamp.com/guides/mcp/best-mcp-servers-2026.md): The MCP servers actually worth connecting in 2026 — Context7, GitHub, Chrome DevTools, Playwright, Serena, Exa, Firecrawl, and official vendor servers.
- [Adding MCP Servers to Claude Code: Local, Remote, and Project-Scoped](https://agentscamp.com/guides/mcp/claude-code-mcp-setup.md): The complete claude mcp add reference — stdio vs HTTP transports, local/project/user scopes, .mcp.json with env expansion, OAuth via /mcp, and the gotchas.
- [Deploying a Remote MCP Server: Stateless, Streamable HTTP, and Horizontal Scaling](https://agentscamp.com/guides/mcp/deploy-remote-mcp-server.md): Take an MCP server from local stdio to a remote, multi-user HTTP service — Streamable HTTP, stateless vs. stateful sessions, OAuth, and horizontal scaling.
- [Connecting and Governing MCP Servers: Registries, Gateways, and Tool Sprawl](https://agentscamp.com/guides/mcp/govern-mcp-servers.md): As MCP servers multiply, discovery, trust, and tool sprawl become the problem. How registries, gateways, and curation keep a growing fleet secure and usable.
- [MCP Ecosystem Statistics 2026](https://agentscamp.com/guides/mcp/mcp-ecosystem-statistics.md): The Model Context Protocol by the numbers — SDK downloads, server counts across registries, governance facts, and growth since the Linux Foundation donation.
- [MCP vs A2A: AI Agent Protocols Explained](https://agentscamp.com/guides/mcp/mcp-vs-a2a.md): What MCP and A2A each standardize, how Agent Cards and Tasks work, why the two protocols are complementary, and who governs them now (both Linux Foundation).
- [Deploying LLMs to Production: A Reliability & Cost Checklist](https://agentscamp.com/guides/mlops/deploying-llms-to-production.md): Take an LLM feature from prototype to production: API vs self-host, provider fallback, retries, caching, observability, eval gates, and safe rollout.
- [Preparing a Fine-Tuning Dataset: Cleaning, Synthetic Data, and Eval Splits](https://agentscamp.com/guides/mlops/finetune-dataset-prep.md): The dataset is the model. How to build a fine-tuning dataset that works — format, curation, cleaning, synthetic augmentation, and a leak-free eval split.
- [Fine-Tune vs RAG vs Prompt vs Distill: The 2026 Decision Tree](https://agentscamp.com/guides/mlops/finetune-vs-rag-vs-prompt.md): When to reach for prompt engineering, RAG, fine-tuning, or distillation — what each actually changes, where each fails, and how to combine them.
- [Self-Host vs API: When Does Running Your Own LLM Actually Pay Off?](https://agentscamp.com/guides/mlops/self-host-vs-api-llm.md): The real economics of self-hosting an LLM vs. calling a hosted API — GPU utilization, privacy, latency, and the hidden ops costs that decide the crossover.
- [AI Coding Agents in 2026: The Open-Source & CLI Edition](https://agentscamp.com/guides/prompting/ai-coding-agents-cli-2026.md): Cursor and Windsurf vs the open-source agents — OpenCode, Cline, Aider, Codex CLI, and more. Who should bring their own model, and when to stay in the terminal.
- [Claude vs GPT vs Gemini for Coding in 2026](https://agentscamp.com/guides/prompting/claude-vs-gpt-vs-gemini-coding.md): The three frontier model families compared for real coding work — agentic depth, ecosystem fit, context, and cost shape — plus how to actually choose.
- [Context Engineering](https://agentscamp.com/guides/prompting/context-engineering.md): Treating the context window as a finite budget — what to load, what to leave out, and when to reset.
- [Cursor vs Claude Code vs GitHub Copilot vs Windsurf in 2026](https://agentscamp.com/guides/prompting/cursor-vs-claude-code-vs-copilot-vs-windsurf-2026.md): A practical, opinionated comparison of the four mainstream AI coding tools — form factor, agentic depth, model choice, and who each one is for.
- [Designing System Prompts for LLM Apps and Agents](https://agentscamp.com/guides/prompting/designing-system-prompts.md): How to write system prompts that hold up in production: what belongs there vs. the user turn, structure that survives long context, and format/refusal rules.
- [Programmatic Prompt Optimization with DSPy: Stop Hand-Tuning Prompts](https://agentscamp.com/guides/prompting/dspy-prompt-optimization.md): Hand-tuning prompts doesn't scale. DSPy treats prompting as programming — declare tasks as typed signatures and let an optimizer compile the prompts for you.
- [Effective Tool Use: Scoping an Agent's Toolset](https://agentscamp.com/guides/prompting/effective-tool-use.md): How to scope tools and permissions so an agent reaches for the right one and can't do damage.
- [Prompt Patterns for Coding Agents](https://agentscamp.com/guides/prompting/prompt-patterns.md): Practical prompting patterns: chaining, few-shot, context management, tool use, and output structuring.
- [Few-Shot vs Chain-of-Thought vs Structured Prompting: What to Use When (2026)](https://agentscamp.com/guides/prompting/prompting-techniques-2026.md): When to reach for few-shot examples, chain-of-thought reasoning, or structured/output-constrained prompting — a 2026 decision guide to the core techniques.
- [Vibe Coding in 2026: What It Is, When It Works, When It Bites](https://agentscamp.com/guides/prompting/vibe-coding-guide.md): An honest guide to vibe coding — where prompt-and-accept development genuinely pays, where it accumulates risk, and the guardrails that make it professional.
- [The Agent Skills Standard: One SKILL.md for Every AI Tool](https://agentscamp.com/guides/skills/agent-skills-open-standard.md): Agent Skills became an open standard in December 2025. Which tools read SKILL.md today — Copilot, Cursor, VS Code, Gemini CLI, Codex — and how to write portable skills.
- [The Best Claude Skills to Install in 2026](https://agentscamp.com/guides/skills/best-claude-skills-2026.md): A skills-only tour of the AgentsCamp library — the Claude Code skills that earn a permanent slot, organized by the job they do.
- [Claude Code Skills: Best Practices](https://agentscamp.com/guides/skills/claude-code-skills-best-practices.md): The patterns that make Claude Code skills reliable: trigger-first descriptions, one job per skill, lean bodies, bundled scripts, and scoped tools.
- [Claude's Document Skills: Excel, PowerPoint, Word, and PDF](https://agentscamp.com/guides/skills/claude-document-skills.md): How Anthropic's pre-built document skills let Claude produce real .xlsx, .pptx, .docx, and PDF files — on claude.ai, the API, and in Claude Code.
- [Claude Skills Examples: Annotated SKILL.md Files](https://agentscamp.com/guides/skills/claude-skills-examples.md): Real SKILL.md examples you can copy — a minimal skill, a scoped-tools skill, a bundled-script skill — with the reasoning behind each line.
- [Claude Skills on claude.ai and the API](https://agentscamp.com/guides/skills/claude-skills-on-claude-ai-and-api.md): How Agent Skills work beyond Claude Code: uploading to claude.ai, the /v1/skills API with code execution, Managed Agents, and the Agent SDK.
- [Claude Skills Use Cases: 20 Ideas Worth Building](https://agentscamp.com/guides/skills/claude-skills-use-cases.md): Twenty concrete Claude skills use cases — for engineers, writers, analysts, and ops — with the pattern behind each and links to installable versions.
- [How to Install Claude Skills](https://agentscamp.com/guides/skills/how-to-install-claude-skills.md): Every way to install Claude skills: manual copy, the agentscamp CLI, GitHub repos, plugins, team distribution, and uploading to claude.ai.
- [Packaging and Sharing Claude Code Skills](https://agentscamp.com/guides/skills/packaging-and-sharing-skills.md): Take a skill from your personal ~/.claude folder to a versioned plugin your whole team installs from a marketplace — portably and with governance.
- [The SKILL.md Reference: Every Frontmatter Field Explained](https://agentscamp.com/guides/skills/skill-md-reference.md): A complete reference for the SKILL.md format — all frontmatter fields, naming rules, argument substitution, limits, and where skill files live.
- [Skills vs Agents vs Commands](https://agentscamp.com/guides/skills/skills-vs-agents-vs-commands.md): How Claude Code's two extension mechanisms — subagents and skills — differ across three invocation patterns, with a decision table for choosing the right one.
- [Skills vs MCP Servers: When to Use Which](https://agentscamp.com/guides/skills/skills-vs-mcp-servers.md): Skills inject procedure into context; MCP servers expose tools and live data over a protocol. A decision framework, the combine pattern, and examples.
- [Testing and Debugging Claude Code Skills](https://agentscamp.com/guides/skills/testing-and-debugging-skills.md): Verify a Claude Code skill triggers on the right prompts, check its output, and fix the five common failures — from vague triggers to broken paths.
- [What Are Claude Skills? The Complete Guide](https://agentscamp.com/guides/skills/what-are-claude-skills.md): Claude Skills explained: what a SKILL.md is, how progressive disclosure keeps skills cheap, where they run, and how to install or write your own.
- [Writing Your First Skill](https://agentscamp.com/guides/skills/writing-your-first-skill.md): A step-by-step guide to packaging a reusable procedure as a Claude Code skill that loads exactly when it's needed.
- [TDD with AI Agents: Red-Green as an Agent Loop](https://agentscamp.com/guides/testing/tdd-with-ai-agents.md): Test-driven development found its killer app: agents. How write-the-test-first turns AI coding into a verifiable loop, and the workflow that makes it stick.
- [How to Test AI-Generated Code](https://agentscamp.com/guides/testing/testing-ai-generated-code.md): AI writes the code; tests decide whether to trust it. The verification stack for agent-written changes — contracts, generated tests, and the review that's left.
- [Testing LLM Applications: How to Test Non-Deterministic Software](https://agentscamp.com/guides/testing/testing-llm-applications.md): How to test software that calls LLMs when outputs are non-deterministic — the testing pyramid, assertion strategies, golden datasets, and CI gating.
- [Claude Code Troubleshooting: Fixes for the Most Common Problems](https://agentscamp.com/guides/troubleshooting/claude-code-troubleshooting.md): Fixes for the Claude Code problems people actually hit — install and auth failures, context-limit errors, MCP servers that won't connect, permission loops.
- [Claude Skills Not Working? Fixes for Every Failure Mode](https://agentscamp.com/guides/troubleshooting/claude-skills-not-working.md): Skill missing from the / menu, never auto-triggering, firing too often, or breaking mid-run — the symptom-by-symptom fix list for Claude skills.
- [Why Your Agent Loops: Debugging AI Agents](https://agentscamp.com/guides/troubleshooting/debugging-ai-agents.md): The recurring agent failure modes — loops, premature victory, tool misuse, context poisoning, scope creep — diagnosed by their signatures, with fixes.
- [MCP Troubleshooting: Server Won't Connect & Other Fixes](https://agentscamp.com/guides/troubleshooting/mcp-troubleshooting.md): Fixes for the MCP problems people actually hit — servers failing to connect, missing tools, OAuth loops, timeouts, truncated output, and Windows quirks.
- [Why RAG Fails: A Debugging Checklist](https://agentscamp.com/guides/troubleshooting/rag-debugging-checklist.md): A diagnostic checklist for broken RAG — localize the failure to ingestion, retrieval, ranking, or generation, and apply the fix that matches, in order.
- [Add Image Understanding to Your App](https://agentscamp.com/guides/vision/add-image-understanding-to-your-app.md): A practical guide to sending images to a vision model and getting reliable, structured results: base64 vs URL, resolution, prompting, cost, and errors.
- [Multimodal Embeddings and Image Search](https://agentscamp.com/guides/vision/multimodal-embeddings-and-image-search.md): How multimodal embeddings put images and text in one vector space, and how to build text-to-image and image-to-image search on top of it.
- [Multimodal RAG over PDFs, Scans & Charts: Two Approaches That Actually Work](https://agentscamp.com/guides/vision/multimodal-rag-images-pdfs.md): RAG over visual documents — PDFs, scans, charts — where text-only extraction loses tables and layout. Parse-then-text vs embed-the-page-image, with trade-offs.
- [Screenshot-to-Code: Building UIs from Images with AI](https://agentscamp.com/guides/vision/screenshot-to-code-with-ai.md): Turn a screenshot, mockup, or Figma frame into working frontend code with AI vision models — the realistic workflow, the right tools, and the honest pitfalls.
- [Vision-Language Models Compared (2026)](https://agentscamp.com/guides/vision/vision-language-models-compared-2026.md): Which vision-language model to reach for, by job: Claude, GPT, Gemini, and open models like Qwen3-VL compared on OCR, charts, grounding, video, and cost.
- [Using Vision-Language Models for OCR, Documents, and Video Understanding](https://agentscamp.com/guides/vision/vlm-ocr-documents.md): How to use vision-language models for OCR, documents, and video: how they differ from traditional OCR, their failure modes, and getting reliable output.
- [Best Speech-to-Text APIs in 2026](https://agentscamp.com/guides/voice/best-stt-apis-2026.md): The STT field, honestly ranked — Deepgram and AssemblyAI's hosted duel, Whisper as the open baseline, Cartesia Ink for latency — and how to pick by workload.
- [Best Text-to-Speech APIs in 2026](https://agentscamp.com/guides/voice/best-tts-apis-2026.md): The TTS APIs worth building on — ElevenLabs for quality and breadth, Cartesia Sonic for realtime latency — and how to choose for agents vs produced audio.
- [How to Build a Voice Agent: The STT → LLM → TTS Pipeline](https://agentscamp.com/guides/voice/build-a-voice-agent.md): How to build a real-time voice agent: the STT → LLM → TTS pipeline, the latency budget that makes or breaks it, and how to wire each stage.
- [Realtime Voice Agents: Build on LiveKit, Buy Vapi, or Pipeline with Pipecat](https://agentscamp.com/guides/voice/realtime-voice-apis.md): The three ways to ship a realtime voice agent in 2026 — open infrastructure, managed platform, or OSS pipeline — and how speech-to-speech models fit in.
- [An AI Code Review Workflow That Actually Catches Bugs](https://agentscamp.com/guides/workflow/ai-code-review-workflow.md): Layer the review stack — self-review, AI reviewers, tests, and a human pass focused on what machines miss — into a workflow tuned for AI-written code.
- [Human-in-the-Loop AI Workflows: Approval Gates That Keep Agents Safe and Trusted](https://agentscamp.com/guides/workflow/human-in-the-loop-ai-workflows.md): How to design human-in-the-loop into agent workflows — when to require approval, gate patterns, confidence escalation, review UX, and feedback loops.
- [Spec-Driven Development with AI Agents](https://agentscamp.com/guides/workflow/spec-driven-development.md): Write the spec, let the agent implement against it — the SDD workflow (spec → plan → tasks → implement), when it beats prompt-and-iterate, and the tooling.

## Tools

A curated directory of AI coding tools, editors, agents, and MCP servers.

- [AgentOps](https://agentscamp.com/tools/agentops.md): Observability for AI agents — session replay, cost and latency tracking, and debugging for multi-step runs.
- [Agno](https://agentscamp.com/tools/agno.md): A Python framework for building multi-agent systems with memory, knowledge, and tools — formerly Phidata, now with the AgentOS runtime.
- [Aider](https://agentscamp.com/tools/aider.md): Open-source terminal AI pair programmer that edits files in your Git repo and auto-commits each change, working with Claude, GPT, and other models you bring.
- [Amp](https://agentscamp.com/tools/amp.md): Sourcegraph's agentic coding tool — a CLI and editor extensions tuned for frontier-model coding.
- [Google Antigravity](https://agentscamp.com/tools/antigravity.md): Google's agentic development platform — an agent-first IDE and Manager surface where multiple agents work across editor, terminal, and browser, on Gemini 3.
- [Arize Phoenix](https://agentscamp.com/tools/arize-phoenix.md): An open-source LLM observability and evaluation tool built on OpenTelemetry, runnable anywhere.
- [Assemblyai](https://agentscamp.com/tools/assemblyai.md): Speech AI platform: promptable Universal-3 Pro STT, a flat-rate Voice Agent API, and speech understanding — summarization, sentiment, PII redaction.
- [Augment Code](https://agentscamp.com/tools/augment-code.md): AI coding assistant built for large, real-world codebases — a Context Engine that indexes the whole repo, with agents, chat, and completions in IDEs and a CLI.
- [AutoGen (AG2)](https://agentscamp.com/tools/autogen.md): A multi-agent conversation framework where agents collaborate via message-passing, with group chat and code execution.
- [BAML](https://agentscamp.com/tools/baml.md): A domain-specific language for type-safe LLM functions, with generated clients and schema-aligned parsing.
- [Baseten](https://agentscamp.com/tools/baseten.md): Production inference platform for ML and LLM models — autoscaling GPU deployments, scale-to-zero, and packaging via the open-source Truss framework.
- [Bolt](https://agentscamp.com/tools/bolt.md): StackBlitz's in-browser AI agent that builds, runs, and deploys full-stack web apps in a WebContainer.
- [Braintrust](https://agentscamp.com/tools/braintrust.md): An end-to-end platform for evaluating, iterating on, and observing LLM apps, with a prompt playground.
- [Browser Use](https://agentscamp.com/tools/browser-use.md): The most-adopted open-source browser-agent framework — point an LLM at a task and it drives a real browser: navigating, clicking, typing, extracting.
- [Browserbase](https://agentscamp.com/tools/browserbase.md): Managed headless-browser infrastructure for AI agents and web automation — serverless cloud browsers with stealth, proxies, live view, and Playwright/Stagehand.
- [Cartesia](https://agentscamp.com/tools/cartesia.md): Real-time voice AI on state-space models — Sonic streaming TTS, Ink STT with native turn detection, and Line, a code-first voice-agent platform.
- [Chonkie](https://agentscamp.com/tools/chonkie.md): A lightweight, fast chunking library for RAG with many splitting strategies in one API.
- [Chroma](https://agentscamp.com/tools/chroma.md): An open-source, Python-first vector database that runs in-process — the fastest path from pip install to a working retrieval prototype.
- [Chrome DevTools MCP](https://agentscamp.com/tools/chrome-devtools-mcp.md): Google's official MCP server that gives coding agents a live Chrome — Puppeteer automation plus DevTools network, console, and performance insights.
- [Claude Agent SDK](https://agentscamp.com/tools/claude-agent-sdk.md): A toolkit for building custom agents on the same harness that powers Claude Code.
- [Claude Code](https://agentscamp.com/tools/claude-code.md): Anthropic’s official agentic coding tool that runs in the terminal, IDE, and web.
- [Cline](https://agentscamp.com/tools/cline.md): Open-source autonomous coding agent for VS Code that plans, edits files, and runs commands with diff approval, using any model you bring or a local runtime.
- [Cloudflare MCP](https://agentscamp.com/tools/cloudflare-mcp.md): Cloudflare's official MCP servers — a Code Mode server covering 2,500 API endpoints in ~1k tokens, plus hosted servers for docs, Workers, and observability.
- [Coderabbit](https://agentscamp.com/tools/coderabbit.md): An AI code reviewer that posts line-by-line feedback and summaries on every pull request.
- [Codex CLI](https://agentscamp.com/tools/codex-cli.md): OpenAI's open-source terminal coding agent with sandboxed execution and two-layer approval controls.
- [Cody](https://agentscamp.com/tools/cody.md): Sourcegraph's AI coding assistant for the IDE, grounded in deep codebase context.
- [Cohere Rerank](https://agentscamp.com/tools/cohere-rerank.md): A hosted reranking API that reorders retrieved passages by true relevance to a query.
- [Context7](https://agentscamp.com/tools/context7.md): Upstash's MCP server that pulls up-to-date, version-specific library documentation into your agent's context — the cure for hallucinated APIs.
- [Continue](https://agentscamp.com/tools/continue.md): An open-source IDE extension for building custom AI coding assistants.
- [CrewAI](https://agentscamp.com/tools/crewai.md): A Python framework for orchestrating role-playing AI agents as collaborating 'crews', plus event-driven flows.
- [Cursor](https://agentscamp.com/tools/cursor.md): An AI-first code editor built on VS Code with deep in-editor agent features, parallel agents, in-house Composer models, and a plugin marketplace.
- [Daytona](https://agentscamp.com/tools/daytona.md): Sub-90ms agent sandboxes — isolated computers with snapshots, volumes, Git and LSP tools, on Linux, Windows, or Android; AGPL self-host or managed cloud.
- [DeepEval](https://agentscamp.com/tools/deepeval.md): An open-source evaluation framework for LLM apps — 'Pytest for LLMs' with ready-made metrics and CI integration.
- [Deepgram](https://agentscamp.com/tools/deepgram.md): A voice-AI platform with fast, accurate speech-to-text (Nova) and low-latency text-to-speech (Aura), plus a bundled Voice Agent API.
- [Devin](https://agentscamp.com/tools/devin.md): Cognition's autonomous AI software engineer that works in its own cloud workspace with an editor, terminal, and browser.
- [Dify](https://agentscamp.com/tools/dify.md): The visual platform for LLM apps and agentic workflows — canvas-built chatflows, RAG pipeline, agent nodes with 50+ tools, and LLMOps, self-hosted via Docker.
- [Docling](https://agentscamp.com/tools/docling.md): Open-source Python library that parses PDFs, DOCX, PPTX, HTML, and images into structured Markdown and JSON with layout, tables, and reading order for RAG.
- [DSPy](https://agentscamp.com/tools/dspy.md): Program language models instead of prompting them: declare tasks as typed signatures and let optimizers compile the prompts and few-shot examples for you.
- [E2b](https://agentscamp.com/tools/e2b.md): Open-source Firecracker-microVM sandboxes where AI agents safely run untrusted code — stateful interpreters, full Linux, pause/resume, desktop VMs.
- [ElevenLabs](https://agentscamp.com/tools/elevenlabs.md): A voice-AI platform for high-quality text-to-speech, voice cloning, dubbing, and real-time conversational agents, via API.
- [Exa](https://agentscamp.com/tools/exa.md): The search engine built for AIs — semantic web search, page contents, Websets, and research APIs, plus the ecosystem's most-used search MCP server.
- [Factory](https://agentscamp.com/tools/factory.md): Factory is an agent-native software development platform whose Droids plan, write, test, and ship code from the terminal, IDE, and web with org context.
- [fal](https://agentscamp.com/tools/fal.md): fal is a generative-media inference cloud for running image, video, and audio diffusion models fast — 1,000+ models, a simple API, and pay-per-use pricing.
- [FastMCP](https://agentscamp.com/tools/fastmcp.md): A Pythonic framework for building Model Context Protocol servers and clients — decorator-based tools, resources, and prompts, with auth and deployment built in.
- [Figma MCP](https://agentscamp.com/tools/figma-mcp.md): Figma's official MCP server — structured design context, variables, screenshots, and Code Connect mappings for agents, plus write-back to the canvas.
- [Firecrawl](https://agentscamp.com/tools/firecrawl.md): The API to search, scrape, and crawl the web for AI — clean Markdown out of any site, LLM-powered extraction, and a first-class MCP server.
- [Fireworks AI](https://agentscamp.com/tools/fireworks-ai.md): Fast production inference for open models — serverless and dedicated GPU deployments, fine-tuning, and an OpenAI-compatible API on the FireAttention engine.
- [Flowise](https://agentscamp.com/tools/flowise.md): Open-source, low-code visual builder for LLM apps and AI agents — drag-and-drop to assemble chains, agents, and RAG; self-host or use Flowise Cloud.
- [Gemini CLI](https://agentscamp.com/tools/gemini-cli.md): Google's open-source terminal AI agent powered by Gemini models, with a 1M-token context window and built-in tools.
- [Github Copilot](https://agentscamp.com/tools/github-copilot.md): GitHub’s AI pair programmer with inline completions and an agent mode.
- [Github MCP Server](https://agentscamp.com/tools/github-mcp-server.md): GitHub's official MCP server — repos, issues, PRs, Actions, and security data for your agent, as a free hosted remote or a local Docker server.
- [Google ADK](https://agentscamp.com/tools/google-adk.md): Google's open-source, code-first framework to build, evaluate, and deploy AI agents. Python and Java, model-agnostic, deploys to Vertex AI Agent Engine.
- [Goose](https://agentscamp.com/tools/goose.md): Block's open-source, on-machine AI agent that is MCP-native and model-agnostic, with a CLI and desktop app.
- [Greptile](https://agentscamp.com/tools/greptile.md): An AI code review agent that reviews pull requests with full-codebase context — catching multi-file logical bugs and learning your team's standards.
- [Groq](https://agentscamp.com/tools/groq.md): GroqCloud runs open-weight LLMs on custom LPU hardware for very fast, low-latency inference through an OpenAI-compatible API.
- [Helicone](https://agentscamp.com/tools/helicone.md): Open-source LLM observability and AI gateway with one-line integration — logging, tracing, caching, and cost/latency tracking across providers.
- [Instructor](https://agentscamp.com/tools/instructor.md): Get structured, validated output from LLMs using plain type definitions, with automatic retries on validation failure.
- [Jan](https://agentscamp.com/tools/jan.md): An open-source ChatGPT alternative that runs fully offline — a polished desktop app over llama.cpp with a model hub, MCP support, and a local API server.
- [Jina Reader](https://agentscamp.com/tools/jina-reader.md): Prepend r.jina.ai/ to any URL and get LLM-ready markdown — JS rendering, PDFs and Office docs, image captioning, and s.jina.ai for read-the-results search.
- [Kilo Code](https://agentscamp.com/tools/kilo-code.md): Open-source AI coding agent extension for VS Code and JetBrains, built as a superset of Roo Code and Cline, with bring-your-own-key and zero model markup.
- [LanceDB](https://agentscamp.com/tools/lancedb.md): An open-source embedded vector database built on the Lance columnar format — serverless, multimodal, and designed to scale on local disk or object storage.
- [Langchain](https://agentscamp.com/tools/langchain.md): The provider-agnostic agent framework, post-1.0: a standard create_agent loop on the LangGraph runtime, middleware hooks, and the largest integration ecosystem.
- [Langfuse](https://agentscamp.com/tools/langfuse.md): An open-source LLM engineering platform for tracing, evals, prompt management, and metrics.
- [LangGraph](https://agentscamp.com/tools/langgraph.md): A low-level library for building stateful, controllable agents as graphs, with checkpointing and human-in-the-loop.
- [LangSmith](https://agentscamp.com/tools/langsmith.md): LangChain's platform for tracing, evaluating, and monitoring LLM apps — framework-agnostic.
- [Letta](https://agentscamp.com/tools/letta.md): Stateful agents from the MemGPT creators — an Apache-2.0 server with self-editing memory, and Letta Code, the memory-first model-agnostic coding harness.
- [Linear MCP](https://agentscamp.com/tools/linear-mcp.md): Linear's hosted MCP server — find, create, and update issues, projects, and comments from your AI agent, with OAuth and one-command setup.
- [LiteLLM](https://agentscamp.com/tools/litellm.md): Call 100+ LLM APIs with one OpenAI-format interface — as a Python library or a self-hosted gateway/proxy.
- [Livekit](https://agentscamp.com/tools/livekit.md): Open-source realtime infrastructure — a WebRTC server plus the LiveKit Agents framework for production voice AI, with turn detection, telephony, and cloud.
- [Llama Cpp](https://agentscamp.com/tools/llama-cpp.md): The C/C++ inference engine that made local LLMs possible — GGUF quantization, every GPU backend, and an OpenAI-compatible server, with no dependencies.
- [Llamaindex](https://agentscamp.com/tools/llamaindex.md): The data framework for LLM apps — ingestion, indexing, query engines, and document agents — now centered on document processing with LlamaParse and LlamaCloud.
- [LlamaParse](https://agentscamp.com/tools/llamaparse.md): Hosted document-parsing API from LlamaIndex that turns complex PDFs — tables, charts, figures, handwriting — into clean, LLM-ready Markdown for RAG.
- [LLM Guard](https://agentscamp.com/tools/llm-guard.md): An open-source security toolkit of input and output scanners for LLM apps — prompt injection, PII/anonymize, secrets, toxicity, and more, from Protect AI.
- [LM Studio](https://agentscamp.com/tools/lm-studio.md): A desktop app for discovering, downloading, and running open-weight LLMs locally with a GUI and a local OpenAI-compatible server.
- [Lovable](https://agentscamp.com/tools/lovable.md): An AI app builder that turns natural-language prompts into shippable full-stack web apps.
- [Marker](https://agentscamp.com/tools/marker.md): Open-source pipeline that converts PDFs, images, and Office docs into clean Markdown, JSON, or HTML fast, with optional LLM assist for tables and equations.
- [Mastra](https://agentscamp.com/tools/mastra.md): An open-source TypeScript framework for building AI agents, workflows, RAG, and tool-calling, with memory, model routing, and built-in observability.
- [MCP Inspector](https://agentscamp.com/tools/mcp-inspector.md): The official open-source visual tool for testing and debugging Model Context Protocol servers — connect, list, and call tools, resources, and prompts.
- [Mem0](https://agentscamp.com/tools/mem0.md): A memory layer for AI agents and apps — persistent, personalized long-term memory across sessions.
- [Milvus](https://agentscamp.com/tools/milvus.md): An open-source vector database built for billion-scale similarity search, with a distributed architecture and a wide menu of index types.
- [Modal](https://agentscamp.com/tools/modal.md): Serverless AI infrastructure in pure Python — GPU functions with sub-second cold starts, secure sandboxes for agent code, batch jobs, and per-second billing.
- [N8n](https://agentscamp.com/tools/n8n.md): Fair-code workflow automation with native AI: a visual canvas plus code, 400+ integrations, and LangChain agent nodes; self-host free or cloud per-run.
- [NeMo Guardrails](https://agentscamp.com/tools/nemo-guardrails.md): NVIDIA's open-source toolkit for adding programmable guardrails to LLM apps — input, dialog, retrieval, and output rails defined in the Colang language.
- [Notion MCP](https://agentscamp.com/tools/notion-mcp.md): Notion's hosted MCP server — search the workspace, fetch and create pages and databases, and manage comments through Markdown-optimized agent tools.
- [Ollama](https://agentscamp.com/tools/ollama.md): An open-source tool to run open-weight LLMs locally with a single command, including a local OpenAI-compatible API.
- [OpenAI Agents SDK](https://agentscamp.com/tools/openai-agents-sdk.md): OpenAI's lightweight, open-source framework for agents — handoffs, guardrails, sessions, and built-in tracing.
- [Opencode](https://agentscamp.com/tools/opencode.md): The open-source AI coding agent — a terminal TUI from Anomaly with 75+ model providers, LSP-powered context, parallel agents, and shareable sessions.
- [OpenHands](https://agentscamp.com/tools/openhands.md): Open-source autonomous AI software-development agent (formerly OpenDevin) — writes code, runs commands, and browses the web in a sandbox.
- [OpenRouter](https://agentscamp.com/tools/openrouter.md): A hosted unified API to hundreds of models from many providers, with one key, one bill, and automatic fallbacks.
- [pgroll](https://agentscamp.com/tools/pgroll.md): An open-source CLI for zero-downtime, reversible Postgres schema migrations using the expand-contract pattern behind versioned schema views.
- [pgvector](https://agentscamp.com/tools/pgvector.md): An open-source Postgres extension that adds a vector type and HNSW/IVFFlat indexes for similarity search inside your existing database.
- [Pinecone](https://agentscamp.com/tools/pinecone.md): A fully managed, serverless vector database for similarity search and RAG — no nodes to run, indexes to tune, or infrastructure to operate.
- [Pipecat](https://agentscamp.com/tools/pipecat.md): An open-source Python framework for real-time voice and multimodal conversational AI — it orchestrates streaming STT, LLM, and TTS into composable pipelines.
- [Playwright MCP](https://agentscamp.com/tools/playwright-mcp.md): Microsoft's open-source MCP server that gives AI agents structured browser automation via Playwright's accessibility tree.
- [Portkey](https://agentscamp.com/tools/portkey.md): An AI gateway and LLMOps platform: route to many LLMs through one API with caching, retries, fallbacks, load balancing, guardrails, and full observability.
- [Postgres MCP Pro](https://agentscamp.com/tools/postgres-mcp.md): The maintained Postgres MCP server — safe SQL execution, EXPLAIN with hypothetical indexes, workload-driven index tuning, and database health checks.
- [promptfoo](https://agentscamp.com/tools/promptfoo.md): An open-source CLI for testing, comparing, and red-teaming LLM prompts, models, and apps.
- [Pydantic AI](https://agentscamp.com/tools/pydantic-ai.md): Type-safe agent framework from the Pydantic team: validated structured outputs, dependency injection, durable execution, 'that FastAPI feeling.'
- [Qdrant](https://agentscamp.com/tools/qdrant.md): An open-source vector database written in Rust, built for low-latency similarity search at scale.
- [Qodo](https://agentscamp.com/tools/qodo.md): A quality-first AI code review platform (ex-CodiumAI) — multi-agent PR review with your team's rules, plus IDE, CLI, and codebase-intelligence products.
- [Qwen3-VL](https://agentscamp.com/tools/qwen3-vl.md): Alibaba Qwen's open-weights vision-language model family (2B–235B, Apache-2.0): image and document understanding, OCR, visual reasoning, and video.
- [RAGAS](https://agentscamp.com/tools/ragas.md): An open-source framework for evaluating retrieval-augmented generation with reference-free RAG metrics.
- [Reducto](https://agentscamp.com/tools/reducto.md): High-accuracy document ingestion API — parsing, agentic OCR, table and figure extraction, and splitting that turns messy PDFs into LLM-ready data for RAG.
- [Replicate](https://agentscamp.com/tools/replicate.md): Run and deploy any open ML model — LLMs, image, video, audio — through one API with pay-per-second billing, and package your own with open-source Cog.
- [Replit Agent](https://agentscamp.com/tools/replit-agent.md): Replit's AI agent that builds, runs, and deploys full-stack apps from a prompt inside the Replit cloud IDE.
- [Roo Code](https://agentscamp.com/tools/roo-code.md): A discontinued open-source VS Code agent (a Cline fork); the team has since pivoted away from the IDE extension.
- [Sentry MCP](https://agentscamp.com/tools/sentry-mcp.md): Sentry's hosted MCP service for debugging — pull issues, events, traces, and releases into your agent, and trigger Seer root-cause analysis.
- [Sequential Thinking MCP](https://agentscamp.com/tools/sequential-thinking-mcp.md): The official MCP reference server for structured reasoning — a sequential_thinking tool that lets agents decompose, revise, and branch their thinking.
- [Serena](https://agentscamp.com/tools/serena.md): An MCP toolkit that gives coding agents IDE-grade powers — symbol-level retrieval and editing via language servers, across 40+ languages.
- [Skyvern](https://agentscamp.com/tools/skyvern.md): Open-source vision + LLM browser automation aimed at replacing brittle RPA — workflow builder, CAPTCHA/2FA handling, and self-host or cloud.
- [Slack MCP Server](https://agentscamp.com/tools/slack-mcp.md): The community-canonical Slack MCP server — smart history fetch, message search, channels, reactions, and opt-in posting, after the official server was archived.
- [Smithery](https://agentscamp.com/tools/smithery.md): A registry and hosting platform for Model Context Protocol servers — discover, deploy, and connect MCP servers from one place.
- [Spec Kit](https://agentscamp.com/tools/spec-kit.md): GitHub's open-source toolkit for spec-driven development — a specify CLI and /speckit slash commands that walk any coding agent from spec to implementation.
- [Stagehand](https://agentscamp.com/tools/stagehand.md): Browserbase's open-source SDK for browser agents — act, extract, observe, and agent primitives that mix natural language with code-level control.
- [Stripe MCP](https://agentscamp.com/tools/stripe-mcp.md): Stripe's official MCP server — customers, invoices, payment links, subscriptions, refunds, and docs search for agents, hosted at mcp.stripe.com.
- [Supabase MCP](https://agentscamp.com/tools/supabase-mcp.md): Supabase's official MCP server — run SQL and migrations, read logs and advisors, generate types, and deploy Edge Functions, with read-only and project scoping.
- [Swe Agent](https://agentscamp.com/tools/swe-agent.md): Open-source autonomous coding agent from Princeton/Stanford that turns an LLM into a software engineer to fix real GitHub issues.
- [Tabby](https://agentscamp.com/tools/tabby.md): Self-hosted, open-source AI coding assistant by TabbyML — run your own completion and chat models on your infrastructure, with IDE extensions.
- [Tabnine](https://agentscamp.com/tools/tabnine.md): An AI code completion and chat assistant built around code privacy, self-hosting, and air-gapped enterprise deployment.
- [Tavily](https://agentscamp.com/tools/tavily.md): The web-access layer for agents — Search, Extract, Crawl, Map, and Research APIs purpose-built for LLMs, behind one key, with a hosted MCP server.
- [Together AI](https://agentscamp.com/tools/together-ai.md): A cloud for running, fine-tuning, and deploying open-source models (Llama, DeepSeek, Qwen) via an OpenAI-compatible API plus dedicated GPU endpoints.
- [Trae](https://agentscamp.com/tools/trae.md): Trae is an AI-native IDE from ByteDance — a VS Code-style editor with a built-in Builder agent and an autonomous SOLO mode that writes code across a project.
- [turbopuffer](https://agentscamp.com/tools/turbopuffer.md): A serverless vector and full-text search database built on object storage (S3/GCS/Azure) — usage-based pricing, hybrid search, and low cost per GB at scale.
- [Unsloth](https://agentscamp.com/tools/unsloth.md): An open-source library that makes LoRA/QLoRA fine-tuning of LLMs roughly 2x faster and far more memory-efficient, so you can fine-tune on a single GPU.
- [Unstructured](https://agentscamp.com/tools/unstructured.md): Open-source library plus hosted Platform/API that turns messy documents — PDF, HTML, docx, images, email — into clean, chunked JSON for LLMs and RAG.
- [V0](https://agentscamp.com/tools/v0.md): Vercel's generative UI builder that turns prompts into production-ready React, Next.js, and shadcn/ui apps.
- [Vapi](https://agentscamp.com/tools/vapi.md): The API-first voice-agent platform — assemble phone and web agents from any STT/LLM/TTS mix, with telephony, squads, and tool calling handled for you.
- [Vercel AI SDK](https://agentscamp.com/tools/vercel-ai-sdk.md): An open-source TypeScript toolkit for building AI apps — unified model API, streaming, structured output, tool calling, and UI hooks.
- [Vercel Sandbox](https://agentscamp.com/tools/vercel-sandbox.md): Ephemeral Firecracker microVMs on Vercel for untrusted and AI-generated code — millisecond startup, Node and Python runtimes, persistent by default.
- [vLLM](https://agentscamp.com/tools/vllm.md): A high-throughput, memory-efficient inference and serving engine for LLMs, with PagedAttention, continuous batching, and an OpenAI-compatible API server.
- [Void — Open-Source AI Code Editor (VS Code Fork)](https://agentscamp.com/tools/void.md): Open-source AI code editor forked from VS Code, an alternative to Cursor that connects directly to your chosen model with no proprietary backend.
- [Voyage AI](https://agentscamp.com/tools/voyage-ai.md): Embedding and reranking models tuned for retrieval, now part of MongoDB.
- [Warp](https://agentscamp.com/tools/warp.md): A modern, AI-powered terminal with an agent mode that can run and chain commands across your codebase.
- [Wave Terminal](https://agentscamp.com/tools/wave-terminal.md): Open-source terminal that blends the CLI with inline file previews, a built-in editor, a web browser, and a context-aware AI assistant in one window.
- [Weaviate](https://agentscamp.com/tools/weaviate.md): An open-source vector database with built-in hybrid search, pluggable vectorizer modules, and GraphQL/REST/gRPC APIs.
- [Whisper](https://agentscamp.com/tools/whisper.md): OpenAI's open-weights speech-to-text — the MIT-licensed multilingual model family that made self-hosted transcription a default, with a huge ecosystem.
- [Devin Desktop (formerly Windsurf)](https://agentscamp.com/tools/windsurf.md): An agentic IDE — formerly Windsurf, now Devin Desktop from Cognition AI — with flows that take multi-step actions across your codebase.
- [Zed](https://agentscamp.com/tools/zed.md): A high-performance, multiplayer code editor with built-in AI assistance.
- [Zep](https://agentscamp.com/tools/zep.md): Agent memory on temporal knowledge graphs — Zep Cloud for sub-200ms context retrieval at enterprise scale, with Graphiti as its open-source graph engine.

## Commands

Reusable slash commands that automate repeatable workflows in Claude Code.

- [Audit Accessibility](https://agentscamp.com/commands/analyze/audit-accessibility.md): Audit a component or page for accessibility against WCAG — semantics, names, keyboard, ARIA, contrast, forms, motion.
- [Explain Error](https://agentscamp.com/commands/analyze/explain-error.md): Diagnose an error message or stack trace and propose a fix.
- [Trace Data Flow](https://agentscamp.com/commands/analyze/trace-data-flow.md): Trace how a value, field, or variable flows through the codebase from source to sink.
- [DB Migrate](https://agentscamp.com/commands/db/db-migrate.md): Generate and apply a database migration the safe way — using the project's migration tool, with expand-contract discipline for breaking changes, lock-free DDL, and a reversible up/down.
- [Scaffold a pgvector Schema & HNSW Index](https://agentscamp.com/commands/db/scaffold-pgvector-schema.md): Scaffold a production-ready pgvector schema and HNSW index for a corpus — matching the project's migration tooling, distance metric, and embedding dimensions.
- [Seed Data](https://agentscamp.com/commands/db/seed-data.md): Generate realistic, referentially-consistent seed data and a re-runnable seed script from your actual schema — types and constraints respected, plausible values, FK-dependency insert order, idempotent, never aimed at production.
- [Add Docstrings](https://agentscamp.com/commands/docs/add-docstrings.md): Add or improve docstrings for the public API of a file or symbol.
- [Explain Code](https://agentscamp.com/commands/docs/explain-code.md): Explain what the given code does, in clear prose with a short summary.
- [Update README](https://agentscamp.com/commands/docs/update-readme.md): Update the README to reflect the current scripts, structure, and features of the repo.
- [Clean Branches](https://agentscamp.com/commands/git/clean-branches.md): Safely prune merged and stale Git branches: drop dead remote-tracking refs, list merged candidates for review, then delete with the safe -d variant.
- [Commit](https://agentscamp.com/commands/git/commit.md): Stage changes and write a Conventional Commits message describing them.
- [Create PR](https://agentscamp.com/commands/git/create-pr.md): Push the current branch and open a GitHub pull request with a generated title and body.
- [Git Bisect](https://agentscamp.com/commands/git/git-bisect.md): Drive git bisect to find the exact commit that introduced a regression.
- [Git Undo](https://agentscamp.com/commands/git/git-undo.md): Safely reverse the last Git operation in the current repo — pick the right tool (restore, reset --soft/--mixed, revert, or reflog recovery) based on what happened and whether it was already pushed, and confirm before anything destructive.
- [Resolve Merge Conflicts](https://agentscamp.com/commands/git/resolve-conflict.md): Walk through resolving the in-progress merge, rebase, or cherry-pick conflict in the current repo by understanding both sides, then verify before continuing.
- [Sync Branch](https://agentscamp.com/commands/git/sync-branch.md): Fetch and rebase the current branch onto its base, resolving conflicts and verifying the build.
- [Add Caching](https://agentscamp.com/commands/perf/add-caching.md): Add a caching layer to one expensive function or endpoint correctly — confirm it's cacheable, design the cache key/TTL/layer/invalidation, handle stampedes, wrap the call in one place, and report the design.
- [Find N+1 Queries](https://agentscamp.com/commands/perf/find-n-plus-one.md): Scan code read-only for N+1 query patterns — loops that query per iteration and handlers that fan out per-row — and report each with a location, why it is N+1, and the concrete eager-load/batch/set-based fix.
- [Profile Postgres Queries](https://agentscamp.com/commands/perf/profile-postgres-queries.md): Profile a Postgres workload to find the queries actually costing you — rank by total time with pg_stat_statements, EXPLAIN the worst offenders, and recommend the highest-leverage fix.
- [Set Perf Budget](https://agentscamp.com/commands/perf/set-perf-budget.md): Define and enforce a cost and latency budget for an LLM feature or endpoint — set p95/p99 latency and cost-per-request ceilings, instrument to measure them against real traffic, and wire a check that fails when the budget is breached.
- [Breakdown Task](https://agentscamp.com/commands/plan/breakdown-task.md): Decompose a task into an ordered checklist of small, verifiable steps.
- [Estimate Effort](https://agentscamp.com/commands/plan/estimate-effort.md): Produce a grounded effort and complexity estimate for a task by exploring the codebase read-only.
- [Plan Feature](https://agentscamp.com/commands/plan/plan-feature.md): Explore the codebase and produce an implementation plan for a feature.
- [Write Design Doc](https://agentscamp.com/commands/plan/write-design-doc.md): Explore the codebase and write a decision-oriented design doc / RFC for a feature or system change.
- [Extract Function](https://agentscamp.com/commands/refactor/extract-function.md): Extract a code region into a well-named function and update the call site.
- [Optimize Imports](https://agentscamp.com/commands/refactor/optimize-imports.md): Remove unused imports and organize the rest in a file or directory per the project's conventions — preferring the project's own import tool where one is configured — without changing behavior.
- [Refactor](https://agentscamp.com/commands/refactor/refactor.md): Refactor the target for readability and structure without changing behavior.
- [Rename Symbol](https://agentscamp.com/commands/refactor/rename-symbol.md): Safely rename a symbol project-wide, distinguishing the real symbol from coincidental substring matches.
- [Benchmark Rerankers](https://agentscamp.com/commands/review/benchmark-rerankers.md): Measure whether adding a reranker actually improves retrieval, by scoring reranked vs. un-reranked results on a labeled query set.
- [Find Bug](https://agentscamp.com/commands/review/find-bug.md): Investigate a reported symptom, form hypotheses, and locate the root cause.
- [Red Team LLM](https://agentscamp.com/commands/review/red-team-llm.md): Red-team an LLM app or agent for prompt injection, jailbreaks, and data leakage — probe the real attack surface (input, RAG, tools, system prompt) with adversarial inputs and report what got through and how to fix it.
- [Review PR](https://agentscamp.com/commands/review/review-pr.md): Review a pull request for correctness, security, and style, and summarize findings.
- [Review Tests](https://agentscamp.com/commands/review/review-tests.md): Review the quality of a test suite, not just whether it passes — find weak assertions, missing edge cases, and tests coupled to implementation.
- [Security Scan](https://agentscamp.com/commands/review/security-scan.md): Scan the current diff or given paths for security vulnerabilities.
- [Add Human Approval Step](https://agentscamp.com/commands/scaffold/add-human-approval.md): Scaffold a human-in-the-loop approval gate into an agent so it pauses before a consequential action and resumes after approval.
- [Add a Streaming LLM Endpoint](https://agentscamp.com/commands/scaffold/add-streaming-endpoint.md): Scaffold a token-streaming LLM endpoint — server-side streaming plus the client handler — so responses render incrementally instead of after a long wait.
- [New Component](https://agentscamp.com/commands/scaffold/new-component.md): Scaffold a new UI component matching the project conventions.
- [Scaffold CLI Command](https://agentscamp.com/commands/scaffold/scaffold-cli.md): Scaffold a new subcommand for an existing CLI (or a minimal new CLI) in the project's language — flag/argument parsing, --help text, input validation, and correct exit codes — matching the framework and conventions already in use.
- [Scaffold Dockerfile](https://agentscamp.com/commands/scaffold/scaffold-dockerfile.md): Scaffold a production-grade multi-stage Dockerfile and .dockerignore for the current project.
- [Scaffold GitHub Action](https://agentscamp.com/commands/scaffold/scaffold-github-action.md): Scaffold a hardened GitHub Actions workflow for a stated goal, wired to the project's real test/lint/build commands.
- [Scaffold RAG Pipeline](https://agentscamp.com/commands/scaffold/scaffold-rag-pipeline.md): Scaffold a Retrieval-Augmented Generation pipeline — ingestion (load, chunk, embed, upsert) and retrieval (search, rerank, grounded prompt with citations) — fitted to the project's stack.
- [Scaffold a vLLM Serving Config](https://agentscamp.com/commands/scaffold/scaffold-vllm-config.md): Scaffold a vLLM serving config for a model on a target GPU — pick precision/quantization and parallelism to fit, set batching and context length, and expose an OpenAI-compatible server.
- [Fix Failing Test](https://agentscamp.com/commands/testing/fix-failing-test.md): Diagnose and fix a failing test by finding the real root cause.
- [Hunt Flaky Tests](https://agentscamp.com/commands/testing/flaky-test-hunt.md): Reproduce a flaky test, find the real source of nondeterminism, and fix the cause.
- [Generate E2E Test](https://agentscamp.com/commands/testing/generate-e2e-test.md): Scaffold a resilient end-to-end test for a user flow grounded in the real UI.
- [Run Evals](https://agentscamp.com/commands/testing/run-evals.md): Run the project's LLM evaluation suite (DeepEval, promptfoo, or RAGAS) and report scores against thresholds before a merge.
- [Write Tests](https://agentscamp.com/commands/testing/write-tests.md): Generate tests covering the happy path and edge cases for the given target.
- [Add MCP Server](https://agentscamp.com/commands/workflow/add-mcp-server.md): Add an MCP server to the current project the safe way — pick the transport and scope, wire secrets through env vars, vet provenance, and verify the connection before trusting it.
- [Create Skill](https://agentscamp.com/commands/workflow/create-skill.md): Scaffold a new Claude Code skill into .claude/skills/<name>/SKILL.md — a model-invoked capability with a trigger-rich description, scoped tools, and a lean body that pushes detail into resource files.
- [Create Slash Command](https://agentscamp.com/commands/workflow/create-slash-command.md): Scaffold a new Claude Code slash command into .claude/commands/ — a valid Markdown file with frontmatter, a least-privilege allowed-tools allowlist, and a $ARGUMENTS-driven body of numbered steps ending in a Report.
- [Create Subagent](https://agentscamp.com/commands/workflow/create-subagent.md): Scaffold a new Claude Code subagent definition file into .claude/agents/ with a routing-ready description, scoped tools, and a system prompt.
- [Setup Claude CI](https://agentscamp.com/commands/workflow/setup-claude-ci.md): Wire Claude Code into this repo's CI the safe way — install the GitHub App or scaffold the workflow YAML, scope permissions to the minimum, set secrets correctly, and verify with a real trigger.
- [Setup Pre-commit Hooks](https://agentscamp.com/commands/workflow/setup-precommit-hooks.md): Set up fast pre-commit hooks that catch problems before they land — detect the repo's existing stack and hook mechanism, run lint/format/typecheck plus a secret scan on staged files only, keep the slow test suite in CI, and make the setup reproducible for the whole team.

## Glossary

Plain-language definitions of the AI and LLM-engineering terms you'll meet across the hub — answer-first, with the deeper guide linked.

- [A2A (Agent2Agent Protocol)](https://agentscamp.com/glossary/a2a-protocol.md): A2A is an open protocol that lets AI agents discover each other's capabilities and delegate tasks across vendors, complementing MCP's tool connections.
- [Agent Engineering](https://agentscamp.com/glossary/agent-engineering.md): Agent engineering is the discipline of building reliable AI agents — designing the tools, context, guardrails, evals, and recovery paths around the model.
- [Agent Harness](https://agentscamp.com/glossary/agent-harness.md): An agent harness is the system around the model that makes it an agent — the loop, tools, context management, permissions, and recovery machinery.
- [Agent Memory](https://agentscamp.com/glossary/agent-memory.md): Agent memory is how an AI agent retains information beyond its context window — working state during a task and persistent knowledge across sessions.
- [Agent Skills](https://agentscamp.com/glossary/agent-skills.md): Agent Skills are reusable procedures packaged as folders with a SKILL.md file — loaded by an AI agent on demand when a task matches, now an open standard.
- [Agentic AI](https://agentscamp.com/glossary/agentic-ai.md): Agentic AI is the class of AI systems that act toward goals — planning, calling tools, and iterating on results — rather than only generating content.
- [AI Agent](https://agentscamp.com/glossary/ai-agent.md): An AI agent is an LLM-driven system that pursues a goal in a loop — calling tools, observing results, iterating — instead of returning one answer.
- [AI Slop](https://agentscamp.com/glossary/ai-slop.md): AI slop is low-effort, mass-produced AI-generated content — fluent, generic, and unchecked — flooding feeds, search results, and codebases.
- [Attention Mechanism](https://agentscamp.com/glossary/attention-mechanism.md): Attention lets a model weigh how relevant every other token is to each token, building a context-aware representation as a weighted blend of their values.
- [Batch Inference](https://agentscamp.com/glossary/batch-inference.md): Batch inference processes many LLM requests asynchronously instead of one-at-a-time interactively — typically at ~50% discount via provider batch APIs.
- [Chain-of-Thought (CoT)](https://agentscamp.com/glossary/chain-of-thought.md): Chain-of-thought prompting has a model work through intermediate reasoning steps before answering — improving accuracy on multi-step problems.
- [Chunking](https://agentscamp.com/glossary/chunking.md): Chunking splits documents into retrievable pieces before embedding — the RAG design decision that quietly determines retrieval quality.
- [Computer Use](https://agentscamp.com/glossary/computer-use.md): Computer use is an AI agent operating software through its real interface — reading the screen, moving the cursor, clicking, and typing like a person would.
- [Constitutional AI](https://agentscamp.com/glossary/constitutional-ai.md): Constitutional AI trains models against written principles — the model critiques and revises its own outputs by them, reducing reliance on human labels.
- [Context Engineering](https://agentscamp.com/glossary/context-engineering.md): Context engineering is the discipline of curating exactly what enters an LLM's context window so it has the right information and nothing else.
- [Context Window](https://agentscamp.com/glossary/context-window.md): The context window is the maximum text — measured in tokens — an LLM can consider at once: prompt, conversation, documents, and its own output combined.
- [Cosine Similarity](https://agentscamp.com/glossary/cosine-similarity.md): Cosine similarity measures how alike two embeddings are by the angle between them — the standard relevance score behind semantic search and RAG retrieval.
- [Distillation](https://agentscamp.com/glossary/distillation.md): Distillation trains a smaller model to imitate a larger one — using its outputs as training data to get most of the capability at a fraction of the cost.
- [DPO (Direct Preference Optimization)](https://agentscamp.com/glossary/dpo.md): DPO aligns a model to preferences directly from chosen-vs-rejected pairs — no reward model, no RL loop — simpler and more stable than classic RLHF.
- [Embedding Dimension](https://agentscamp.com/glossary/embedding-dimension.md): Embedding dimension is the length of an embedding vector — how many numbers represent each text — trading capacity against storage and search cost.
- [Embedding](https://agentscamp.com/glossary/embedding.md): An embedding is a vector of numbers representing text's meaning, placed so similar texts land close together — the foundation of semantic search and RAG.
- [Eval Dataset](https://agentscamp.com/glossary/eval-dataset.md): An eval dataset is the curated set of test cases — inputs with expected outcomes — that an LLM application's quality is measured against.
- [Extended Thinking](https://agentscamp.com/glossary/extended-thinking.md): Extended thinking is the reasoning tokens a model generates before its final answer, trading latency and cost for higher accuracy on hard problems.
- [Few-Shot Prompting](https://agentscamp.com/glossary/few-shot-prompting.md): Few-shot prompting includes worked examples in the prompt so the model learns the task's pattern from demonstrations instead of instructions alone.
- [Fine-Tuning](https://agentscamp.com/glossary/fine-tuning.md): Fine-tuning continues training a pretrained model on your own examples, changing its weights to teach durable behavior, format, or domain style.
- [Flash Attention](https://agentscamp.com/glossary/flash-attention.md): FlashAttention is an IO-aware, exact attention algorithm that runs standard attention far faster and with less memory by tiling on-chip.
- [Frontier Model](https://agentscamp.com/glossary/frontier-model.md): A frontier model is one of the most capable AI models available — the leading edge from labs like Anthropic, OpenAI, and Google, defining the state of the art.
- [Function Calling (Tool Calling)](https://agentscamp.com/glossary/function-calling.md): Function calling lets an LLM request structured invocations of your code: describe tools with schemas, the model emits typed calls, your app executes them.
- [Grounding](https://agentscamp.com/glossary/grounding.md): Grounding ties a model's output to verifiable sources — retrieved documents, tool results, citations — instead of training-data memory.
- [Guardrails](https://agentscamp.com/glossary/guardrails.md): Guardrails are programmatic checks around an LLM — validating inputs and outputs in code — enforcing safety and format rules a prompt alone can't guarantee.
- [Hallucination](https://agentscamp.com/glossary/hallucination.md): A hallucination is fluent, confident output that is factually wrong or fabricated — plausible text unsupported by any source, the signature LLM failure mode.
- [Human-in-the-Loop (HITL)](https://agentscamp.com/glossary/human-in-the-loop.md): Human-in-the-loop design inserts human judgment at decisive points in an AI workflow — approving actions, resolving ambiguity, owning the irreversible steps.
- [Hybrid Search](https://agentscamp.com/glossary/hybrid-search.md): Hybrid search runs keyword (BM25) and semantic (vector) retrieval together and merges the results — catching both exact terms and paraphrases.
- [Inference](https://agentscamp.com/glossary/inference.md): Inference is running a trained model to produce output — for LLMs, generating tokens one at a time. Its cost and latency define the economics of AI products.
- [Jailbreak](https://agentscamp.com/glossary/jailbreak.md): A jailbreak is a prompt crafted to bypass a model's safety training and policies — making it produce output it was trained to refuse.
- [Knowledge Cutoff](https://agentscamp.com/glossary/knowledge-cutoff.md): A knowledge cutoff is the date a model's training data ends, so it has no built-in knowledge of any event, release, or fact that came after it.
- [KV Cache](https://agentscamp.com/glossary/kv-cache.md): The KV cache stores each token's attention keys and values so an LLM doesn't recompute the whole context per new token — the memory that makes generation fast.
- [LLM-as-Judge](https://agentscamp.com/glossary/llm-as-judge.md): LLM-as-judge uses a language model to score AI outputs against a rubric — evaluating quality at scale where exact-match metrics fail and humans don't scale.
- [Token (LLM)](https://agentscamp.com/glossary/llm-token.md): A token is the unit LLMs read and write — a word fragment of roughly 3–4 characters in English. Models are priced, limited, and measured in tokens, not words.
- [LLMOps](https://agentscamp.com/glossary/llmops.md): LLMOps is the practices and tooling for running LLM apps in production: prompt versioning, evals, tracing, cost and latency monitoring, and guardrails.
- [LoRA (Low-Rank Adaptation)](https://agentscamp.com/glossary/lora.md): LoRA fine-tunes a model by training small low-rank adapter matrices instead of all weights — a fraction of the memory and cost, nearly full-tune quality.
- [Mixture of Experts (MoE)](https://agentscamp.com/glossary/mixture-of-experts.md): MoE is a model architecture where a router activates only a few expert subnetworks per token — huge total capacity, a fraction of the compute per token.
- [MCP (Model Context Protocol)](https://agentscamp.com/glossary/model-context-protocol.md): MCP is the open standard for connecting AI models to external tools and data: write one server, and any MCP client — Claude Code, IDEs, agents — can use it.
- [Model Routing](https://agentscamp.com/glossary/model-routing.md): Model routing sends each request to the cheapest model that can handle it, escalating only hard cases to a stronger model — cutting cost and latency.
- [Multimodal AI](https://agentscamp.com/glossary/multimodal-ai.md): Multimodal AI processes more than one kind of input or output — text, images, audio, video — in a single model, like an LLM that reads screenshots or speaks.
- [Needle in a Haystack](https://agentscamp.com/glossary/needle-in-a-haystack.md): Needle in a haystack is a long-context eval that hides a fact in filler text and tests whether the model can retrieve it at varying depths and lengths.
- [Open Weights](https://agentscamp.com/glossary/open-weights.md): An open-weights model publishes its parameters for anyone to download and run — unlike API-only models — with licenses from permissive to restricted.
- [Perplexity](https://agentscamp.com/glossary/perplexity.md): Perplexity measures how well a language model predicts a text sample — the exponential of its average per-token negative log-likelihood. Lower is better.
- [Prompt Caching](https://agentscamp.com/glossary/prompt-caching.md): Prompt caching reuses the computed state of a repeated prompt prefix across requests — dramatically cutting cost and time-to-first-token for stable context.
- [Prompt Engineering](https://agentscamp.com/glossary/prompt-engineering.md): Prompt engineering is the practice of designing an LLM's inputs — instructions, context, examples, and format — to reliably get the output you want.
- [Prompt Injection](https://agentscamp.com/glossary/prompt-injection.md): Prompt injection is an attack where untrusted content carries instructions an LLM then follows — overriding its task, leaking data, or triggering tool calls.
- [Prompt Template](https://agentscamp.com/glossary/prompt-template.md): A prompt template is a parameterized prompt — fixed instructions with variable slots — turning prompts from strings into versioned, testable components.
- [Quantization](https://agentscamp.com/glossary/quantization.md): Quantization shrinks a model by storing weights in lower precision (8-, 4-, even 2-bit) — cutting memory and speeding inference at a small accuracy cost.
- [RAG (Retrieval-Augmented Generation)](https://agentscamp.com/glossary/rag.md): RAG retrieves relevant documents from your own data and injects them into an LLM's prompt at query time, grounding answers in facts the model wasn't trained on.
- [ReAct (Reasoning + Acting)](https://agentscamp.com/glossary/react-agent.md): ReAct is an agent loop that interleaves reasoning with tool actions — Thought, Action, Observation, repeat — so the model plans, calls a tool, and revises.
- [Reasoning Model](https://agentscamp.com/glossary/reasoning-model.md): A reasoning model is an LLM trained to think before answering — generating internal reasoning tokens it can spend adaptively on hard problems.
- [Red-Teaming (AI)](https://agentscamp.com/glossary/red-teaming.md): AI red-teaming is adversarial testing — attacking your model or agent with jailbreaks, injections, and misuse scenarios to find failures before users do.
- [Reranking](https://agentscamp.com/glossary/reranking.md): Reranking is a second-pass scoring step: a cross-encoder model re-orders the top results from fast retrieval so the truly relevant few rise to the top.
- [RLHF (Reinforcement Learning from Human Feedback)](https://agentscamp.com/glossary/rlhf.md): RLHF trains a model against human preferences: people rank outputs, a reward model learns the ranking, and the LLM is optimized to produce preferred responses.
- [Semantic Caching](https://agentscamp.com/glossary/semantic-caching.md): Semantic caching reuses LLM responses keyed by meaning rather than exact text, matching queries by embedding similarity to cut cost and latency.
- [Semantic Search](https://agentscamp.com/glossary/semantic-search.md): Semantic search retrieves results by meaning rather than keyword overlap — embedding queries and documents in one vector space and matching by similarity.
- [SLM (Small Language Model)](https://agentscamp.com/glossary/small-language-model.md): A small language model is a compact LLM — roughly 1–15B parameters — that runs cheaply or locally, trading peak capability for speed and deployability.
- [Speculative Decoding](https://agentscamp.com/glossary/speculative-decoding.md): Speculative decoding speeds up generation: a small draft model proposes tokens, the large model verifies them in one parallel pass — same output, fewer steps.
- [Structured Output](https://agentscamp.com/glossary/structured-output.md): Structured output makes an LLM return data in a guaranteed shape — JSON matching your schema — so code can consume model responses without parsing prose.
- [Subagent](https://agentscamp.com/glossary/subagent.md): A subagent is a specialist agent a primary agent delegates to — running in its own context window with its own prompt and tools, returning only a summary.
- [Synthetic Data](https://agentscamp.com/glossary/synthetic-data.md): Synthetic data is training or eval data generated by a model rather than collected from the world — filling gaps, balancing classes, bootstrapping fine-tunes.
- [System Prompt](https://agentscamp.com/glossary/system-prompt.md): The system prompt is the standing instruction layer an LLM receives before user input — defining its role, rules, tools, and tone for the whole conversation.
- [Temperature](https://agentscamp.com/glossary/temperature.md): Temperature controls how random an LLM's token choices are: low values make output focused and repeatable, high values make it varied and creative.
- [Test-Time Compute](https://agentscamp.com/glossary/test-time-compute.md): Test-time compute is spending more computation at inference — longer reasoning, sampling, or search — to improve answers without retraining the model.
- [Token Streaming](https://agentscamp.com/glossary/token-streaming.md): Token streaming delivers model output incrementally as it's generated — via SSE or websockets — so users see text immediately instead of waiting.
- [Tokenization](https://agentscamp.com/glossary/tokenization.md): Tokenization splits text into tokens — the sub-word units a model reads and writes — and maps each to an integer ID the model processes.
- [Top-k Sampling](https://agentscamp.com/glossary/top-k.md): Top-k sampling restricts an LLM's next-token choice to the k most probable tokens before sampling; lower k is more deterministic, higher k more diverse.
- [Top-p (Nucleus Sampling)](https://agentscamp.com/glossary/top-p.md): Top-p sampling restricts an LLM's next-token choices to the smallest set whose probabilities sum to p — cutting the long tail of unlikely tokens adaptively.
- [Tracing (LLM)](https://agentscamp.com/glossary/tracing.md): LLM tracing records every step of a model-driven request — prompts, tool calls, retrievals, tokens, latency — so multi-step behavior is debuggable.
- [Transformer](https://agentscamp.com/glossary/transformer.md): The neural-network architecture (Vaswani et al., 2017) that uses self-attention to process sequences in parallel — the basis of nearly all modern LLMs.
- [Tree of Thoughts](https://agentscamp.com/glossary/tree-of-thoughts.md): Tree of Thoughts is a prompting method that explores multiple reasoning branches as a search tree, evaluating and backtracking among them.
- [Vector Database](https://agentscamp.com/glossary/vector-database.md): A vector database stores embeddings and answers nearest-neighbor queries fast — the retrieval layer under RAG and semantic search, using ANN indexes like HNSW.
- [Vibe Coding](https://agentscamp.com/glossary/vibe-coding.md): Vibe coding is building software by describing intent in natural language and letting an AI agent write the code, judging results by behavior.
- [VLM (Vision-Language Model)](https://agentscamp.com/glossary/vision-language-model.md): A VLM jointly understands images and text — reading documents, screenshots, charts, and photos and reasoning about them in language.
- [Zero-Shot Prompting](https://agentscamp.com/glossary/zero-shot-prompting.md): Zero-shot prompting asks a model to perform a task from instructions alone, with no examples — the default mode for capable modern LLMs.

## Network

- [OptimizeCamp](https://optimizecamp.com): Audit & optimize content for AI search
- [GritShip](https://gritship.com): Lightweight project management for makers
- [SurePrompts](https://sureprompts.com): Free AI prompt generator & builder

## Optional

- [Full content](https://agentscamp.com/llms-full.txt): every page concatenated as Markdown
- [How to use](https://agentscamp.com/how-to-use): installing agents, skills, and commands
- [RSS feed](https://agentscamp.com/feed.xml): newest additions