LobeHub

Use this skill to plan or refine product interfaces across web, desktop, and mobile. It turns broad or focused requests into stages for understanding business needs, structuring screens, improving flows and visuals, aligning components, polishing copy, and reviewing readiness.

• Designing a new landing page or dashboard
• Polishing an existing product interface
• Restoring a UI from a screenshot or unifying a design system

Use this guide when adding SPA pages or changing routers. It helps keep route files focused on page entry points, place domain logic in features, and coordinate shared, desktop, and mobile paths, including loading skeletons and platform-specific differences.

• Adding a page or dynamic route to an SPA
• Deciding whether UI or logic belongs in routes or features
• Keeping shared desktop and mobile routes in sync

Create a pull request from the current branch, usually targeting `canary`, and organize cross-layer work into stacked PRs when callers depend on a server contract. The guide covers dependency order, PR details, acceptance links, and verification steps.

• Opening a pull request for the current branch
• Splitting server and client work into ordered PRs
• Checking which layer must merge before its callers

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

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

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

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

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

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

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

Build event-driven background workflows for agents by defining sources, interpreting them as signals, and running actions through policies. It also guides asynchronous handoffs, deduplication, scoped execution, completion receipts, and observability.

• Adding a new event source to an agent workflow
• Routing interpreted signals to concrete background actions
• Enqueuing work for asynchronous processing

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 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 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

Find guidance for shaping data in Zustand stores, including list and detail types, ID-keyed maps, reducers, and shared type sources. It also points to conventions for replica-backed domain data and clarifies that the zustand skill is the automatic entry for store work.

• Choosing list and detail types for a Zustand store
• Structuring records in ID-keyed maps
• Finding guidance on reducers and shared types

Trace external CLI agent flows from launch through event conversion, tool-call persistence, and UI delivery. Use it to diagnose Claude Code or Codex adapter issues, execution identity, session boundaries, and subagent routing across the desktop and CLI pipeline.

• Debug Claude Code event or tool result handling
• Trace Codex JSONL messages across turns
• Check agent identity passed to a launched process

Plan and review Drizzle database migrations, from schema changes and safe SQL to online index creation and separate backfill scripts. The guidance also covers regenerating draft migrations during development and resolving migration conflicts after a rebase.

• Choose a rollout path for a schema change
• Create an index while limiting write disruption
• Move historical data updates into a retryable script

Plan and maintain standalone micro apps built with React Router, including server rendering or prebuilt pages, Cloudflare Workers, CDN assets, gateway routes, and previews. The guidance also covers keeping server bundles small and handling shared code across hosted environments.

• Splitting a large app into standalone micro apps
• Setting up React Router SSR or prerendered pages
• Tracing and reducing a worker's server bundle

Run the official OpenResponses compliance suite against a local or remote Response API endpoint. Check basic and streaming responses, tool calls, images, and multi-turn input, then use request and response details to investigate authentication or schema failures.

• Checking a Response API implementation against the compliance suite
• Investigating endpoint schema failures
• Running selected response tests with verbose details

Use this skill to verify a delivery by exercising the real product through a suitable surface such as a CLI, web app, desktop app, or iOS Simulator. It helps create or find a verification plan, capture evidence, and publish an acceptance report.

• Verifying a completed product change
• Collecting screenshots or other evidence
• Creating a verification plan and report

Navigate the LobeHub open-source monorepo by locating major application layers, packages, and ownership boundaries. Use the map to find where UI, routing, state, APIs, database code, and open-source business stubs live before investigating a change.

• Find the likely layer for a feature change
• Trace a request from UI to database
• Locate a package or business stub

Audit Git worktrees and local branches to find merged, stale, or otherwise removable entries. The skill groups candidates by reason, flags dirty or unpushed work for review, and guides guarded cleanup followed by a verification audit.

• Review stale worktrees before cleanup
• Find branches whose pull requests have merged
• Identify dirty or unpushed work to preserve