Skills from clawhub.ai/lxgicstudios

This skill generates production-ready webhook handler code (Express/Next.js) with signature verification, idempotency, and retry utilities. It invokes the `openai` SDK via `openai.chat.completions.create`, requires `OPENAI_API_KEY`, and is run with `npx ai-webhook` which writes output to `path.resolve(options.output)`.

This skill is a CLI X/Twitter scraper for fetching tweets, profiles, searches, and timelines, installable via `npm install -g xfetch-cli`. It instructs storing/using `auth_token` and `ct0` and running `xfetch` commands that make network requests to `https://x.com/user/status/123456789` and references `https://github.com/LXGIC-Studios/xfetch`.

AI suggests routes and data to prefetch for better UX. Use when optimizing navigation performance.

Generate Zod and Yup validation schemas from TypeScript types. Use when you need runtime validation that matches your types.

Generate optimized Vercel configuration. Use when deploying to Vercel.

Generate API documentation from route files. Use when you need markdown or OpenAPI specs fast.

Generate Content Security Policy headers for your site. Use when you need to add CSP headers without spending hours reading the spec.

Generate optimized Dockerfiles for any project

Generate Playwright/Cypress E2E tests from user flows

Generate PR descriptions from your changes

Analyze SQL queries for performance and security issues

Transform, filter, merge, validate, and analyze CSV files. Zero dependencies. Powerful CSV processing from command line. Free CLI tool.

Generate CORS configuration for your stack. Use when cross-origin requests are blocked.

Scan your project and generate an optimized Dockerfile. Use when you need to containerize fast.

Generates ETL and data-transformation Node.js scripts using an AI model. The tool requires `OPENAI_API_KEY`, invokes the `openai` SDK via `openai.chat.completions.create` (network calls), and is run with `npx ai-data-transform`.

Generate Jest snapshot tests for components

Make components responsive with proper breakpoints

Generate React components from plain English descriptions. Use when you need UI components fast.

This skill generates changelogs from git history and can write output to `CHANGELOG.md` or another file. It reads `OPENAI_API_KEY`, runs `git` via `git.raw`, and sends commit text to the OpenAI API (`https://platform.openai.com/api-keys`).

Generate codemods for large-scale code changes. Use when refactoring patterns across many files.

Add meaningful inline comments to complex code. Use when documentation is lacking.

Generate a beautiful HTML landing page from your package.json. Use when you need a quick marketing page for your project.

Identify components that should be lazy loaded. Use when optimizing bundle size.

This CLI generates production-ready structured logging configs for `pino`, `winston`, or `bunyan` (e.g., run `npx ai-logger`). It requires `OPENAI_API_KEY` and calls the OpenAI API via the `openai` SDK, which is purpose-aligned network/credential use.

Generate startup pitch deck content. Use when fundraising or presenting.

Scan HTML and JSX for accessibility issues and get fix suggestions. Use when you need to catch WCAG violations before they hit production.

This skill audits authentication flows and exposes a CLI (e.g., `npx ai-auth-check ./src/auth/`) for scanning project files. It instructs executing that CLI and requires `OPENAI_API_KEY`, implying local command execution plus use of an API key.

Generate Architecture Decision Records with AI. Use when documenting technical decisions.

Generate Architecture Decision Records with AI. Use when documenting technical decisions.

Generate tests to hit uncovered code paths

This skill converts plain English into cron expressions, explains and validates cron syntax. It requires `OPENAI_API_KEY`, and includes example shell commands such as `npx ai-cron-gen "every monday at 3pm"` and links to `https://github.com/lxgicstudios/ai-cron-gen`.

Generate Cloudflare Workers configuration and code. Use when building on the edge.

Scan HTML and JSX for accessibility issues with AI-powered fix suggestions

Explain complex code in plain English

Generate role-based permission systems

Generate realistic mock data from TypeScript types

Generate database schemas from descriptions

Dangerous skill that reads `process.env.HISTFILE` (e.g., `~/.zsh_history`) and sends the raw history to OpenAI via `openai.chat.completions.create`. It claims to "filter out commands with sensitive data" while the code embeds and transmits `history` in `userContent`.

Analyzes `npm audit` JSON and returns prioritized fix commands using an OpenAI model. It runs `npm audit --json` locally and sends audit data to the OpenAI API, requiring the `OPENAI_API_KEY` environment variable.

Generate descriptive git branch names from plain English. Use when you need a branch name that follows conventions.

Get AI-powered caching strategy suggestions for your API. Use when performance matters.

This skill generates realistic mock data from descriptions, TypeScript types, or JSON schemas. It includes shell examples that run `npx ai-mock-data` and states it "sends it to an AI model", implying external network calls to `https://github.com/LXGIC-Studios` and `https://lxgic.dev`.

This skill is a Node CLI that generates CSS and Framer Motion animations from natural language. It reads `OPENAI_API_KEY` via `process.env.OPENAI_API_KEY`, calls `openai.chat.completions.create` to the OpenAI service, and writes output to the path supplied via `fs.writeFileSync(opts.output, code)`.

Make your AI agent learn and improve automatically. Reviews sessions, extracts learnings, updates memory files, and compounds knowledge over time. Set up nightly review loops that make your agent smarter every day.

Generates GitHub Actions workflows by scanning a project and synthesizing YAML from project files. It sends project file contents to the `openai` API via the `openai` SDK and requires the `OPENAI_API_KEY` environment variable.

This CLI `ai-core-vitals` scans local source files and sends combined code to OpenAI (`gpt-4o-mini`) to generate Core Web Vitals fixes. It reads files matching `**/*.{js,ts,jsx,tsx,html,css,vue,svelte}` under `./src/` and requires `OPENAI_API_KEY`.

Generates TypeScript types from a `.env` file and provides CLI installation/usage. It instructs running `npm install -g @lxgicstudios/env-typegen` / `npx @lxgicstudios/env-typegen` and reads environment variables like `API_KEY` and `.env`.

Generate database backup scripts with AI. Use when you need automated backups to S3, GCS, or local storage.

This skill is a CLI tool that generates React form components by calling the OpenAI API. It requires the `OPENAI_API_KEY` environment variable and makes network requests via the `openai` SDK.

Analyze bundle size and get AI suggestions to reduce it. Use when your builds are getting bloated.

Convert natural language to cron expressions. Use when you need to schedule tasks.

The skill explains code files in plain English and provides CLI usage such as `npx ai-explain src/utils.ts`. It instructs executing a CLI and explicitly states it `sends the content to an AI model`, causing local file reads and network transmission of the file contents.

Find untested code paths and generate tests to boost coverage. Use when your test coverage is too low and you need to fill the gaps.

Generate tailored cover letters with AI. Use when applying for jobs.

Generate Playwright end-to-end tests from a URL or component file. Use when you need e2e test coverage fast.

Generate .gitignore by analyzing your project. Use when setting up a new repo.

Detect AI-generated text patterns and get fixes. Score detection risk, find AI vocabulary, suggest improvements. Free CLI for writers and content creators.

This skill generates GitHub Actions workflow YAML from plain English using the OpenAI API. It reads the `OPENAI_API_KEY` (`process.env.OPENAI_API_KEY`) and calls `openai.chat.completions.create`, and can write workflows to `.github/workflows` or to a user-specified `opts.output`.

AI-powered git merge conflict resolution

Generate SQL queries from natural language

Summarizes git diffs into human-readable PR-ready descriptions and is invoked via `npx ai-diff-summary`. It requires `OPENAI_API_KEY` and includes CLI examples, implying use of external APIs and execution of `npx` commands.

High-risk skill that runs a remotely fetched package via `npx ai-auth-check` and scans provided code directories such as `src/`, `src/auth/`, `src/middleware/`, and `src/routes/`. It advertises auditing authentication code but includes explicit shell commands like `npx ai-auth-check src/` which download-and-execute external code.

High-risk skill: security audit for Clawdbot that reads and writes `~/.clawdbot` and runs shell commands, including piped install scripts like `curl -fsSL https://tailscale.com/install.sh | sh`. It also contacts `ifconfig.me`/`icanhazip.com`, performs `nc` port checks, and instructs setting `CLAWDBOT_GATEWAY_TOKEN` and `CLAWDBOT_DISABLE_BONJOUR` environment variables.

Convert CSS files to Tailwind utility classes. Use when migrating from vanilla CSS to Tailwind.

This CLI audits a project's `package.json` for unused and outdated dependencies and can auto-remove them via `npx ai-deps`. It executes shell commands such as `npm uninstall`, sends dependency data to OpenAI via `openai.chat.completions.create`, and requires the `OPENAI_API_KEY` env var.

This skill is a CLI tool that scans frontend components and uses the OpenAI SDK to generate dark-mode variants. It requires the `OPENAI_API_KEY` env var, includes commands like `npx ai-dark-mode ./src/components/Button.tsx`, and calls `openai.chat.completions.create` to submit file contents.

This skill generates Mermaid diagrams from a codebase and calls OpenAI via `openai.chat.completions.create`. It reads source files, requires `OPENAI_API_KEY`, and is invoked with `npx ai-diagram ./src/`.

This CLI tool (`npx ai-dark-mode ./src/components/Card.tsx` / `npx ai-dark-mode ./src/components/`) uses the OpenAI client to add dark mode to components. It requires the `OPENAI_API_KEY` env var and sends file contents to the OpenAI client (`openai.chat.completions.create`), resulting in external network calls.

Generate .env.example from your .env files. Use when onboarding developers.

Generates responsive email templates (HTML, React, MJML) via a CLI. The tool requires the `OPENAI_API_KEY` environment variable and makes network requests using the `openai` client.

This skill generates human-readable summaries of git diffs via `npx ai-diff-summary`. It runs `git diff` locally and sends the diff output to an AI model (network transmission), which involves executing shell commands and transmitting repository content.

Generates a `docker-compose.yml` by scanning the project and synthesizing YAML via OpenAI. The tool initializes the OpenAI client from `OPENAI_API_KEY` (`process.env.OPENAI_API_KEY`) and calls `openai.chat.completions.create`, which causes outbound network requests.

This skill is a CLI that generates error-handling middleware for various frameworks. It uses the `openai` SDK, requires the `OPENAI_API_KEY` environment variable, and makes network calls to the OpenAI API.

Generates an ESLint config by analyzing a codebase and calling OpenAI. It reads local files (e.g., `package.json`) and sends code samples to OpenAI, requires `OPENAI_API_KEY`, and is run via the CLI `npx ai-eslint-config .`.

Get AI-powered image optimization suggestions. Use when images are slowing your site.

Provides a CLI that analyzes local query files and suggests database indexes using an OpenAI model. It sends local query file contents to OpenAI via `openai.chat.completions.create` and requires the `OPENAI_API_KEY` environment variable.

Generate PR titles and descriptions from your branch diff. Use when you need to write pull request descriptions quickly.

Generate RBAC permission configs from your routes. Use when you need role-based access control without building it from scratch.

Generates an ESLint config by sampling a project's source files and invoking the OpenAI API. Requires `OPENAI_API_KEY` and calls `openai.chat.completions.create`, sending `package.json` and code samples to OpenAI.

This skill analyzes `package.json` and generates Husky git hooks, writing them into `.husky/` and configuring `git`. It calls the OpenAI API via `openai.chat.completions.create` (requires `OPENAI_API_KEY`) and runs `git config core.hooksPath .husky`.

Generate Prisma schema from plain English. Use when starting a database schema.

Generate rate limiting configurations using AI. Use when protecting APIs from abuse.

Generate database schemas from plain English. Use when you need SQL tables fast.

Generate Storybook stories from React components. Use when documenting components or setting up a design system.

Detect SQL injection vulnerabilities in your codebase. Use when you need to find unsafe database queries before they get exploited.

Generate tailwind.config.js from brand colors. Use when setting up Tailwind.

Generate unit tests from source files using AI. Use when adding test coverage.

Generate Terraform infrastructure configs. Use when provisioning cloud resources.

Decode and inspect JWT tokens from command line. Check expiration, extract claims, debug auth. No more jwt.io tabs. Free CLI tool.

Adds JSDoc/TSDoc comments to source files by sending file contents to OpenAI and optionally writing changes back to the filesystem. It reads/writes files matching `**/*.{ts,tsx,js,jsx}` and requires `OPENAI_API_KEY` to call OpenAI via `openai.chat.completions.create`.

Pick and generate the right license for your project. Use when licensing open source.

Generate HTML meta tags for SEO, Open Graph, Twitter Cards, JSON-LD. Copy-paste ready. Perfect for web developers. Free CLI tool.

Resolve git merge conflicts intelligently using AI. Use when the user has merge conflicts they need help resolving.

This skill converts docker-compose files or plain descriptions into Kubernetes manifests using an OpenAI model. It requires `OPENAI_API_KEY` and calls `openai.chat.completions.create`, which sends the provided input to the OpenAI service.

This skill runs a Lighthouse audit (`npx lighthouse`) and sends the report to OpenAI for AI-powered fix suggestions. It executes a shell command using a user-supplied `url` via `execSync` and requires `OPENAI_API_KEY`, creating command-execution and network risks.

Generate Next.js config with best practices. Use when configuring Next.js.

This skill scans a URL or local HTML and generates missing SEO, Open Graph, and Twitter meta tags. It sends page content to an LLM and requires the `OPENAI_API_KEY` environment variable.

Identify components that should be lazy loaded using AI. Use when optimizing bundle size and initial load.

Generates interview questions by scanning a local code directory and sending code excerpts to OpenAI. It reads files under `./src/`, requires `OPENAI_API_KEY`, and calls `openai.chat.completions.create`.

Generates SQL migration files from ORM schemas and writes timestamped `up.sql`/`down.sql` files. Requires the `OPENAI_API_KEY` env var and uses the `openai` SDK to call the OpenAI API.

Generate monitoring and alerting configs for Prometheus and Grafana. Use when setting up observability.

Generate monitoring and alerting configuration. Use when setting up observability.

This skill generates Express middleware from plain-English descriptions and writes the result to stdout or a file. It reads the `OPENAI_API_KEY` environment variable and invokes `openai.chat.completions.create` (model `gpt-4o-mini`).

Generate onboarding documentation for new developers. Use when improving dev experience.

Kill processes running on any port with one command. Cross-platform utility for developers. No more lsof grep awk xargs. Free CLI tool.

Get AI suggestions for routes and data to prefetch. Use when optimizing navigation.

Optimize SQL and Prisma queries using AI. Use when your queries are slow and you need performance help.

Generate rate limiting configuration. Use when protecting APIs from abuse.

Make components responsive with proper breakpoints. Use when your components look terrible on mobile.

Generates npm `package.json` scripts from a short workflow description via the `npx ai-script` CLI. The skill requires the `OPENAI_API_KEY` environment variable and therefore implies use of an external API and running the `npx ai-script` command.

Generate regex patterns from plain English descriptions. Use when the user needs to create regular expressions without memorizing syntax.

Generate semantic version bumps and git tags from commit history. Use when preparing a release.

This skill is a CLI that analyzes source files and suggests better variable and function names. It sends file contents to OpenAI via `new OpenAI()` (model `gpt-4o-mini`), expects `OPENAI_API_KEY`, and is invoked with `npx ai-naming`.

Generate and improve developer resumes. Use when job hunting.

Convert REST API routes to a GraphQL schema. Use when migrating APIs or adding a GraphQL layer.

This skill is an npm CLI `ai-readme` that reads `package.json` and files under `src` to generate a `README.md` using the OpenAI API. It transmits project files to an external service and requires the `OPENAI_API_KEY` environment variable.

This skill generates user-facing release notes from a repo's git history or changelog and uses the OpenAI API to rewrite them. It requires the `OPENAI_API_KEY` env var and will send repository `CHANGELOG`/git log content to the OpenAI service.

Generate social media posts for different platforms. Use when sharing content.

Generate TypeScript interfaces from JSON data or API responses. Auto-type your APIs instantly. Free CLI tool for TypeScript developers.

This skill generates Supabase RLS SQL policies from a Prisma schema using OpenAI. It requires `OPENAI_API_KEY`, is invoked via `npx ai-supabase-gen prisma/schema.prisma`, reads the input file, and sends it to `openai.chat.completions.create`.

Spin up a mock REST API server from JSON files in seconds. Full CRUD, filtering, pagination. Zero config. Free CLI tool for frontend developers.

Set up Turborepo monorepo structure. Use when starting a monorepo.

Generate nginx config from plain English. Use when configuring nginx.

Generate BullMQ job queue setup and workers. Use when implementing background jobs.

Generate Redis key patterns and data structure designs. Use when planning your Redis architecture.

This skill runs Lighthouse performance audits and generates AI-powered fix suggestions for URLs. It includes CLI usage like `npx ai-lighthouse https://mysite.com` and states it `sends the bottleneck data to an AI model`.

Generate Redis key patterns and data structures. Use when designing Redis architecture.

Generate Jest snapshot tests for React components. Use when you need snapshot coverage for your UI components.

Convert natural language to SQL queries. Use when you need to write SQL fast.

Generate file upload handling code. Use when building upload features with S3, local storage, or cloud providers.

This skill generates concise git stash names by reading repository diffs and calling OpenAI, then runs `git stash push -m` to create the stash. It requires `OPENAI_API_KEY` and makes network calls to the OpenAI service (purpose-aligned network and API-key usage).

Generate WebSocket handlers with Socket.io. Use when building real-time features.

Generates OpenAPI 3.0 specs from Express routes by reading route files and using OpenAI to infer schemas. It reads `./src/routes/` (or a supplied path), requires `OPENAI_API_KEY`, sends file contents to OpenAI, and is invoked via `npx ai-swagger ./src/routes/`.

This skill generates a project wiki by scanning a user-supplied source directory (e.g., `./src/`) and sending code snippets to the OpenAI client. It requires `OPENAI_API_KEY` and calls `openai.chat.completions.create`, so it reads local source files and performs network requests to the OpenAI service.

This tool analyzes and refactors code files, producing colored diffs and optionally writing changes back to the target file. It sends file contents to the OpenAI model `gpt-4o-mini` via `openai.chat.completions.create` and requires the `OPENAI_API_KEY` environment variable.

This skill generates realistic database seed data from a provided schema using OpenAI. It requires `OPENAI_API_KEY` and sends the schema to OpenAI via `openai.chat.completions.create`, with no other sensitive or obfuscated operations present.

This skill is a Solidity smart contract security scanner offering a CLI (examples: `npm install -g solaudit-cli`, `solaudit audit Contract.sol`) to analyze `Contract.sol` or `./contracts/`. It instructs running shell commands and performing network operations (e.g., `https://github.com/lxgicstudios/solaudit`).

This skill is a CLI tool that reads a user-specified code file and sends it to OpenAI for a humorous, actionable code review. It reads files such as `./src/index.ts`, is run via `npx ai-roast ./src/index.ts`, and requires the `OPENAI_API_KEY` environment variable.

Generate Supabase RLS policies from Prisma schema. Use when securing database.

Generates VS Code snippets by scanning a provided directory (e.g., `./src/`) and sending code excerpts to OpenAI. The tool requires the `OPENAI_API_KEY` environment variable and performs network calls to the OpenAI client; no other security-relevant behaviors were detected.

Generate unit tests from source files. Use when you need test coverage fast.

Get current weather and forecasts (no API key required).

This skill generates a design system/theme from brand colors using the OpenAI API. It requires `OPENAI_API_KEY`, invokes `openai.chat.completions.create` (network access), and provides CLI usage like `npx ai-theme` that can write output files such as `./theme.css`.

Extract YouTube video info, channel stats, playlists, comments. No API key required. Free CLI tool for content research and analysis.

This skill is a CLI that scans project source files and sends combined code to the OpenAI API to produce Core Web Vitals fixes. It requires the `OPENAI_API_KEY` env var and uses the `openai` SDK to make network requests, which are purpose-aligned credential and network uses.

This skill generates project-specific tsconfig.json files and writes them to `tsconfig.json` by default. It calls the OpenAI API via the `openai` client and expects the `OPENAI_API_KEY` environment variable.

Complete X (Twitter) algorithm mastery - engagement weights, viral formulas, shadow ban avoidance, thread optimization, and growth strategies. Based on X's open-source code analysis and real creator data.