virtual-company

Use when facing complex multi-skill orchestration, full-stack architecture decisions, or coordinating multiple domain experts to build a feature end-to-end

Use when generating documentation, READMEs, API docs, inline comments, architecture diagrams, or technical explanations — for audiences ranging from developers to end users

Use when encountering any bug, test failure, crash, unexpected behavior, or stack trace — before proposing or implementing any fix

Use when writing tests, increasing coverage, verifying functionality, or implementing TDD — before claiming any feature or fix is complete

Use when refactoring messy code, improving readability, eliminating code smells, or applying SOLID/DRRY principles — always with tests as safety net

Use when performing security audits, reviewing code for vulnerabilities, checking auth flows, or validating OWASP compliance — before any approval or merge

Use when diagnosing slow code, identifying bottlenecks, optimizing hot paths, fixing memory leaks, or improving concurrency — always with before/after benchmarks

Use when performing version upgrades, framework migrations, library replacements, or API deprecation handling — with rollback planning and risk assessment

Use when creating CI/CD pipelines (GitHub Actions, GitLab CI, CircleCI), debugging pipeline failures, optimizing build times, or configuring deployment automation

Use when designing Infrastructure as Code (Terraform, CloudFormation), setting up cloud resources, defining IAM policies, or configuring networking — with security and verification discipline

Use when designing REST/GraphQL APIs, creating OpenAPI specs, defining request/response contracts, or refactoring API schemas — before implementation begins

Use when designing database schemas, writing complex SQL queries, building ETL pipelines, or optimizing data transformations — with validation at every step

Use when building UI components, implementing responsive layouts, managing client-side state, or fixing accessibility issues — before shipping to production

Use when implementing server-side logic, designing middleware, integrating databases, or building API endpoints — with TDD and verification discipline

Use when creating Dockerfiles, docker-compose configurations, optimizing images, or debugging container build/runtime issues

Use when creating Kubernetes manifests, Deployments, Services, Ingress rules, Helm charts, or debugging cluster-level issues

Use when performing data visualization, statistical analysis, generating reports, or extracting insights from datasets

Use when building iOS/Android/Flutter/React Native apps, implementing offline sync, optimizing mobile performance, or handling platform-specific APIs — with platform testing discipline

Use when building ML pipelines, training models, evaluating LLMs, setting up RAG systems, or designing model deployment architectures — with validation at every stage

Use when setting up logging, distributed tracing, monitoring dashboards, alerts, or defining SLIs/SLOs — to make systems transparent and debuggable

Use when designing user flows, creating accessible UI components, optimizing visual hierarchy, or defining design systems — with usability and accessibility verification

Use when breaking down epics into user stories, prioritizing features, writing PRDs, defining acceptance criteria, or scoping MVPs — with clear Definition of Done

Use when writing Playwright, Cypress, or Cucumber E2E tests, debugging flaky browser tests, or performing visual regression testing — with flakiness prevention built in

Use when designing full-text search (Elasticsearch), vector search (Pinecone, Weaviate), RAG pipelines, or hybrid search systems — with evaluation metrics

Use when designing multi-step workflows, state machines, parallel execution plans, or coordinating multiple agents/skills for a complex task

Use when analyzing unknown or legacy codebases, documenting undocumented systems, planning refactoring, or identifying dead code and technical debt — with systematic exploration

Use when creating new skills, debugging existing SKILL.md files, or evolving skill definitions — before deploying any skill to production