name: convex-tanstack description: Comprehensive guide for building full-stack applications with Convex and TanStack Start. This skill should be used when working on projects that use Convex as the backend database with TanStack Start (React meta-framework). Covers schema design, queries, mutations, actions, authentication with Better Auth, routing, data fetching patterns, SSR, file storage, scheduling, AI agents, and frontend patterns. Use this when implementing features, debugging issues, or needing guidance on Convex + TanStack Start best practices.

Convex + TanStack Start

Overview

This skill provides guidance for building reactive, real-time full-stack applications using Convex (reactive backend-as-a-service) with TanStack Start (full-stack React meta-framework). The stack provides live-updating queries, type-safe end-to-end development, SSR support, and automatic cache invalidation.

When to Use This Skill

• Implementing Convex queries, mutations, or actions
• Setting up or troubleshooting Better Auth authentication
• Configuring TanStack Router routes and loaders
• Writing schema definitions and indexes
• Implementing data fetching patterns (useQuery, useSuspenseQuery)
• Working with file storage, scheduling, or cron jobs
• Building AI agents with @convex-dev/agent
• Debugging SSR or hydration issues

Quick Reference

Essential Imports

// Data fetching (always use cached version)
import { useQuery } from 'convex-helpers/react/cache'
import { useMutation, useAction } from 'convex/react'

// SSR with React Query
import { useSuspenseQuery } from '@tanstack/react-query'
import { convexQuery } from '@convex-dev/react-query'

// API and types
import { api } from '~/convex/_generated/api'
import type { Id, Doc } from '~/convex/_generated/dataModel'

// Backend functions
import { query, mutation, action } from "./_generated/server"
import { v } from "convex/values"

The Skip Pattern

Never call hooks conditionally. Use "skip" instead:

const user = useQuery(api.users.get, userId ? { userId } : "skip")
const org = useQuery(api.orgs.get, user?.orgId ? { orgId: user.orgId } : "skip")

Three-State Query Handling

if (data === undefined) return <Skeleton />  // Loading
if (data === null) return <NotFound />       // Not found
return <Content data={data} />               // Success

Function Syntax (Always Include Returns Validator)

export const getUser = query({
  args: { userId: v.id("users") },
  returns: v.union(
    v.object({ _id: v.id("users"), name: v.string() }),
    v.null()
  ),
  handler: async (ctx, args) => {
    return await ctx.db.get(args.userId)
  },
})

Index Best Practices

// Schema - name includes all fields
.index("by_organizationId_status", ["organizationId", "status"])

// Query - fields in same order as index
.withIndex("by_organizationId_status", (q) =>
  q.eq("organizationId", orgId).eq("status", "published")
)

Auth Check (Backend)

import { authComponent } from "./auth"

const user = await authComponent.getAuthUser(ctx)
if (!user) throw new Error("Not authenticated")

Core Principles

1. Use queries for reads - Queries are reactive, cacheable, and consistent
2. Keep functions fast - Finish in < 100ms, work with < a few hundred records
3. Prefer queries/mutations over actions - Actions are for external API calls only
4. Always use indexes - Never do table scans with .filter()
5. Minimize client state - Rely on Convex's real-time sync

Common Anti-Patterns

Reference Files

Load the appropriate reference file based on the task:

When to Load References

• Starting a new project: Load 01-setup.md
• Adding authentication: Load 03-auth.md
• Writing backend functions: Load 05-backend.md
• Implementing data fetching: Load 04-data-fetching.md
• Building UI components: Load 10-frontend.md
• Need quick syntax: Load 13-quick-reference.md