LobeHub

Shape Zustand stores with clear state types, selectors, and separate action classes. Use local-replica for server-backed lists and details, including hydration and optimistic updates that roll back on failure, while following legacy patterns where needed.

• Choose state and type shapes for a Zustand store
• Build replica-backed list and detail data
• Add optimistic updates with rollback after a failed request

Audit one screen using code, rendered screenshots, and an automated user journey as needed. The review records evidence for strengths and gaps, checks the screen against interface patterns and UX checklists, and feeds general lessons back into those checklists.

• Auditing one page against UX standards
• Checking rendered layout and responsive states
• Measuring a user journey and its performance

Use interaction principles and checklists to design or review user-facing flows. It helps check how screens handle empty, loading, and error states, preserve drafts, guide actions, and reveal advanced options as needed.

• Designing a new user flow
• Reviewing empty, loading, and error states
• Checking draft safety and action feedback

Draft and maintain public website guides for self-hosting, deployment, migration, and configuration. It checks claims against current code, keeps English and Simplified Chinese pages aligned, and updates links and tested redirects when published paths change.

• Write a self-hosting guide
• Document deployment or configuration steps
• Update a guide after a published URL changes

Use this skill to prepare minor or patch releases, follow the expected branch and pull request workflow, and write GitHub Release notes. It explains which changes trigger automated tagging and release creation, and which versioning steps CI handles.

• Preparing a minor feature release
• Preparing a weekly patch or hotfix
• Checking whether a pull request triggers a release

Use this guide when adding server-side tRPC routers, queries, mutations, or API endpoints. It explains input validation, model access through middleware, response shapes, parallel detail queries, and consistent error handling for code in the server router area.

• Adding a query or mutation to a server router
• Validating procedure inputs with Zod schemas
• Combining related records in a detail endpoint

Use this guide to create a fully interactive, single-file HTML prototype with the repository’s actual LobeHub UI components and styles. It explains the runtime setup, theming, and interaction checks so teams can explore screen behavior before production implementation.

• Prototyping an interactive product screen
• Trying light and dark themes with real UI components
• Demonstrating loading, empty, or error states

Use this skill to clarify what a product surface should do and why before settling its layout. It grounds recommendations in business and user evidence, identifies structural problems, and frames scope and unresolved decisions for a design or prototype when requested.

• Clarifying the purpose of a new product surface
• Reframing a vague redesign request around user tasks
• Checking whether a screen reflects real business concepts

Manage Linear issues from initial lookup through completion by checking descriptions and images, updating status, and posting concise results. It also helps break larger work into ordered, nested sub-issues with clear dependencies and self-contained acceptance criteria.

• Reviewing a Linear issue before starting work
• Updating issue status and adding completion notes
• Breaking a project issue into ordered sub-issues

Maintain alint rules for code issues that deterministic linters cannot express. Add and calibrate rules against real source, classify true and false findings, decide when a rule can become an error, and track token costs while keeping noisy checks out of pull request reviews.

• Adding or narrowing a model-backed lint rule
• Checking rule findings for false positives in source code
• Deciding whether a warning is ready to become an error

Use this guide when adding or extending a LobeHub builtin agent tool. It covers the tool manifest and types, runtime and frontend executor, chat interface surfaces, and registry wiring, with conventions for connecting them consistently.

• Creating a new builtin tool package
• Adding an API method to an existing tool
• Building an Inspector or result view

Use this skill to define Drizzle ORM tables, columns, indexes, relations, and inferred TypeScript types, then write schema-aware queries with explicit joins and aggregations. It also guides choices around typed JSONB fields and raw SQL.

• Defining a new database table and its indexes
• Writing typed queries with joins or aggregations
• Reviewing Drizzle schema and query conventions

Guide changes to full-text search across product data such as messages, files, and documents. It covers PostgreSQL and Elasticsearch providers, permission-preserving results, document mappings, incremental sync, reindexing, and performance considerations; external web search is outside its scope.

• Adding a searchable product data entity
• Changing PostgreSQL or Elasticsearch search behavior
• Updating document mappings and projections

Use this skill to run end-to-end acceptance checks for bot channels in real desktop chat apps. It drives apps such as Discord, Slack, Telegram, WeChat, Lark, and QQ to send a message, wait for a response, and capture the result.

• Checking a bot response in a real Discord channel
• Testing chat behavior through Slack or Telegram
• Capturing a bot interaction in a native macOS app

Review a project's skill files for duplicates, overlapping purposes, stale references, and descriptions that no longer match their instructions. Get specific findings with file evidence and suggested changes to guide cleanup or maintenance.

• Check a skill collection for duplicates and overlapping triggers
• Find references to skills or files that have been renamed or removed
• Review whether skill descriptions still match their instructions

Inspect recorded agent runs by operation ID to see failed tool calls, their arguments and results, available tools, execution context, and LLM inputs. The CLI also supports context maps and replaying recorded calls with different models for comparison.

• Finding why an agent tool call failed
• Checking which tools and context an operation received
• Viewing the messages sent to an LLM

Implement the registry that turns agent-created or edited resources into durable Work records and cards with version history. Covers deduplication, skill-provider results, shell CLI scans, file and task registration, and access rules for shared conversations.

• Register GitHub or Linear results as Work cards
• Prevent duplicate Work records while preserving version history
• Scan CLI output for created or edited resources

Organize user-facing text for a react-i18next app by adding locale keys, choosing namespaces, and using interpolation. Follow the translation workflow, preview English and Chinese changes, and handle changed source text so generated translations do not remain stale.

• Adding translated text to a react-i18next feature
• Choosing keys and namespaces for interface strings
• Updating translations after changing English source text

Build asynchronous workflows with Upstash Workflow and QStash using a staged design: preview work, paginate and fan out large batches, then process one item per run. The guide also covers flow control, retries, and deployment setup.

• Design a workflow that previews work before execution
• Split a large batch into paginated, parallel tasks
• Implement a handler that processes one item per run

Use this diagnostic extension to investigate intermittent frontend bugs, stale state, ordering issues, navigation problems, or browser-only behavior. It helps trace the same data across rendering, client state, and server boundaries, then identify where the incorrect result first appears.

• Tracing an intermittent UI issue across data layers
• Investigating stale state after navigation or refresh
• Finding where item ordering becomes incorrect

Use this skill to add a server-side environment variable that sets a default for a user setting. It walks through validation, server configuration and store merging, plus updating the example environment file and self-hosting documentation.

• Adding an environment variable for a setting default
• Wiring a new setting domain into server config
• Documenting a new variable for self-hosting

Use this guide to write and diagnose Vitest tests across an application and its packages. It covers mock choices, behavior-focused assertions, database integration tests, UI library mocks, and deciding whether failing tests should be updated or removed.

• Writing a regression test for a bug fix
• Diagnosing a failing Vitest test
• Choosing mocks and assertions for database or UI tests

Add and register keyboard shortcuts in an existing application. The guide covers key combinations, scope, grouping, translations, hooks, optional tooltips, and checks for conflicts with browser or system shortcuts.

• Adding a shortcut for an application action
• Choosing where a shortcut is active
• Checking shortcut registration or conflicts

Follow an existing codebase’s conventions for source and test file placement, naming, exports, and splitting files over 1,200 lines. The guide explains how to organize extracted modules while preserving import paths and behavior.

• Choosing where a new source file belongs
• Placing tests beside the code they cover
• Planning a large file split