idumb-v2

Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", or any task requiring programmatic web interaction.

Systematically identify what's missing, unknown, or needs investigation before making changes or decisions. Use proactively when proposing features, implementing changes, or making technical decisions to ensure all critical areas are covered. This skill catches overlooked dependencies, edge cases, and integration points before they become problems. Examples: - "Implement user authentication" → trigger gap analysis (what's the current auth system?) - "Add caching to API" → trigger gap analysis (what caching infrastructure exists?) - "Migrate to TypeScript" → trigger gap analysis (what's the build pipeline?) - "Refactor this module" → trigger gap analysis (what depends on this module?) - "Add new API endpoint" → trigger gap analysis (what endpoints exist, what patterns?)

Detect ambiguous or underspecified research requests and guide through structured clarification questions before executing any research. Use proactively when user requests are vague, lack specificity, missing context, or have unclear goals. This skill prevents wasted research by ensuring intent is crystal clear before any web searches, file reads, or data gathering. Examples: - "Research the codebase" → ❌ Too vague, trigger clarification - "Why is this slow?" → ❌ Missing context (what is "this"?), trigger clarification - "Add a feature" → ❌ Not research, this is implementation - "Investigate authentication flow" → ❌ What specifically about it? Trigger clarification - "Compare React and Vue" → ✅ Specific enough, but still validate dimensions

Evaluate requests, proposals, or decisions from multiple dimensions (technical, business, UX, security, performance, maintainability, etc.) to ensure holistic understanding before proceeding. Use proactively when making technical decisions, choosing solutions, or proposing changes. This skill prevents single-minded thinking and uncovers trade-offs, risks, and opportunities across all relevant aspects. Examples: - "Use Redis for caching" → assess multiple aspects (performance, cost, complexity, ops) - "Add AI to our app" → assess aspects (technical feasibility, user experience, data privacy) - "Refactor to microservices" → assess aspects (benefits, costs, migration complexity, team readiness) - "Implement authentication" → assess aspects (security, UX, integration effort, maintenance) - "Switch to React 19" → assess aspects (benefits, migration cost, breaking changes, learning curve)

Choose the right OpenCode primitive (Command, Skill, Tool, Prompt, CustomTool, Plugin hook) for a given task or workflow. Use proactively when deciding which OpenCode capability to use, or when trying to understand what's available. This skill maps research and development needs to appropriate OpenCode mechanisms, ensuring optimal use of the platform's capabilities. Examples: - "How do I search the codebase?" → select tool (read/grep) - "I need a reusable workflow for feature development" → select command - "How do I intercept file writes?" → select plugin hook - "What primitive should I use for systematic debugging?" → select skill - "I need a custom tool for X" → select CustomTool (if innate tools insufficient)

Create structured, executable research plans with clear phases, checkpoints, and validation criteria. Use proactively when research intent is clear but execution plan is missing. This skill transforms research goals into actionable workflows with defined deliverables, time estimates, and success metrics, ensuring research is systematic and produces useful outputs. Examples: - "Research how to add OAuth" (intent clear, need plan) → trigger workflow planner - "Investigate performance bottlenecks" (intent clear, need plan) → trigger workflow planner - "Analyze codebase architecture" (intent clear, need plan) → trigger workflow planner - "Find best practices for X" (intent clear, need plan) → trigger workflow planner - "Compare technology options" (intent clear, need plan) → trigger workflow planner

Specialized agent for systematic reduction of oversized components (>300 lines) into focused, composable modules. Use this skill when splitting large React components, extracting custom hooks for complex state management or side effects, implementing component composition patterns, or maintaining API compatibility during refactoring.

Specialized agent for sync strategy consolidation, conflict resolution, and cross-workspace file synchronization. Use this skill when consolidating duplicate sync implementations, implementing conflict resolution strategies, handling offline-first scenarios, or creating unified sync status indicators across IDE, Notes, and Knowledge workspaces.

Comprehensive architecture remediation module for systematic elimination of technical debt. Use this skill when addressing god stores (>300 lines), oversized components, TypeScript errors, test coverage gaps, workspace file system E2E issues, or sync strategy fragmentation. This module provides structured agents and workflows for foundation stabilization, workspace E2E implementation, and quality assurance.

Specialized agent for systematic elimination of god stores (>300 lines) by extracting focused slices (≤120 lines each) while maintaining 100% backward compatibility. Use this skill when refactoring Zustand stores, splitting god classes into modular slices, implementing Zustand v5 patterns (individual selectors, persist on combined store), creating facade exports for backward compatibility, or migrating legacy stores to modern architecture.

Specialized agent for systematic improvement of test coverage from current baseline to ≥80%. Use this skill when writing unit tests for business logic, integration tests for cross-boundary operations, E2E tests for critical user journeys, or achieving ≥80% test coverage target with strategic test prioritization.

Specialized agent for systematic reduction of TypeScript errors through categorized batch fixing and pattern identification. Use this skill when fixing TypeScript errors in batches (50-100 per session), categorizing errors by type (missing imports, wrong types, circular deps), identifying error patterns, or applying incremental TypeScript checking.

Systematic workflow for eliminating god stores (>300 lines) by extracting focused slices (≤120 lines each) while maintaining 100% backward compatibility. Use this workflow when refactoring Zustand stores, implementing Zustand v5 patterns, creating facade exports, or consolidating duplicate stores.

Specialized workflow for implementing Knowledge workspace file synchronization with RAG pipeline integration, source import handling, and AI synthesis. Use this workflow when implementing sync for Knowledge workspace, integrating RAG indexing with file sync, or handling source document imports.

Systematic workflow for reducing oversized components (>300 lines) into focused, composable modules through hook extraction and component decomposition. Use this workflow when splitting large React components, extracting custom hooks, or implementing component composition patterns.

Specialized workflow for implementing Notes workspace file synchronization with offline-first support, conflict resolution, and AI synthesis integration. Use this workflow when implementing sync for Notes workspace, creating note-specific conflict resolution, or integrating AI with note files.

End-to-end workflow for implementing workspace file system strategies with permission hardening, concurrent access handling, and AI integration. Use this workflow when implementing file system E2E for IDE, Notes, or Knowledge workspaces.

Specialized agent for workspace end-to-end (E2E) implementation, focusing on file system alignment, permission hardening, and AI integration across IDE, Notes, and Knowledge workspaces. Use this skill when implementing workspace file system strategies, auditing FSA permission models, creating agent tool permission matrices, or handling concurrent file access.

Design, implement, and maintain RESTful API endpoints following industry best practices for resource-based URLs, HTTP methods, versioning, query parameters, and status codes. Use this skill when creating API routes in Express, Fastify, Next.js API routes, TanStack Router API endpoints, or any backend API framework; when defining RESTful resources with GET, POST, PUT, PATCH, DELETE operations; when implementing API versioning strategies; when adding query parameters for filtering, sorting, pagination, or search; when determining appropriate HTTP status codes (200, 201, 400, 404, 500, etc.); when structuring nested resources and endpoint naming conventions; when implementing rate limiting headers; or when working with API contract design and backend routing in TypeScript, JavaScript, Python, Ruby, or any server-side language.

Create and manage database schema migrations with reversible operations, zero-downtime deployments, and safe rollback strategies. Use this skill when writing database migrations for PostgreSQL, MySQL, SQLite, MongoDB, or any database system; when using ORMs like Prisma, Sequelize, TypeORM, ActiveRecord, Django ORM, or similar migration tools; when implementing schema changes (adding tables, columns, indexes, constraints); when performing data migrations or transformations; when creating indexes on large tables with concurrent options to avoid locks; when separating schema changes from data migrations for safer rollbacks; when implementing zero-downtime deployment strategies for high-availability systems; when versioning database schemas and managing migration order; or when working with database change management in production environments.

Design database models with clear naming conventions, appropriate data types, relationships, constraints, and indexing strategies. Use this skill when defining database models, schemas, or entities in ORMs like Prisma, Sequelize, TypeORM, ActiveRecord, Django ORM, Mongoose, or similar; when creating tables with PostgreSQL, MySQL, SQLite, MongoDB, or any database; when establishing model relationships (one-to-one, one-to-many, many-to-many); when adding database constraints (NOT NULL, UNIQUE, foreign keys); when implementing timestamps for auditing and debugging; when choosing appropriate data types for columns; when creating indexes on foreign keys and frequently queried fields; when balancing normalization with query performance; when implementing validation at model and database layers; or when structuring data models for optimal query performance and data integrity.

Write efficient, secure database queries that prevent SQL injection, avoid N+1 problems, and optimize performance through proper indexing and caching strategies. Use this skill when writing SQL queries for PostgreSQL, MySQL, SQLite, or any SQL database; when using ORM query builders like Prisma, Sequelize, TypeORM, ActiveRecord, Django ORM; when implementing parameterized queries to prevent SQL injection; when optimizing query performance with proper indexing; when eager loading relationships to avoid N+1 queries; when selecting specific columns instead of SELECT *; when wrapping related operations in transactions for data consistency; when implementing query timeouts to prevent runaway operations; when caching expensive query results; or when working with database query optimization and performance tuning.

You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.

Enforce canonical paths and prevent file tree anarchy. Use when creating or modifying files to ensure they go to correct locations.

Load required context before any work. Uses prompt matrix to determine what to load based on request type. Prevents premature implementation and context poisoning.

Implement accessible user interfaces following WCAG guidelines with semantic HTML, keyboard navigation, proper color contrast, and screen reader support. Use this skill when building React, Vue, Svelte, or any frontend framework components; when writing HTML structure with semantic elements (nav, main, button, etc.); when implementing keyboard navigation and focus management; when checking color contrast ratios for text and UI elements; when adding ARIA attributes to enhance complex components; when providing alt text for images and labels for form inputs; when testing with screen readers; when structuring heading hierarchies (h1-h6) for document outline; when managing focus in dynamic content, modals, and single-page applications; when building accessible forms, buttons, links, and interactive elements; or when ensuring web accessibility compliance across desktop and mobile interfaces.

Build reusable, composable UI components with clear interfaces, proper state management, and single-responsibility design principles. Use this skill when creating React components, Vue components, Svelte components, or any UI framework components; when designing component APIs with props and sensible defaults; when implementing component composition patterns; when managing component state (local vs. lifted state); when writing component documentation and usage examples; when ensuring components are reusable across different contexts; when following single responsibility and encapsulation principles; when creating UI libraries or design systems; when optimizing component performance with proper rendering patterns; when building complex UIs by combining smaller components; or when structuring component architecture for scalability and maintainability.

Write maintainable, consistent CSS following established methodologies like Tailwind, BEM, CSS Modules, or utility-first approaches with design tokens and optimized production builds. Use this skill when styling React components, Vue components, Svelte components, or any frontend framework; when applying Tailwind CSS utility classes; when implementing CSS methodologies (BEM, OOCSS, utility-first); when defining design tokens (colors, spacing, typography); when writing custom CSS vs. using framework utilities; when optimizing CSS for production with purging and tree-shaking; when avoiding framework style overrides; when maintaining consistent styling across the application; when working with CSS-in-JS solutions like styled-components or emotion; when creating responsive styles with mobile-first or desktop-first approaches; or when structuring CSS architecture for scalability and maintainability.

Implement responsive, mobile-first designs with fluid layouts, standard breakpoints, touch-friendly interactions, and cross-device compatibility. Use this skill when creating layouts that adapt to mobile, tablet, and desktop screen sizes; when implementing mobile-first progressive enhancement; when using standard breakpoints consistently across the application; when working with flexible containers and percentage-based widths; when using relative units (rem/em) instead of fixed pixels; when sizing tap targets for mobile (minimum 44x44px); when optimizing images and assets for mobile networks; when testing UI across multiple device sizes; when ensuring readable typography across all breakpoints; when prioritizing content for smaller screens; when implementing responsive grid systems or layout frameworks; or when designing touch-friendly interfaces with appropriate spacing and interaction areas.

Write clean, maintainable code with consistent naming conventions, meaningful identifiers, small focused functions, proper formatting, and adherence to DRY principles. Use this skill when writing code in any programming language (TypeScript, JavaScript, Python, Ruby, Go, etc.); when naming variables, functions, classes, and files; when formatting code with consistent indentation and line breaks; when refactoring code to follow DRY principles and avoid duplication; when writing small, focused functions with single responsibilities; when removing dead code, commented-out blocks, and unused imports; when choosing between backward compatibility and clean implementations; when structuring code for readability and testability; when applying automated formatting with Prettier, ESLint, Black, RuboCop, or similar tools; or when establishing and maintaining coding standards across the project.

Write self-documenting code with minimal, evergreen comments that explain complex logic rather than obvious implementations or recent changes. Use this skill when writing code in any programming language; when deciding whether to add comments to explain logic; when writing comments that clarify complex algorithms or non-obvious reasoning; when documenting large sections of code; when avoiding comments that speak to recent or temporary changes or fixes; when prioritizing self-documenting code through clear structure and naming; when writing JSDoc, TSDoc, Python docstrings, or similar documentation comments; when refactoring code to be more self-explanatory; or when maintaining comment quality across the codebase.

Follow general development conventions including project structure, version control best practices, environment configuration, dependency management, code review processes, and feature flagging strategies. Use this skill when organizing project files and directories; when writing Git commit messages and managing feature branches; when configuring environment variables and managing secrets; when managing dependencies and documenting why major dependencies are used; when establishing code review processes and pull request guidelines; when defining testing requirements before merging; when implementing feature flags for incomplete features; when maintaining changelogs and release notes; when setting up project documentation and README files; or when establishing team-wide development standards and workflows.

Implement robust error handling with user-friendly messages, specific exception types, centralized error boundaries, graceful degradation, retry strategies, and proper resource cleanup. Use this skill when handling errors in backend or frontend code; when providing clear, actionable error messages to users; when validating input and failing fast with explicit error messages; when using specific exception types instead of generic errors; when implementing centralized error handling at appropriate boundaries; when designing systems to degrade gracefully when services fail; when implementing retry strategies with exponential backoff for external service calls; when cleaning up resources in finally blocks or equivalent mechanisms; when handling errors in React components with error boundaries; when logging errors for debugging and monitoring; or when structuring error handling across the application architecture.

Reference and maintain the project's technical stack including frameworks, languages, databases, testing tools, deployment infrastructure, and third-party services. Use this skill when defining or updating the technical stack; when documenting framework choices (React, Next.js, Express, Rails, Django, etc.); when specifying language and runtime versions (TypeScript, JavaScript, Python, Ruby, Node.js, etc.); when listing package managers (npm, yarn, pnpm, bundler, pip, etc.); when documenting frontend technologies (JavaScript frameworks, CSS frameworks, UI components); when specifying databases and ORMs (PostgreSQL, MySQL, MongoDB, Prisma, Sequelize, etc.); when listing testing frameworks and linting tools (Jest, Vitest, RSpec, ESLint, Prettier, etc.); when documenting deployment infrastructure (Vercel, AWS, Heroku, Railway, CI/CD tools); when specifying third-party services (Auth0, SendGrid, Sentry); or when onboarding new team members to the project's technology choices.

Implement robust input validation with server-side checks, client-side UX feedback, specific error messages, allowlist strategies, and consistent validation across all entry points. Use this skill when validating user input in web forms, API endpoints, or background jobs; when implementing server-side validation for security and data integrity; when adding client-side validation for immediate user feedback; when validating data types, formats, ranges, and required fields; when providing clear, field-specific error messages; when implementing allowlist strategies instead of blocklists; when sanitizing user input to prevent injection attacks (SQL, XSS, command injection); when validating business rules at the appropriate application layer; when applying validation consistently across web forms, API endpoints, and background jobs; or when designing validation architecture for security and user experience.

Use when completing tasks, implementing major features, or before merging to verify work meets requirements

Use when executing implementation plans with independent tasks in the current session

Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes

Write failing tests FIRST before any implementation. RED phase of RED-GREEN-REFACTOR cycle. Non-negotiable before implementing features.

Use when implementing any feature or bugfix, before writing implementation code