SilantevBitcoin
UserUniversal idea -> product -> maintenance pipeline for Claude Code: process backbone, intent-based routing, coding discipline, and 6 direction-columns (frontend, TS/Node, Python, DB, AI, backend) with role-agents and skills.
Categories
Indexed Skills (48)
async-python-patterns
Comprehensive guidance for implementing asynchronous Python applications using asyncio, concurrent programming patterns, and async/await for building high-performance, non-blocking systems.
advanced-evaluation
This skill should be used when the user asks to "implement LLM-as-judge", "compare model outputs", "create evaluation rubrics", "mitigate evaluation bias", or mentions direct scoring, pairwise comparison, position bias, evaluation pipelines, or automated quality assessment.
vercel-composition-patterns
React composition patterns that scale. Use when refactoring components with boolean prop proliferation, building flexible component libraries, or designing reusable APIs. Triggers on tasks involving compound components, render props, context providers, or component architecture. Includes React 19 API changes.
deploy-to-vercel
Deploy applications and websites to Vercel. Use when the user requests deployment actions like "deploy my app", "deploy and give me the link", "push this live", or "create a preview deployment".
fixing-motion-performance
Audit and fix animation performance issues including layout thrashing, compositor properties, scroll-linked motion, and blur effects. Use when animations stutter, transitions jank, or reviewing CSS/JS animation performance.
llm-structured-output
Get reliable JSON, enums, and typed objects from LLMs using response_format, tool_use, and schema-constrained decoding across OpenAI, Anthropic, and Google APIs.
multi-agent-patterns
This skill should be used when the user asks to "design multi-agent system", "implement supervisor pattern", "create swarm architecture", "coordinate multiple agents", or mentions multi-agent patterns, context isolation, agent handoffs, sub-agents, or parallel agent execution.
rag-engineer
Expert in building Retrieval-Augmented Generation systems. Masters embedding models, vector databases, chunking strategies, and retrieval optimization for LLM applications. Use when building RAG, vector/semantic search, embeddings, document retrieval, knowledge bases, or chunking strategy.
vercel-react-native-skills
React Native and Expo best practices for building performant mobile apps. Use when building React Native components, optimizing list performance, implementing animations, or working with native modules. Triggers on tasks involving React Native, Expo, mobile performance, or native platform APIs.
vercel-react-view-transitions
Guide for implementing smooth, native-feeling animations using React's View Transition API (`<ViewTransition>` component, `addTransitionType`, and CSS view transition pseudo-elements). Use this skill whenever the user wants to add page transitions, animate route changes, create shared element animations, animate enter/exit of components, animate list reorder, implement directional (forward/back) navigation animations, or integrate view transitions in Next.js. Also use when the user mentions view transitions, `startViewTransition`, `ViewTransition`, transition types, or asks about animating between UI states in React without third-party animation libraries.
remotion-best-practices
Best practices for Remotion - Video creation in React
a11y-audit
Accessibility audit skill for scanning, fixing, and verifying WCAG 2.2 Level A and AA compliance across React, Next.js, Vue, Angular, Svelte, and plain HTML codebases. Use when auditing accessibility, fixing a11y violations, checking color contrast, generating compliance reports, or integrating accessibility checks into CI.
agent-architecture-audit
Full-stack diagnostic for agent and LLM applications. Audits the 12-layer agent stack for wrapper regression, memory pollution, tool discipline failures, hidden repair loops, and rendering corruption. Produces severity-ranked findings with code-first fixes. Essential for developers building agent applications, autonomous loops, or any LLM-powered feature.
api-design
REST API design conventions for TypeScript/Node services — resource naming, HTTP method/status-code semantics, success/error response envelopes, offset vs cursor pagination, filtering/sorting/sparse-fieldsets, versioning strategy, and zod boundary validation. Use when designing or reviewing API endpoints and contracts.
api-rate-limiting
Distributed API rate limiting and throttling: per-IP and per-user limits backed by a shared store (Redis), tiered quotas, sliding/fixed windows, 429 + Retry-After + X-RateLimit headers, and stricter limits on auth and expensive endpoints. Use PROACTIVELY when protecting an API from brute force / abuse / DDoS, enforcing per-tenant quotas, or adding rate limiting at a gateway or service edge.
auth-implementation-patterns
Authentication and authorization patterns: JWT vs session strategies, refresh-token flow, OAuth2/OIDC social login, RBAC/permission/ABAC and resource-ownership checks, password security, and auth-endpoint rate limiting. Use PROACTIVELY when adding login/SSO, designing token or session lifecycle, building an authorization model, or reviewing auth code for security gaps.
bun-runtime
Bun as an all-in-one JS/TS toolchain — runtime, package manager, bundler, and test runner. When to choose Bun vs Node, migration notes from Node, lockfile and reproducible-install guidance, and Vercel support. Use when adopting Bun, migrating from Node, or writing/debugging Bun scripts and tests.
coding-standards
TypeScript/JavaScript coding standards and patterns — naming, immutability, type safety (no `any` at boundaries), async/await discipline, file organization, and code-smell detection. Use when starting a TS module, reviewing TS code for quality, enforcing conventions, or onboarding contributors.
cost-aware-llm-pipeline
Cost optimization patterns for LLM API usage — model routing by task complexity, budget tracking, retry logic, and prompt caching.
cqrs-implementation
Command Query Responsibility Segregation — separate write (command) and read (query) models, drive read models from events, and handle eventual consistency. Use PROACTIVELY when read and write workloads have very different shapes/scale, when building event-sourced systems, or when one ORM model is being contorted to serve both complex writes and high-volume reads.
data-quality-frameworks
Implement data quality validation with Great Expectations, dbt tests, and data contracts. Use when building data quality pipelines, implementing validation rules, or establishing data contracts.
database-migrations
Database migration best practices for schema changes, data migrations, rollbacks, and zero-downtime deployments across PostgreSQL, MySQL, and common ORMs (Prisma, Drizzle, Kysely, Django, TypeORM, golang-migrate). Use when planning or implementing database schema changes.
deployment-patterns
Deployment workflows, CI/CD pipeline patterns, Docker containerization, health checks, rollback strategies, and production readiness checklists for web applications.
distributed-tracing
Distributed tracing with OpenTelemetry across services — instrument Python/Node/Go, propagate W3C trace context, export to Jaeger/Tempo, set sampling, and correlate traces with logs. Use PROACTIVELY when debugging cross-service latency, mapping service dependencies, or adding request-flow visibility to a microservice system.
django-celery
Background task / message-queue patterns with Celery + Redis or RabbitMQ — broker config, idempotent tasks, retries with backoff, dead-letter handling, canvas (chain/group/chord), beat scheduling, monitoring, and testing. Use when adding background jobs, async processing, scheduled tasks, or a task queue to a Python service.
docker-expert
Production Docker containerization: multi-stage builds, layer-cache and image-size optimization, security hardening (non-root, distroless, build-time secrets), Compose orchestration (health checks, dependency ordering, resource limits, internal networks), multi-arch builds, and a container code-review checklist. Use PROACTIVELY when writing/reviewing a Dockerfile or compose file, shrinking or hardening an image, or containerizing a service for production.
embedding-strategies
Select and optimize embedding models for semantic search and RAG applications. Use when choosing embedding models, implementing chunking strategies, or optimizing embedding quality for specific domains.
error-handling
TypeScript error-handling patterns — typed error hierarchies, the Result (no-throw) pattern, API error handlers, retry with exponential backoff + jitter, and user-facing error message mapping. Use when designing error types, adding retries/circuit breakers, reviewing endpoints for missing handling, or debugging cascading failures and silent error swallowing.
eval-harness
Formal evaluation framework implementing eval-driven development (EDD) — pass/fail criteria, code/rule/model/human graders, pass@k and pass^k reliability metrics, and regression suites for LLM and agent behavior.
hexagonal-architecture
Design, implement, and refactor Ports & Adapters (hexagonal) systems in TypeScript / Node — clear domain boundaries, dependency inversion, use-case orchestration, composition root, and slice-by-slice migration. Use when the work involves boundaries, domain-centric design, decoupling logic from frameworks/DB, or supporting multiple interfaces (HTTP/CLI/queue) for one use case.
hono
Build ultra-fast web APIs and full-stack apps with Hono — runs on Cloudflare Workers, Deno, Bun, Node.js, and any WinterCG-compatible runtime.
image-gen-letterbox
Use when generating or editing images via Gemini / nano-banana / banana-pro / gemini-3-pro-image-preview and the target aspect ratio is NOT one of the standard ones the model accepts (16:9, 4:3, 1:1, 3:4, 9:16). Typical triggers — YouTube banners 2560×423, ultra-wide headers, vertical strips, any ratio ≥ 3:1 or ≤ 1:3. This skill teaches the letterbox-and-crop trick so Pro stops mangling the composition.
iterative-retrieval
Pattern for progressively refining context retrieval to solve the subagent context problem in multi-agent and RAG-style code exploration pipelines.
mle-workflow
Production machine-learning engineering workflow for data contracts, reproducible training, model evaluation, deployment, monitoring, and rollback. Use when building, reviewing, or hardening ML systems beyond one-off notebooks.
nestjs-patterns
NestJS architecture patterns for modular TypeScript backends — modules, controllers, providers, DTO validation with class-validator, guards, interceptors, exception filters, typed config, and testing. Use when building NestJS APIs/services, structuring modules, or adding validation/guards/filters.
nodejs-best-practices
Node.js development principles and decision-making. Framework selection, async patterns, security, and architecture. Teaches thinking, not copying.
postgres-best-practices
Postgres performance, schema, concurrency, and security best practices from Supabase. 30 rules across 8 categories, each with incorrect vs correct SQL and impact rating. Use when writing, reviewing, or optimizing Postgres queries, schemas, indexes, locking, or RLS.
postgres-patterns
PostgreSQL database patterns for query optimization, schema design, indexing, concurrency, security (RLS), and performance diagnostics. Quick reference for index types, data types, EXPLAIN ANALYZE workflow, deadlock prevention, and anti-pattern detection. Use when writing SQL, designing schemas, troubleshooting slow queries, or reviewing database code. Based on Supabase best practices.
postgresql
Design a PostgreSQL-specific schema. Covers data types, keys, constraints, indexing, partitioning, RLS, and safe schema evolution. Use when modeling tables for PostgreSQL.
prompt-engineering-patterns
Master advanced prompt engineering techniques to maximize LLM performance, reliability, and controllability in production. Use when optimizing prompts, improving LLM outputs, or designing production prompt templates.
python-patterns
Python-specific design patterns and best practices including protocols, dataclasses, context managers, decorators, async/await, type hints, and package organization. Use when working with Python code to apply Pythonic patterns.
python-testing
Python testing best practices using pytest including fixtures, parametrization, mocking, coverage analysis, async testing, and test organization. Use when writing or improving Python tests.
rag-implementation
Build Retrieval-Augmented Generation (RAG) systems for LLM applications with vector databases and semantic search. Use when implementing knowledge-grounded AI, building document Q&A systems, or integrating LLMs with external knowledge bases.
redis-patterns
Redis distributed-cache, rate-limiting, distributed-lock, pub/sub and Streams patterns for production backends. Use when adding a distributed cache (cache-aside/write-through, invalidation, TTL, stampede), rate limiting/throttling, cross-worker coordination, or a durable event queue. Out-of-process — not an in-memory app cache.
regex-vs-llm-structured-text
Decision framework for choosing between regex and LLM when parsing structured text — start with regex, add LLM only for low-confidence edge cases.
agent-harness-construction
Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates.
database-design
Database design decision-making: schema design, indexing strategy, ORM selection, database selection, migrations, query optimization. DB-agnostic thinking guide. Use when modeling a data layer or choosing database/ORM.
modern-javascript-patterns
Master ES6+ features including async/await, destructuring, spread operators, arrow functions, promises, modules, iterators, generators, and functional programming patterns for writing clean, efficient JavaScript code. Use when refactoring legacy code, implementing modern patterns, or optimizing JavaScript applications.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.