Fourmis

fourmis-marketplace

Prompt engineering toolkit — prompt design patterns (role, constraints, multi-pass), structured output (tool use, Zod schemas, JSON/XML parsing), few-shot example design (selection strategies, contrastive pairs), chain-of-thought reasoning (CoT, extended thinking, self-consistency, tree of thought), RAG patterns (chunking, vector search, hybrid search, grounding), and LLM evaluation (datasets, LLM-as-judge, regression testing, CI pipelines). 6 skills, 3 commands, 1 agent. No dependencies.

Migration and upgrade toolkit — database schema migrations (SQL, ORM, rollbacks, zero-downtime), dependency updates (semver, changelogs, breaking changes, Dependabot/Renovate), framework upgrades (Next.js, React, Express, Go, codemods), API versioning (URL/header strategies, deprecation headers, consumer migration), data migrations (ETL, backfills, dual-write, verification), and deprecation management (sunset plans, migration guides, usage tracking). 6 skills, 3 commands, 1 agent. No dependencies.

Log analysis and observability toolkit — structured logging patterns (Node.js Pino, Python structlog, Go slog), log parsing (JSON, Apache, nginx, syslog, Docker, Kubernetes), error diagnosis with stack trace analysis and root cause workflows, log monitoring and alerting (Grafana Loki, LogQL, script-based alerts), advanced log search (jq, grep, awk one-liners), and OpenTelemetry observability setup (traces, metrics, log correlation). 6 skills, 3 commands, 1 agent. No dependencies.

Environment variable and configuration management toolkit — dotenv patterns and precedence rules (Node.js, Python, Go), type-safe env validation (Zod, t3-env, Pydantic, Go envconfig), secret management (1Password CLI, cloud vaults, rotation strategies), 12-factor config patterns and feature flags, .env.example sync and developer onboarding, and env security (leak prevention, gitleaks, secret scanning, audit). 6 skills, 3 commands, 1 agent. No dependencies.

Docker and containerization toolkit — Dockerfile best practices (multi-stage builds, layer caching, distroless/scratch, Node.js/Python/Go patterns), Docker Compose (services, networks, health checks, profiles, dev/prod overrides), container debugging (6-step framework, exit codes, logs, exec, networking, resources), image optimization (dive analysis, size reduction, BuildKit cache mounts, buildx multi-arch), Docker networking (bridge, overlay, DNS, service discovery, port mapping), and container security (rootless, image scanning, secrets, capabilities, hardening checklists). 6 skills, 3 commands, 1 agent. No dependencies.

Modern React patterns — custom hooks (useCallback, useMemo, useRef, useReducer, composition, debounce), state management (React Context, Zustand, TanStack Query, state colocation), React Server Components (RSC boundaries, streaming, Suspense, Server Actions, data fetching), component architecture (compound components, render props, polymorphic, slots, controlled/uncontrolled), form patterns (React Hook Form, Zod, multi-step wizards, optimistic updates, field arrays), and performance (React.memo, virtualization, code splitting, lazy loading, React Compiler). 6 skills, 3 commands, 1 agent. No dependencies.

Advanced TypeScript patterns — generics (constrained, conditional, mapped, template literal types), utility types (built-in, custom, branded/opaque types), type guards (narrowing, discriminated unions, exhaustive checking, assertion functions), Zod validation (schemas, form/API validation, type inference from schemas), error handling (Result types, typed errors, error boundaries, async patterns), and module patterns (barrel exports, declaration merging, module augmentation, tsconfig best practices). 6 skills, 3 commands, 1 agent. No dependencies.

Idiomatic Go patterns — concurrency (goroutines, channels, select, sync.Mutex/RWMutex/WaitGroup/Once/Pool, errgroup, fan-out/fan-in, worker pools, rate limiting), error handling (fmt.Errorf %w wrapping, custom error types, errors.Is/As, sentinel errors, multi-error, goroutine errors), interfaces (implicit satisfaction, composition, type assertions/switches, common interfaces, dependency injection, mocking), HTTP (net/http, Go 1.22+ routing, middleware chains, JSON helpers, graceful shutdown, structured responses), testing (table-driven, subtests, testify, httptest, benchmarks, fuzzing, golden files, build tags), and project structure (cmd/internal layout, packages, modules, Makefile, golangci-lint). 6 skills, 3 commands, 1 agent. No dependencies.

Authentication and authorization patterns — JWT (access/refresh tokens, RS256/HS256, claims design, token rotation, revocation), OAuth2 (authorization code + PKCE, client credentials, social login with Google/GitHub/Discord, OIDC), session auth (cookie-based sessions, Redis/DB stores, CSRF protection, session security, httpOnly/sameSite cookies), password security (bcrypt/argon2 hashing, reset flows, magic links, email verification, rate limiting login), authorization (RBAC roles/permissions, ABAC policies, resource-level auth, org/tenant scoping, middleware), and API auth (API key generation/rotation/scoping, webhook signature verification, tiered rate limiting, Bearer tokens). 6 skills, 3 commands, 1 agent. No dependencies.

Production API design patterns — RESTful resource design (naming, methods, status codes, versioning, idempotency, ETags), error handling (RFC 7807 Problem Details, typed error classes, validation errors, error middleware), pagination and filtering (cursor/offset pagination, Relay connections, sorting, field selection, search), rate limiting (token bucket, sliding window, Redis distributed limiting, tiered limits, proper headers), WebSocket real-time patterns (ws, gorilla/websocket, rooms/channels, authentication, heartbeat/reconnection, Redis pub/sub scaling), and GraphQL (schema design, resolvers, DataLoader N+1 prevention, subscriptions, Relay pagination, query complexity). 6 skills, 3 commands, 1 agent. No dependencies.

Production observability patterns — structured logging (Pino, Winston, zerolog with correlation IDs and redaction), Prometheus metrics (RED/USE methods, prom-client, client_golang, custom business metrics, label best practices), alerting rules (Prometheus rules, Alertmanager routing, SLO burn-rate alerts, severity levels, alert fatigue prevention), health checks (liveness/readiness/startup probes, dependency checkers, Kubernetes configuration, graceful degradation), distributed tracing (OpenTelemetry SDK for Node.js and Go, auto-instrumentation, manual spans, context propagation, sampling strategies, collector config), and Grafana dashboards (PromQL queries, RED/USE/SLO/database dashboards, JSON provisioning, variables, GitOps). 6 skills, 3 commands, 1 agent. No dependencies.

Production Next.js patterns — App Router (file-based routing, layouts, parallel/intercepting routes, route groups), data fetching (Server Components, fetch caching, ISR, streaming with Suspense, React.cache, parallel data loading), Server Actions (useActionState, useOptimistic, validation, redirect after mutation), middleware and authentication (Auth.js/NextAuth v5, session cookies, JWT, role-based access, protected API routes), caching strategies (four cache layers, tag-based invalidation, revalidatePath/revalidateTag, cache debugging, ISR), and deployment optimization (next.config.ts, security headers, next/image, next/font, bundle analysis, Docker standalone, Vercel, env validation with Zod). 6 skills, 3 commands, 1 agent. No dependencies.

Production database patterns — schema design (naming, types, constraints, UUIDs, soft deletes, enums, normalization), query optimization (EXPLAIN ANALYZE, B-tree/GIN/partial/covering/composite indexes, CTEs, window functions, materialized views), ORM patterns (Prisma schema/queries/transactions, Drizzle ORM, GORM, SQLx, raw SQL), transactions and locking (ACID, isolation levels, optimistic locking with version columns, pessimistic locking with SELECT FOR UPDATE, advisory locks, deadlock prevention, SKIP LOCKED job queues), connection pooling (pg Pool, pgxpool, pool sizing formulas, PgBouncer, monitoring, graceful shutdown), and data modeling (one-to-many, many-to-many, polymorphic associations, self-referential trees with ltree, JSONB columns, audit logs with triggers, multi-tenancy with RLS). 6 skills, 3 commands, 1 agent. No dependencies.

Production Kubernetes patterns — core resources (Pods, Deployments, StatefulSets, DaemonSets, Jobs, ConfigMaps, Secrets, Namespaces, resource quotas, labels), networking (Services, Ingress with NGINX and cert-manager TLS, NetworkPolicies with default deny, DNS service discovery, Gateway API, canary traffic splitting), storage (StorageClasses, PVCs, StatefulSets with volumeClaimTemplates, access modes, volume snapshots, Velero backups), scaling (HPA with CPU/memory/custom metrics, VPA right-sizing, KEDA event-driven scale-to-zero, PodDisruptionBudgets, Cluster Autoscaler, Karpenter), Helm charts (chart structure, values per environment, Go templates, hooks for migrations, dependencies, OCI registries, testing), and troubleshooting (CrashLoopBackOff, OOMKilled, ImagePullBackOff, pending pods, network debugging, RBAC, exit codes, kubectl debug). 6 skills, 3 commands, 1 agent. No dependencies.

Vector database and RAG patterns — embedding models (OpenAI text-embedding-3, Cohere, Voyage AI, sentence-transformers, Ollama local models, chunking strategies, token counting), pgvector (PostgreSQL extension setup, HNSW/IVFFlat indexes, cosine/L2/IP similarity search, hybrid search with full-text, metadata filtering, Drizzle/Prisma/node-postgres usage), vector search fundamentals (distance metrics, ANN algorithms, filtering strategies, cross-encoder re-ranking, Cohere rerank, Reciprocal Rank Fusion, evaluation metrics), RAG patterns (retrieval-augmented generation pipelines, query rewriting, HyDE, multi-step retrieval, parent document retrieval, context assembly, citation, ingestion pipelines, LLM-as-judge evaluation), Pinecone (serverless/pod indexes, batch upsert, metadata filtering, namespaces, hybrid search, index management), and ChromaDB/Weaviate (local embedded DB, collections, custom embedding functions, Weaviate schema, hybrid BM25+vector search, multi-tenancy). 6 skills, 3 commands, 1 agent. No dependencies.

State machines and workflow patterns — XState v5 (createMachine, createActor, context, events, guards, actions, invoke, delayed transitions, type-safe machines), XState + React (useActor, useSelector, actor context pattern, multi-step form wizards, authentication flows, testing), workflow patterns (order processing, approval workflows, retry with exponential backoff, saga pattern with compensation, pipeline pattern), finite automata (hierarchical/nested states, parallel states, history states, always transitions, final states, actor model/spawning), event-driven architecture (event sourcing, CQRS, event stores with optimistic concurrency, projections, snapshots, domain events, event versioning), and process orchestration (Temporal.io workflows/activities/signals/queries, simple workflow engine, database-backed job queues with SKIP LOCKED). 6 skills, 3 commands, 1 agent. No dependencies.

Production-ready Claude Code hooks — bash command safety guards (blocks rm -rf, force push, DROP TABLE), file protection (.env, credentials, SSH keys), auto-lint after edits (ESLint, Prettier, ruff, gofmt), project context injection on session start, and task completeness verification via prompt hook. 3 skills, 2 commands, 1 agent, 5 hooks. No dependencies.

Smart workspace onboarding for Claude Code — auto-detects your project stack (Node.js, TypeScript, Go, Python, React, Next.js, Prisma, Docker, Kubernetes, GitHub Actions), recommends relevant marketplace plugins, and configures your workspace. Includes /setup and /plugins commands, a SessionStart hook for automatic stack detection, and a workspace-advisor agent. 2 skills, 2 commands, 1 agent, 1 hook. No dependencies.

Production readiness hooks — test gates that block session end until tests pass, secret scanning that blocks writes containing API keys and tokens, auto-formatting (prettier/gofmt/black/rustfmt), commit message validation (conventional commits, force-push protection), and async type checking (tsc/mypy/go vet). 2 skills, 1 command, 1 agent, 5 hooks. No dependencies.

Autonomous session management hooks — auto-checkpoints every N edits (git commits), stuck loop detection (repeated errors/commands), TODO/FIXME scanner (blocks session end if stubs remain), session summary generator (stats on stop), and test drift detector (warns when source changes outpace tests). Built for Ralph Wiggum loops and long-running autonomous sessions. 2 skills, 1 command, 1 agent, 5 hooks. No dependencies.

Product management toolkit — PRD writing (templates, RICE scoring), sprint planning (capacity, velocity, ceremonies), user stories (INVEST, story mapping, splitting), estimation (Fibonacci, t-shirt sizing, PERT), roadmap planning (Now/Next/Later, OKR alignment, milestones), and retrospectives (Start/Stop/Continue, 4Ls, Sailboat, action tracking). 6 skills, 3 commands, 1 agent. No dependencies.

Design system toolkit — design tokens (3-tier architecture), Tailwind CSS theming (v3/v4), responsive design patterns (container queries, fluid typography), CSS animations (entrance, loading, scroll-driven), typography systems (scales, font loading, prose), and component styling (CVA variants, compound components). 6 skills, 3 commands, 1 agent. No dependencies.

A simple demo plugin that greets the user and demonstrates the Claude Code plugin standard. Includes a slash command and an auto-activating skill.

Comprehensive git workflow toolkit — conventional commits, branch naming conventions, PR descriptions, changelog generation, git hooks (Husky, lint-staged, Lefthook), merge conflict resolution, rebasing and recovery (reflog, cherry-pick, stash), and monorepo workflows (CODEOWNERS, selective CI, Changesets). 6 skills, 4 commands, 1 agent. No dependencies.

Codebase quality metrics and tech debt tracking. Analyzes file complexity, outdated dependencies, TODO/FIXME markers, and dead code. Gives your codebase a health score with actionable improvements.

Auto-generate API documentation from your code. Scans route handlers in Express, Go, Next.js, and Fastify to produce OpenAPI specs, markdown references, and curl examples.

Full Reddit integration via MCP — browse subreddits, search posts, read comments, submit posts, comment, and vote. Authenticated via OAuth2 with 10 tools covering all core Reddit operations.

Local-first CRM for freelancers — manage contacts, deals, follow-ups, and interactions with zero cloud dependencies. SQLite-based with 17 MCP tools covering full CRUD, pipeline tracking, and reporting.

Professional writing toolkit — blog posts, technical docs, SEO content, readability analysis, content outlining, and systematic editing. 6 skills, 3 commands, 1 editor agent. No dependencies.

Cross-platform social media posting — publish to Bluesky and Mastodon from Claude Code. Compose once, adapt for character limits, post to one or all platforms. 8 MCP tools, 1 skill, 2 commands.

Comprehensive DevOps expertise bundle — incident response, deployment safety, Dockerfile optimization, GitHub Actions, Kubernetes troubleshooting, security hardening, and infrastructure cost analysis. 7 skills, 3 commands, 2 agents.

Free SEO analysis toolkit — on-page optimization, technical audits, meta tag validation, heading analysis, image audits, SSL checks, redirect tracing, robots.txt/sitemap parsing, and performance metrics. 10 MCP tools, 3 skills, 2 commands, 1 agent. No paid API keys.

Local-first invoicing for freelancers — create, track, and export professional invoices from Claude Code. SQLite-based with 10 MCP tools for clients, invoices, payments, HTML export, and revenue reports. Zero cloud dependencies.

Content marketing agent profile — orchestrates markdown-writer, seo-toolkit, and social-poster into end-to-end workflows. Create content, optimize for search, distribute on social. 3 agents, 3 skills, 3 commands. No MCP server — pure coordination.

Local-first time tracking for freelancers — start/stop timers, log hours per project, generate timesheets, and track billable earnings. SQLite-based with 12 MCP tools. Zero cloud dependencies, zero subscriptions.

Freelancer business agent profile — orchestrates local-crm, invoice, and time-tracker into end-to-end workflows. Onboard clients, track time, bill clients, monitor business health. 3 agents, 3 skills, 4 commands. No MCP server — pure coordination.

Database exploration MCP server — connect to SQLite or PostgreSQL, list and describe tables, view column types and constraints and indexes, map table relationships, run read-only SQL queries, sample data, export results to CSV, data quality checks (orphaned FKs, duplicates, null analysis). 1 skill, 2 commands, 1 agent, 10 MCP tools. Zero cloud dependencies.

Local code security scanning MCP server — detect hardcoded secrets and API keys, scan dependencies for known CVEs, find SQL injection and XSS and command injection patterns, audit configurations for misconfigurations, check HTTP security headers (HSTS, CSP, X-Frame-Options), verify .env exposure and file permissions, generate security grades and audit reports. 1 skill, 2 commands, 1 agent, MCP server. Zero cloud dependencies.

Test generation and analysis toolkit — unit tests (Jest, Vitest, pytest, Go table-driven), integration tests (Supertest, httpx, httptest, database setup/teardown), E2E tests (Playwright, Cypress, Page Object pattern), TDD workflow (Red-Green-Refactor), mocking patterns (jest.fn, vi.fn, unittest.mock, testify/mock, fixtures), and coverage analysis (gap detection, risk-based prioritization, flaky test detection). 6 skills, 3 commands, 1 agent. No dependencies.

Comprehensive code review toolkit — review patterns (TypeScript, Python, Go), PR review workflow (gh CLI, size guidelines, verdict framework), review checklists (API, React, migration, auth, performance, config), code quality assessment (SOLID, code smells, cyclomatic/cognitive complexity), test review (coverage gaps, anti-patterns, mock audit), and effective review comments (categorization, tone, volume guidelines). 6 skills, 3 commands, 1 agent. No dependencies.

CI/CD toolkit — GitHub Actions workflows (Node.js, Go, Python, monorepo, reusable workflows), deployment pipelines (Vercel, Fly.io, Railway, AWS, blue-green, canary, rolling), Docker CI (multi-stage builds, layer caching, vulnerability scanning, multi-arch), release automation (semantic-release, Changesets, GoReleaser, GitHub Releases, changelogs), and CI best practices (caching, parallelism, test sharding, matrix builds, OIDC secrets, concurrency groups). 5 skills, 3 commands, 1 agent. No dependencies.

Project scaffolding toolkit — generate production-ready boilerplate for Next.js, Express, Go, Python, monorepos, and npm/PyPI libraries. Best-practice project structure, configs, CI, testing, and Docker setup. 6 skills, 3 commands, 1 agent. No dependencies.

Accessibility audit toolkit — WCAG 2.2 compliance checking, ARIA patterns, color contrast analysis, keyboard navigation, screen reader optimization, and accessible component recipes. 6 skills, 3 commands, 1 agent. No dependencies.

Web performance optimization toolkit — Core Web Vitals (LCP, INP, CLS), rendering performance, bundle size optimization, image optimization, caching strategies, and performance monitoring. 6 skills, 3 commands, 1 agent. No dependencies.

API testing toolkit — REST API testing patterns (Supertest, httpx, Go httptest), mock server setup (MSW), contract testing (OpenAPI validation), API security auditing, HTTP client best practices, and API documentation. 6 skills, 3 commands, 1 agent. No dependencies.