openclaw

Add sign-in to a Convex app with @convex-dev/auth. The skill sets up passkeys by default, generates authentication keys, connects server and client settings, adds a sign-in interface and route protection, and verifies a real login.

• Adding passkey sign-in to a Convex app
• Setting up Google OAuth or password sign-in on request
• Configuring authentication keys and environment variables

Analyze Axiom data ingestion and query usage to identify unused columns and field values. Build cost dashboards and spike monitors, then summarize recommendations for dropping or sampling data with estimated savings.

• Find unused data that contributes to Axiom costs
• Track ingestion trends and projected spending
• Set up alerts for ingestion and query cost spikes

Investigate errors and health in a running Convex app using plain-language questions. It summarizes relevant logs with counts and representative evidence, checks deployment timing, and provides dashboard links when possible for verification.

• Summarizing recent errors by function and message
• Checking failures that appeared after a deployment
• Tracing a specific failed function call

Add an AI agent backend to a Convex app with persistent conversations, streamed messages, and tool calls. It also supports document retrieval for grounded answers, using Convex AI Gateway for model calls where available.

• Add an AI conversation feature to a Convex app
• Store conversation threads and message history
• Build answers using retrieved documents

Review and triage ClawHub issues and pull requests using current GitHub information, related code, tests, and visual evidence. Produce a maintainer review explaining the fix, alternatives considered, supporting evidence, and remaining uncertainty.

• Review a ClawHub bug fix
• Verify visual evidence for UI changes
• Compare a proposed fix with alternatives

Review code in a convex/ directory for security, access control, input and output validation, performance, and schema design. Receive findings grouped by severity, with explanations of each issue and suggested fixes before release.

• Reviewing Convex functions before release
• Checking authentication and resource access controls
• Finding inefficient queries and missing validation

Investigate production incidents and bugs using logs, metrics, and code evidence. The skill guides hypothesis testing, root cause analysis, fix validation, and reusable investigation notes, with access to configured observability tools such as Axiom.

• Investigate production outages and rising error rates
• Trace causes using logs, metrics, and code
• Reproduce bugs and validate minimal fixes

Check the Convex version installed in a project, then consult matching documentation and package type definitions to confirm API details, available exports, and command options before implementing changes or fixing version mismatch errors.

• Check an API against the installed Convex version
• Investigate missing exports or changed command options
• Find documentation for an installed component

Audit and fix four access-control problems in Convex apps: impersonation, missing ownership checks, sensitive data exposure, and writes into another user's container. Check the authentication foundation first, then verify changes with TypeScript.

• Check whether callers can impersonate another user
• Restrict document access to its owner
• Review queries that expose sensitive data

Maintain data retention in ClawHub's Convex tables by classifying each table, defining expiration fields, and bounding cleanup jobs. Guide changes to temporary data and expired authentication records, with focused tests and runtime verification.

• Classify retention policies for new tables
• Add expiration fields and indexed cleanup
• Update scheduled jobs with bounded deletion batches

Wait for the next Convex development error, production error, or feature request, then respond with investigation, a fix, or implementation. The skill combines local logs and deployment events, using polling when blocking tools are unavailable.

• Waiting for the next error during development
• Investigating and fixing newly detected production errors
• Starting implementation when a feature request arrives

Create tests for Convex functions with convex-test and vitest, using a backend that runs in memory. Check arguments, return values, authentication, indexes, errors, and scheduled functions without relying on real time or network access.

• Test Convex function arguments and return values
• Check behavior with different authentication identities
• Cover errors as well as successful requests

Identify which Convex functions drive spending by combining data read per call with call volume. Use deployment evidence or query structure to explain how costs grow with usage and data size, then suggest the cheapest fix for each driver.

• Find functions that drive Convex spending
• Assess cost growth as data and traffic increase
• Estimate future cost drivers before traffic arrives

Check pinned Convex components against recommended versions, then upgrade them individually with user approval. Each update includes migration steps, type checking, and a build check, with rollback if validation fails.

• Checking Convex components for outdated versions
• Reviewing migration details before approving an update
• Upgrading components with build checks and rollback

Build reusable Convex backend components with their own database tables and a small API, the functions an app calls. It guides component structure, app integration, authentication boundaries, and checks for generated code and type errors.

• Adding a local component to an existing Convex app
• Extracting reusable backend logic
• Building an integration with its own tables

Set up Convex snapshot backups and test recovery by restoring into a temporary environment. Verify table counts and sample records, then define a backup schedule, retention period, and production recovery instructions based on acceptable data loss.

• Setting a backup schedule based on acceptable data loss
• Testing snapshot recovery in a temporary environment
• Preparing production recovery instructions

Turn plain-language app ideas into Convex backend designs and code. Cover data structure, authentication, live updates, file storage, scheduled tasks, and LLM features, with type checking and deployment verification before treating the backend as complete.

• Building a backend from an app idea
• Adding authentication and file uploads
• Designing live collaboration or multiplayer features

Support ClawHub staff moderation through its local admin tool, including skill reports, removals and restores, user restrictions, publisher and package management, and staff email, with approval checks and verification after changes.

• Triage skill reports and restore hidden listings
• Ban users or lift account restrictions
• Manage organization publishers and package ownership

Assess an existing Convex app and turn the findings into a prioritized improvement plan. With explicit approval, update outdated components, address production error monitoring gaps, and reassess the app to show how its score changed.

• Reviewing an existing Convex app before release
• Updating outdated Convex components
• Adding production error monitoring

Publish a local Convex project to a shareable *.convex.app URL. The skill deploys the backend, builds and uploads the static web app, and guides custom domain options after publication.

• Publish a local Convex app
• Deploy the backend and web app together
• Get a live URL to share

Review code using shared OpenClaw instructions and a Python helper, while also following the target repository’s review requirements. This skill points to a common installation that supplies the actual review procedure.

• Reviewing code with shared OpenClaw instructions
• Applying repository-specific review requirements
• Keeping shared review instructions up to date

Identifies custom Convex code that an existing component or built-in feature could handle. After the current task is complete, it suggests one matching option, explains the connection to the code, and provides installation guidance without installing automatically.

• Reviewing custom scheduled jobs for a suitable component
• Finding components for rate limits or shared counters
• Considering existing options for long-running workflows

Diagnoses slow Convex features by tracing database reads, live-update subscriptions, competing writes, and function limits. Uses runtime findings or code inspection to guide fixes, checks related functions, and verifies that results remain unchanged.

• Investigating slow Convex pages or features
• Reducing excessive database reads and live-update costs
• Diagnosing write conflicts and repeated mutation retries

Plan changes to Convex data structures while an app keeps running. The skill guides staged deployments, updates to existing records, and verification for required fields, type changes, and table restructuring using @convex-dev/migrations.

• Adding required fields to existing records
• Changing field types or renaming fields
• Splitting or merging existing tables