Bundles

Go language baseline with idiomatic structure, implementation patterns, testing defaults, and security checks for harness-kit projects.

Java language baseline with coding standards, implementation patterns, testing discipline, and security practices for harness-kit projects.

Python language baseline with style, architecture patterns, testing guidance, and security guardrails for harness-kit workflows.

Rust language baseline covering idiomatic structure, implementation patterns, testing expectations, and secure coding defaults for harness-kit.

TypeScript and JavaScript language baseline with coding style, implementation patterns, testing discipline, and security defaults for harness-kit projects.

Your agent now works on Django projects across four specialized skills — architecture patterns, security, TDD with pytest-django, and pre-release verification loops.

Your agent now builds production-ready Express servers — middleware stacks, routing, authentication, robust error handling, and database integration patterns for REST APIs.

Your agent now scaffolds and reviews FastAPI applications against production-ready templates — async patterns, dependency injection, Pydantic models, middleware, and comprehensive error handling.

Your agent now builds Fastify backends against best practices maintained by Fastify co-creator Matteo Collina — routes, plugins, JSON Schema validation, lifecycle hooks, Pino logging, security headers, and the full request lifecycle.

Your agent now writes and debugs GitHub Actions workflows against the official GitHub documentation — syntax, triggers, matrices, runners, reusable workflows, caching, secrets, OIDC, deployments, and custom actions.

Your agent now builds LangChain apps using the modern agent runtime — `create_agent()`, `@tool` decorator, middleware for custom flows, and standard patterns for human-in-the-loop and error handling. Sourced from LangChain AI.

Your agent now models LangGraph workflows as directed graphs correctly — `StateGraph`, state schemas, nodes, edges, `Command`, `Send`, `invoke`, streaming, and error handling. Sourced from LangChain AI.

Your agent now follows Next.js App Router best practices — RSC boundaries, async APIs, data fetching patterns, error handling, and image/font optimization.

Your agent now designs and reviews PostgreSQL schemas against production-grade rules — proper data types (`TIMESTAMPTZ`, `NUMERIC`, `JSONB`), indexing for actual access paths, constraints, partitioning, and workload-aware patterns (insert-heavy / update-heavy / upsert).

Your agent now writes and reviews React/Next.js code against 70 performance rules from Vercel Engineering — waterfalls, bundle size, server caching, re-renders, and hydration patterns.

Your agent now follows Redis Engineering's own guidance for data structures, the Query Engine (RQE), vector search with RedisVL, semantic caching with LangCache, and performance tuning.

Your agent now writes and reviews Spring Boot applications following GitHub's curated best practices — project structure, dependency injection, JPA, REST controllers, validation, Spring Security, and testing.

Your agent now follows Supabase's own guidance for Database, Auth, RLS, Edge Functions, Realtime, Storage, and SSR client libraries (`supabase-js`, `@supabase/ssr`) — sourced from Supabase Engineering.

Your agent now writes and reviews Vue 3 code following a vetted Composition API workflow — `<script setup>` with TypeScript, Pinia for state, Vue Router patterns, SSR, and Vite conventions.

Token-efficient browser automation via accessibility snapshots (~200-400 tokens/page).

Branch naming conventions and PR size limits.

Brave Search MCP server + usage skill — independent index, privacy-focused web search.

Playwright browser automation via persistent CLI daemon. Fine-grained control with ~50ms latency per command.

> **Experimental** — heavy dependencies (Bun, ChromaDB via uv/Python). Powerful but complex setup.

Self-review checklist, PR review protocol, and review-response protocol for Claude Code. Covers all three sides of the review loop: before sending (self-review), when reviewing others, and when receiving feedback on your own diff.

GPG and SSH commit signing setup for Claude Code projects.

Context hygiene rules and task decomposition guide for Claude Code sessions.

Conventional Commits format for AI-assisted git workflows — structured commit messages that map directly to semantic versioning.

Open-source web scraping with JavaScript rendering, LLM extraction, deep crawl, and YouTube/PDF processing — self-hosted, no API key required.

The agent treats the repository as the system of record — decisions, plans, and constraints that aren't in the repo don't exist for the agent.

Hosted web scraping, search, crawling, and browser interaction via the Firecrawl CLI — clean markdown output shaped for LLM context windows.

File-based long-term memory for your agent — personal learnings stay on your machine, team-shared context lives in the repo. Zero dependencies.

Hosted long-term memory for your agent — searchable facts that persist across sessions, extracted automatically from conversation.

Local, offline long-term memory for your agent — a spatial palace (wings → rooms → halls) of verbatim memories retrieved by semantic search + metadata filter. No API keys, no cloud, no LLM calls on write.

Explicit opt-out of persistent memory. Installs a short rule telling the agent that no memory backend exists in this project — so it stops trying (or pretending) to use one.

Teaches the agent when to split work across parallel subagents, how to brief them so the results are actually usable, and how to avoid the common failure modes (overlapping edits, vague output, sequential dispatch).

Installs the brainstorm-then-plan-then-execute discipline — the habit of exploring the code, asking one clarifying question at a time, putting 2–3 approaches on the table with trade-offs, waiting for explicit approval before touching the filesystem, and then executing the approved plan with proper verification gates between tasks.

Terminal-driven browser automation via the Playwright CLI. The agent opens a real browser, snapshots the accessibility tree, and interacts by stable element refs (`e3`, `e15`) — not CSS selectors, not pixel screenshots.

Blocks bad commits at the git layer — conflict markers, obvious secrets, and tech-stack-appropriate lint/typecheck/test. No framework dependency (husky, lefthook, pre-commit.com) — just a portable shell script.

Fresh verification before completion claims. The agent stops treating \"looks correct\" as evidence and proves \"done\" with repo-appropriate commands.

Dedicated security review for risky diffs. The agent stops treating security as one checkbox inside generic code review and runs a focused pass on attacker-controlled inputs, trust boundaries, and exploit paths.

Spec before plan for non-trivial work. The agent stops letting implementation become the first precise statement of scope and writes the source-of-truth spec in the repo first.

Root-cause-first debugging for agent sessions. The agent stops thrashing on quick fixes and works through reproduction, evidence, isolation, hypothesis, and only then a targeted fix.

Agent-oriented web access via Tavily MCP. The agent can search for current information, extract clean content from URLs, and escalate into site mapping or crawling when a single page is not enough.

Test-driven development for agent sessions. The agent stops coding first and instead grows behavior through small red-green-refactor loops.