diff --git a/CATALOG.md b/CATALOG.md
index 744d337c..67ce313d 100644
--- a/CATALOG.md
+++ b/CATALOG.md
@@ -2,7 +2,7 @@
 
 Generated at: 2026-02-08T00:00:00.000Z
 
-Total skills: 978
+Total skills: 979
 
 ## architecture (67)
 
@@ -132,7 +132,7 @@ calculations | startup, business, analyst, market, opportunity | startup, busine
 | `startup-financial-modeling` | This skill should be used when the user asks to \\\"create financial projections", "build a financial model", "forecast revenue", "calculate burn rate", "est... | startup, financial, modeling | startup, financial, modeling, skill, should, used, user, asks, projections, model, forecast, revenue |
 | `whatsapp-automation` | Automate WhatsApp Business tasks via Rube MCP (Composio): send messages, manage templates, upload media, and handle contacts. Always search tools first for c... | whatsapp | whatsapp, automation, automate, business, tasks, via, rube, mcp, composio, send, messages, upload |
 
-## data-ai (179)
+## data-ai (180)
 
 | Skill | Description | Tags | Triggers |
 | --- | --- | --- | --- |
@@ -237,6 +237,7 @@ calculations | startup, business, analyst, market, opportunity | startup, busine
 | `dbt-transformation-patterns` | Master dbt (data build tool) for analytics engineering with model organization, testing, documentation, and incremental strategies. Use when building data tr... | dbt, transformation | dbt, transformation, data, analytics, engineering, model, organization, testing, documentation, incremental, building, transformations |
 | `documentation-generation-doc-generate` | You are a documentation expert specializing in creating comprehensive, maintainable documentation from code. Generate API docs, architecture diagrams, user g... | documentation, generation, doc, generate | documentation, generation, doc, generate, specializing, creating, maintainable, code, api, docs, architecture, diagrams |
 | `documentation-templates` | Documentation templates and structure guidelines. README, API docs, code comments, and AI-friendly documentation. | documentation | documentation, structure, guidelines, readme, api, docs, code, comments, ai, friendly |
+| `drizzle-orm-expert` | Expert in Drizzle ORM for TypeScript — schema design, relational queries, migrations, and serverless database integration. Use when building type-safe databa... | drizzle, orm | drizzle, orm, typescript, schema, relational, queries, migrations, serverless, database, integration, building, type |
 | `embedding-strategies` | Select and optimize embedding models for semantic search and RAG applications. Use when choosing embedding models, implementing chunking strategies, or optim... | embedding, strategies | embedding, strategies, select, optimize, models, semantic, search, rag, applications, choosing, implementing, chunking |
 | `fal-audio` | Text-to-speech and speech-to-text using fal.ai audio models | fal, audio | fal, audio, text, speech, ai, models |
 | `fal-generate` | Generate images and videos using fal.ai AI models | fal, generate | fal, generate, images, videos, ai, models |
diff --git a/README.md b/README.md
index bf46c95e..68e4b5ed 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
-# 🌌 Antigravity Awesome Skills: 978+ Agentic Skills for Claude Code, Gemini CLI, Cursor, Copilot & More
+# 🌌 Antigravity Awesome Skills: 979+ Agentic Skills for Claude Code, Gemini CLI, Cursor, Copilot & More
 
-> **The Ultimate Collection of 978+ Universal Agentic Skills for AI Coding Assistants — Claude Code, Gemini CLI, Codex CLI, Antigravity IDE, GitHub Copilot, Cursor, OpenCode, AdaL**
+> **The Ultimate Collection of 979+ Universal Agentic Skills for AI Coding Assistants — Claude Code, Gemini CLI, Codex CLI, Antigravity IDE, GitHub Copilot, Cursor, OpenCode, AdaL**
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Claude Code](https://img.shields.io/badge/Claude%20Code-Anthropic-purple)](https://claude.ai)
@@ -42,7 +42,7 @@ This repository provides essential skills to transform your AI assistant into a
 - [🎁 Curated Collections (Bundles)](#curated-collections)
 - [🧭 Antigravity Workflows](#antigravity-workflows)
 - [📦 Features & Categories](#features--categories)
-- [📚 Browse 978+ Skills](#browse-978-skills)
+- [📚 Browse 979+ Skills](#browse-979-skills)
 - [🤝 How to Contribute](#how-to-contribute)
 - [💬 Community](#community)
 - [☕ Support the Project](#support-the-project)
@@ -341,7 +341,7 @@ The repository is organized into specialized domains to transform your AI into a
 
 Counts change as new skills are added. For the current full registry, see [CATALOG.md](CATALOG.md).
 
-## Browse 978+ Skills
+## Browse 979+ Skills
 
 We have moved the full skill registry to a dedicated catalog to keep this README clean, and we've also introduced an interactive **Web App**!
 
diff --git a/data/bundles.json b/data/bundles.json
index 271e473a..db8df3c4 100644
--- a/data/bundles.json
+++ b/data/bundles.json
@@ -138,6 +138,7 @@
         "dotnet-architect",
         "dotnet-backend",
         "dotnet-backend-patterns",
+        "drizzle-orm-expert",
         "exa-search",
         "fastapi-pro",
         "fastapi-router-py",
@@ -441,6 +442,7 @@
         "database-migrations-sql-migrations",
         "database-optimizer",
         "dbt-transformation-patterns",
+        "drizzle-orm-expert",
         "firebase",
         "fp-ts-react",
         "frontend-dev-guidelines",
diff --git a/data/catalog.json b/data/catalog.json
index 95e8a6a1..6246a6a4 100644
--- a/data/catalog.json
+++ b/data/catalog.json
@@ -1,6 +1,6 @@
 {
   "generatedAt": "2026-02-08T00:00:00.000Z",
-  "total": 978,
+  "total": 979,
   "skills": [
     {
       "id": "00-andruia-consultant",
@@ -9871,6 +9871,31 @@
       ],
       "path": "skills/dotnet-backend-patterns/SKILL.md"
     },
+    {
+      "id": "drizzle-orm-expert",
+      "name": "drizzle-orm-expert",
+      "description": "Expert in Drizzle ORM for TypeScript — schema design, relational queries, migrations, and serverless database integration. Use when building type-safe database layers with Drizzle.",
+      "category": "data-ai",
+      "tags": [
+        "drizzle",
+        "orm"
+      ],
+      "triggers": [
+        "drizzle",
+        "orm",
+        "typescript",
+        "schema",
+        "relational",
+        "queries",
+        "migrations",
+        "serverless",
+        "database",
+        "integration",
+        "building",
+        "type"
+      ],
+      "path": "skills/drizzle-orm-expert/SKILL.md"
+    },
     {
       "id": "dropbox-automation",
       "name": "dropbox-automation",
diff --git a/skills/drizzle-orm-expert/SKILL.md b/skills/drizzle-orm-expert/SKILL.md
new file mode 100644
index 00000000..5aa08603
--- /dev/null
+++ b/skills/drizzle-orm-expert/SKILL.md
@@ -0,0 +1,363 @@
+---
+name: drizzle-orm-expert
+description: "Expert in Drizzle ORM for TypeScript — schema design, relational queries, migrations, and serverless database integration. Use when building type-safe database layers with Drizzle."
+risk: safe
+source: community
+date_added: "2026-03-04"
+---
+
+# Drizzle ORM Expert
+
+You are a production-grade Drizzle ORM expert. You help developers build type-safe, performant database layers using Drizzle ORM with TypeScript. You know schema design, the relational query API, Drizzle Kit migrations, and integrations with Next.js, tRPC, and serverless databases (Neon, PlanetScale, Turso, Supabase).
+
+## When to Use This Skill
+
+- Use when the user asks to set up Drizzle ORM in a new or existing project
+- Use when designing database schemas with Drizzle's TypeScript-first approach
+- Use when writing complex relational queries (joins, subqueries, aggregations)
+- Use when setting up or troubleshooting Drizzle Kit migrations
+- Use when integrating Drizzle with Next.js App Router, tRPC, or Hono
+- Use when optimizing database performance (prepared statements, batching, connection pooling)
+- Use when migrating from Prisma, TypeORM, or Knex to Drizzle
+
+## Core Concepts
+
+### Why Drizzle
+
+Drizzle ORM is a TypeScript-first ORM that generates zero runtime overhead. Unlike Prisma (which uses a query engine binary), Drizzle compiles to raw SQL — making it ideal for edge runtimes and serverless. Key advantages:
+
+- **SQL-like API**: If you know SQL, you know Drizzle
+- **Zero dependencies**: Tiny bundle, works in Cloudflare Workers, Vercel Edge, Deno
+- **Full type inference**: Schema → types → queries are all connected at compile time
+- **Relational Query API**: Prisma-like nested includes without N+1 problems
+
+## Schema Design Patterns
+
+### Table Definitions
+
+```typescript
+// db/schema.ts
+import { pgTable, text, integer, timestamp, boolean, uuid, pgEnum } from "drizzle-orm/pg-core";
+import { relations } from "drizzle-orm";
+
+// Enums
+export const roleEnum = pgEnum("role", ["admin", "user", "moderator"]);
+
+// Users table
+export const users = pgTable("users", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  email: text("email").notNull().unique(),
+  name: text("name").notNull(),
+  role: roleEnum("role").default("user").notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull(),
+});
+
+// Posts table with foreign key
+export const posts = pgTable("posts", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  title: text("title").notNull(),
+  content: text("content"),
+  published: boolean("published").default(false).notNull(),
+  authorId: uuid("author_id").references(() => users.id, { onDelete: "cascade" }).notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+});
+```
+
+### Relations
+
+```typescript
+// db/relations.ts
+export const usersRelations = relations(users, ({ many }) => ({
+  posts: many(posts),
+}));
+
+export const postsRelations = relations(posts, ({ one }) => ({
+  author: one(users, {
+    fields: [posts.authorId],
+    references: [users.id],
+  }),
+}));
+```
+
+### Type Inference
+
+```typescript
+// Infer types directly from your schema — no separate type files needed
+import type { InferSelectModel, InferInsertModel } from "drizzle-orm";
+
+export type User = InferSelectModel<typeof users>;
+export type NewUser = InferInsertModel<typeof users>;
+export type Post = InferSelectModel<typeof posts>;
+export type NewPost = InferInsertModel<typeof posts>;
+```
+
+## Query Patterns
+
+### Select Queries (SQL-like API)
+
+```typescript
+import { eq, and, like, desc, count, sql } from "drizzle-orm";
+
+// Basic select
+const allUsers = await db.select().from(users);
+
+// Filtered with conditions
+const admins = await db.select().from(users).where(eq(users.role, "admin"));
+
+// Partial select (only specific columns)
+const emails = await db.select({ email: users.email }).from(users);
+
+// Join query
+const postsWithAuthors = await db
+  .select({
+    title: posts.title,
+    authorName: users.name,
+  })
+  .from(posts)
+  .innerJoin(users, eq(posts.authorId, users.id))
+  .where(eq(posts.published, true))
+  .orderBy(desc(posts.createdAt))
+  .limit(10);
+
+// Aggregation
+const postCounts = await db
+  .select({
+    authorId: posts.authorId,
+    postCount: count(posts.id),
+  })
+  .from(posts)
+  .groupBy(posts.authorId);
+```
+
+### Relational Queries (Prisma-like API)
+
+```typescript
+// Nested includes — Drizzle resolves in a single query
+const usersWithPosts = await db.query.users.findMany({
+  with: {
+    posts: {
+      where: eq(posts.published, true),
+      orderBy: [desc(posts.createdAt)],
+      limit: 5,
+    },
+  },
+});
+
+// Find one with nested data
+const user = await db.query.users.findFirst({
+  where: eq(users.id, userId),
+  with: { posts: true },
+});
+```
+
+### Insert, Update, Delete
+
+```typescript
+// Insert with returning
+const [newUser] = await db
+  .insert(users)
+  .values({ email: "dev@example.com", name: "Dev" })
+  .returning();
+
+// Batch insert
+await db.insert(posts).values([
+  { title: "Post 1", authorId: newUser.id },
+  { title: "Post 2", authorId: newUser.id },
+]);
+
+// Update
+await db.update(users).set({ name: "Updated" }).where(eq(users.id, userId));
+
+// Delete
+await db.delete(posts).where(eq(posts.authorId, userId));
+```
+
+### Transactions
+
+```typescript
+const result = await db.transaction(async (tx) => {
+  const [user] = await tx.insert(users).values({ email, name }).returning();
+  await tx.insert(posts).values({ title: "Welcome Post", authorId: user.id });
+  return user;
+});
+```
+
+## Migration Workflow (Drizzle Kit)
+
+### Configuration
+
+```typescript
+// drizzle.config.ts
+import { defineConfig } from "drizzle-kit";
+
+export default defineConfig({
+  schema: "./db/schema.ts",
+  out: "./drizzle",
+  dialect: "postgresql",
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+});
+```
+
+### Commands
+
+```bash
+# Generate migration SQL from schema changes
+npx drizzle-kit generate
+
+# Push schema directly to database (development only — skips migration files)
+npx drizzle-kit push
+
+# Run pending migrations (production)
+npx drizzle-kit migrate
+
+# Open Drizzle Studio (GUI database browser)
+npx drizzle-kit studio
+```
+
+## Database Client Setup
+
+### PostgreSQL (Neon Serverless)
+
+```typescript
+// db/index.ts
+import { drizzle } from "drizzle-orm/neon-http";
+import { neon } from "@neondatabase/serverless";
+import * as schema from "./schema";
+
+const sql = neon(process.env.DATABASE_URL!);
+export const db = drizzle(sql, { schema });
+```
+
+### SQLite (Turso/LibSQL)
+
+```typescript
+import { drizzle } from "drizzle-orm/libsql";
+import { createClient } from "@libsql/client";
+import * as schema from "./schema";
+
+const client = createClient({
+  url: process.env.TURSO_DATABASE_URL!,
+  authToken: process.env.TURSO_AUTH_TOKEN,
+});
+export const db = drizzle(client, { schema });
+```
+
+### MySQL (PlanetScale)
+
+```typescript
+import { drizzle } from "drizzle-orm/planetscale-serverless";
+import { Client } from "@planetscale/database";
+import * as schema from "./schema";
+
+const client = new Client({ url: process.env.DATABASE_URL! });
+export const db = drizzle(client, { schema });
+```
+
+## Performance Optimization
+
+### Prepared Statements
+
+```typescript
+// Prepare once, execute many times
+const getUserById = db.query.users
+  .findFirst({
+    where: eq(users.id, sql.placeholder("id")),
+  })
+  .prepare("get_user_by_id");
+
+// Execute with parameters
+const user = await getUserById.execute({ id: "abc-123" });
+```
+
+### Batch Operations
+
+```typescript
+// Use db.batch() for multiple independent queries in one round-trip
+const [allUsers, recentPosts] = await db.batch([
+  db.select().from(users),
+  db.select().from(posts).orderBy(desc(posts.createdAt)).limit(10),
+]);
+```
+
+### Indexing in Schema
+
+```typescript
+import { index, uniqueIndex } from "drizzle-orm/pg-core";
+
+export const posts = pgTable(
+  "posts",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    title: text("title").notNull(),
+    authorId: uuid("author_id").references(() => users.id).notNull(),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+  },
+  (table) => [
+    index("posts_author_idx").on(table.authorId),
+    index("posts_created_idx").on(table.createdAt),
+  ]
+);
+```
+
+## Next.js Integration
+
+### Server Component Usage
+
+```typescript
+// app/users/page.tsx (React Server Component)
+import { db } from "@/db";
+import { users } from "@/db/schema";
+
+export default async function UsersPage() {
+  const allUsers = await db.select().from(users);
+  return (
+    <ul>
+      {allUsers.map((u) => (
+        <li key={u.id}>{u.name}</li>
+      ))}
+    </ul>
+  );
+}
+```
+
+### Server Action
+
+```typescript
+// app/actions.ts
+"use server";
+import { db } from "@/db";
+import { users } from "@/db/schema";
+
+export async function createUser(formData: FormData) {
+  const name = formData.get("name") as string;
+  const email = formData.get("email") as string;
+  await db.insert(users).values({ name, email });
+}
+```
+
+## Best Practices
+
+- ✅ **Do:** Keep all schema definitions in a single `db/schema.ts` or split by domain (`db/schema/users.ts`, `db/schema/posts.ts`)
+- ✅ **Do:** Use `InferSelectModel` and `InferInsertModel` for type safety instead of manual interfaces
+- ✅ **Do:** Use the relational query API (`db.query.*`) for nested data to avoid N+1 problems
+- ✅ **Do:** Use prepared statements for frequently executed queries in production
+- ✅ **Do:** Use `drizzle-kit generate` + `migrate` in production (never `push`)
+- ✅ **Do:** Pass `{ schema }` to `drizzle()` to enable the relational query API
+- ❌ **Don't:** Use `drizzle-kit push` in production — it can cause data loss
+- ❌ **Don't:** Write raw SQL when the Drizzle query builder supports the operation
+- ❌ **Don't:** Forget to define `relations()` if you want to use `db.query.*` with `with`
+- ❌ **Don't:** Create a new database connection per request in serverless — use connection pooling
+
+## Troubleshooting
+
+**Problem:** `db.query.tableName` is undefined
+**Solution:** Pass all schema objects (including relations) to `drizzle()`: `drizzle(client, { schema })`
+
+**Problem:** Migration conflicts after schema changes
+**Solution:** Run `npx drizzle-kit generate` to create a new migration, then `npx drizzle-kit migrate`
+
+**Problem:** Type errors on `.returning()` with MySQL
+**Solution:** MySQL does not support `RETURNING`. Use `.execute()` and read `insertId` from the result instead.
diff --git a/skills_index.json b/skills_index.json
index a025d2ba..a5c1e2bc 100644
--- a/skills_index.json
+++ b/skills_index.json
@@ -4039,6 +4039,16 @@
     "source": "personal",
     "date_added": "2026-02-27"
   },
+  {
+    "id": "drizzle-orm-expert",
+    "path": "skills/drizzle-orm-expert",
+    "category": "uncategorized",
+    "name": "drizzle-orm-expert",
+    "description": "Expert in Drizzle ORM for TypeScript \u2014 schema design, relational queries, migrations, and serverless database integration. Use when building type-safe database layers with Drizzle.",
+    "risk": "safe",
+    "source": "community",
+    "date_added": "2026-03-04"
+  },
   {
     "id": "dropbox-automation",
     "path": "skills/dropbox-automation",