Vibe Coding

Claude Code

Mon, 01 Jan 0001 00:00:00 +0000

Claude Code runs in your terminal and works like a senior engineer with full access to your codebase: it can search files, run shell commands, edit code across multiple files, run tests, and commit changes — all while narrating what it’s doing.

Claude Opus 5

Mon, 01 Jan 0001 00:00:00 +0000

Claude Opus 5 is Anthropic’s top-tier model, tuned specifically for agentic coding — multi-file features, large refactors, and end-to-end implementation work rather than single-shot completions. Give it a full task specification up front and it tends to run the whole way to a finished result instead of leaving stubs behind.

Filesystem

Mon, 01 Jan 0001 00:00:00 +0000

The Filesystem server exposes a sandboxed slice of your local disk to an agent — reading, writing, listing, and searching files within directories you explicitly allow.

Why it matters

It’s one of the original reference MCP servers, and the clearest example of the protocol’s core promise: instead of every agent vendor writing its own file-access layer, any MCP-compatible client can use this one server.

Model Context Protocol Docs

Mon, 01 Jan 0001 00:00:00 +0000

The official home for the Model Context Protocol specification: how the handshake works, how tools and resources are defined, and reference documentation for building both clients and servers.

Start here if you want to understand MCP at the protocol level rather than just using pre-built servers from the directory.

PDF

Mon, 01 Jan 0001 00:00:00 +0000

The PDF skill packages the specific know-how needed to work with PDFs reliably: filling form fields, extracting text and tables, merging or splitting documents, and generating new PDFs from scratch — using the right libraries and avoiding common formatting pitfalls.

Claude Code GitHub Repository

Mon, 01 Jan 0001 00:00:00 +0000

The public GitHub repository backing Claude Code — where releases are tracked, issues are filed, and changes to the CLI agent are documented over time.

Useful for checking what changed in a recent release, filing a bug, or seeing how other users are running into and working around specific issues.

Claude Sonnet 5

Mon, 01 Jan 0001 00:00:00 +0000

Claude Sonnet 5 closes most of the gap to Opus-tier quality on coding and agentic tasks while staying meaningfully cheaper — a solid default for the coding work that makes up most of a normal week, not just the hardest 20%.

Cursor

Mon, 01 Jan 0001 00:00:00 +0000

Cursor takes the familiar VS Code shell and rebuilds the editing experience around AI: inline “Cmd+K” edits, a chat sidebar with full repo context, and an agent mode that can plan and execute multi-file changes.

DOCX

Mon, 01 Jan 0001 00:00:00 +0000

The DOCX skill covers creating and editing Microsoft Word documents programmatically — headings, styles, tables, tracked changes — in a way that produces files that open correctly in Word rather than malformed XML.

GitHub

Mon, 01 Jan 0001 00:00:00 +0000

The GitHub MCP server lets an agent create and comment on issues, open pull requests, search code and repositories, and manage branches — all through GitHub’s API instead of shelling out to git and gh directly.

Anthropic Engineering Blog

Mon, 01 Jan 0001 00:00:00 +0000

Anthropic’s engineering blog covers practical, implementation-level writing on building with AI — agent design patterns, evaluation methodology, and lessons from building Anthropic’s own tools.

A good source for grounded, non-hype thinking on why certain agent architectures work better than others.

GitHub Copilot

Mon, 01 Jan 0001 00:00:00 +0000

Copilot started as an autocomplete extension and has grown into a full assistant: inline suggestions, a chat pane, a CLI, and an agent mode that can open pull requests on its own.

GPT-5.6 Sol

Mon, 01 Jan 0001 00:00:00 +0000

GPT-5.6 Sol is the top tier of OpenAI’s three-model GPT-5.6 lineup (Luna, Terra, Sol), positioned as the strongest option for coding, enterprise work, and cybersecurity tasks, with a claim on efficiency alongside raw capability.

Postgres

Mon, 01 Jan 0001 00:00:00 +0000

The Postgres server gives an agent introspection into a database’s schema — tables, columns, relationships — and the ability to run read-only queries against it.

Why it matters

Without this, an agent writing SQL is guessing at your schema from memory or from whatever you paste in. With direct, read-only access, it can verify a query actually runs and returns the shape of data you expect before you ever run it yourself.

PPTX

Mon, 01 Jan 0001 00:00:00 +0000

The PPTX skill packages the conventions needed to generate and edit PowerPoint presentations: slide layouts, text formatting, speaker notes, and basic chart or image placement, producing files that open cleanly in PowerPoint or Keynote.

Gemini 3.1 Pro

Mon, 01 Jan 0001 00:00:00 +0000

Gemini 3.1 Pro is Google’s flagship coding and reasoning model — Gemini 3.5 Pro hasn’t shipped yet, so 3.1 Pro remains the top tier of the Gemini line for complex, multi-step work.

Simon Willison's Blog

Mon, 01 Jan 0001 00:00:00 +0000

Simon Willison writes frequently and specifically about AI coding tools — hands-on reviews, careful benchmarking, and clear-eyed commentary that cuts through a lot of the surrounding hype.

Particularly useful for grounded takes on how well a new tool or model actually performs at real coding tasks, rather than marketing claims.

Slack

Mon, 01 Jan 0001 00:00:00 +0000

The Slack server connects an agent to a workspace — listing channels, reading recent messages, searching history, and posting replies — using a bot token scoped to whatever permissions you grant it.

XLSX

Mon, 01 Jan 0001 00:00:00 +0000

The XLSX skill covers working with Excel files properly: writing real formulas rather than pre-computed values, applying number formats and styles, and managing multiple sheets and references correctly.

Why a skill for this

It’s easy for an agent to produce a spreadsheet that looks right but is actually just static values pasted where formulas should be — which breaks the moment the underlying data changes. This skill steers toward spreadsheets that behave the way a human analyst would build them.

Canvas Design

Mon, 01 Jan 0001 00:00:00 +0000

The Canvas Design skill packages visual design judgment: spacing systems, typographic hierarchy, color restraint, and layout composition — the kind of taste that’s easy to describe but hard to consistently apply prompt by prompt.

Grok 4.6

Mon, 01 Jan 0001 00:00:00 +0000

Grok 4.6 is xAI’s frontier model for coding, agentic tasks, and knowledge work, and the current flagship behind Grok Build — xAI’s dedicated coding agent and terminal UI.

Why it stands out

Aggressive tiered pricing — a lower rate below 200K prompt tokens and a scaled-up rate above it, so short-context coding sessions stay cheap.
Grok Build, xAI’s open-source coding agent and TUI, gives it a purpose-built harness rather than relying only on third-party tools.
500K-token context window, comfortably large for most real-world coding sessions.

Good for

Fast, iterative agentic coding workflows — especially teams already using Grok Build or wanting a cheaper alternative to the largest frontier models for everyday agent loops.

Latent Space

Mon, 01 Jan 0001 00:00:00 +0000

Latent Space covers the AI engineering space through both a newsletter and podcast, with interviews and deep dives that regularly touch on coding agents, developer tooling, and the people building them.

Puppeteer

Mon, 01 Jan 0001 00:00:00 +0000

The Puppeteer server gives an agent control of a real (or headless) Chrome browser — navigating to URLs, clicking elements, filling in forms, and capturing screenshots as it goes.

Why it matters

Some tasks can only be verified by actually looking at rendered output — a UI change, a broken layout, a JavaScript-heavy page that a plain HTTP fetch can’t render. Browser automation closes that verification gap.

v0

Mon, 01 Jan 0001 00:00:00 +0000

v0 generates production-ready frontend code from a prompt, a rough sketch, or a screenshot. It leans on Tailwind CSS and shadcn/ui, so the output looks polished by default and drops straight into a Next.js project.

Brand Guidelines

Mon, 01 Jan 0001 00:00:00 +0000

The Brand Guidelines skill encodes a specific brand’s rules — color palette, typography, tone of voice, logo usage — so an agent’s output stays consistent with that identity across many separate requests.

Brave Search

Mon, 01 Jan 0001 00:00:00 +0000

The Brave Search server gives an agent access to web and local search results through Brave’s Search API, without routing through another AI vendor’s index.

Why it matters

Models have a training cutoff and no innate awareness of anything after it. A search connector lets an agent verify current information — a library’s latest version, a recent API change, a live status — instead of confidently guessing from stale training data.

DeepSeek V4

Mon, 01 Jan 0001 00:00:00 +0000

DeepSeek V4 ships in two MIT-licensed variants — V4-Pro and V4-Flash — with weights published on Hugging Face. It’s a genuinely open model: download it, fine-tune it, or ship it in a product, not just call an API.

r/ClaudeAI

Mon, 01 Jan 0001 00:00:00 +0000

A community forum where people share real workflows, prompt patterns, and troubleshooting specific to Claude and Claude Code — useful for seeing how other practitioners are actually using the tools day to day, warts and all.

Replit Agent

Mon, 01 Jan 0001 00:00:00 +0000

Replit Agent works inside the browser: it can create a project from scratch, write the code, install packages, provision a database, and deploy — with a live preview updating as it works.

Artifacts Builder

Mon, 01 Jan 0001 00:00:00 +0000

The Artifacts Builder skill covers the conventions for producing standalone, self-contained interactive outputs — inlined styles and scripts, responsive layout, no external dependencies that would break in a sandboxed viewer.

Bolt.new

Mon, 01 Jan 0001 00:00:00 +0000

Bolt.new runs entirely in the browser using WebContainers, so the generated app boots, installs npm packages, and runs without any server round-trip. You can prompt changes and watch the live app update instantly.

Hacker News

Mon, 01 Jan 0001 00:00:00 +0000

Hacker News isn’t AI-specific, but new coding tools and agent releases show up there early, and the comment threads often include genuinely critical, hands-on feedback rather than pure marketing response.

Memory

Mon, 01 Jan 0001 00:00:00 +0000

The Memory server stores facts as a local knowledge graph — entities, relationships, observations — that persists between sessions, giving an agent a lightweight, inspectable form of long-term memory.

Why it matters

Without persistence, every new conversation starts with zero context about you, your preferences, or past decisions. A local, file-backed memory store closes that gap without relying on a specific vendor’s built-in memory feature.

Qwen3-Coder-Next

Mon, 01 Jan 0001 00:00:00 +0000

Qwen3-Coder-Next is built for self-hosted coding agents — an 80B-total, 3B-active mixture-of-experts model under an Apache 2.0 license, small enough to run on a single well-equipped workstation instead of a data-center cluster.

Cline

Mon, 01 Jan 0001 00:00:00 +0000

Cline is an open-source VS Code extension that acts as an autonomous agent — creating and editing files, running terminal commands, and even using a browser — while showing exactly what it plans to do before it does it.

GitHub Topic: AI Agents

Mon, 01 Jan 0001 00:00:00 +0000

GitHub’s topic pages aggregate repositories tagged with a given subject — in this case, AI agent frameworks and projects — sorted by popularity and updated automatically as the ecosystem moves.

Google Drive

Mon, 01 Jan 0001 00:00:00 +0000

The Google Drive server lets an agent search your Drive and read the contents of documents and spreadsheets, using OAuth scoped to your account.

Why it matters

A lot of real work context — specs, meeting notes, planning docs — lives in Docs and Sheets, not in a codebase. This connector lets an agent reference that material directly instead of you manually copying content into a prompt.

Kimi K2.7 Code

Mon, 01 Jan 0001 00:00:00 +0000

Kimi K2.7 Code is Moonshot AI’s coding-focused release in the Kimi K2 line, built to carry end-to-end programming tasks across long, multi-turn agent sessions rather than one-shot completions.

Why it stands out

Always-on thinking mode that preserves full reasoning content across multi-turn conversations, instead of resetting context between steps.
Native multimodal mixture-of-experts architecture, accepting text and image input in the same coding session.
Frontier-competitive coding benchmarks at a fraction of the per-token cost of comparable Western frontier models.
Steep cache discount (roughly 80% off cache-miss input pricing), which rewards long, iterative agent loops that keep re-reading the same context.

Good for

Teams running long, agentic coding sessions who want frontier-adjacent reasoning quality without frontier-model pricing.

Webapp Testing

Mon, 01 Jan 0001 00:00:00 +0000

The Webapp Testing skill packages a verification workflow: launching a dev server, driving a browser through the golden path and edge cases, and checking console and network output for errors — rather than declaring a UI change complete after just reading the code.

Aider

Mon, 01 Jan 0001 00:00:00 +0000

Aider was one of the first tools to popularize the “AI edits your local repo from the terminal” workflow. It reads your codebase, makes changes as real git diffs, and commits each one with an auto-generated message, so every edit is reviewable and revertible.

GLM-5.2

Mon, 01 Jan 0001 00:00:00 +0000

GLM-5.2 is Z.ai’s (formerly Zhipu AI) flagship open-weight model — a 753-billion-parameter mixture-of-experts design released under the MIT license, with a 1M-token context window and full downloadable weights.

Why it stands out

MIT-licensed, 753B-parameter MoE weights, fully self-hostable with no usage restrictions.
1M-token context window with up to 131K tokens of output in a single response.
Beats GPT-5.5 on FrontierSWE at roughly a sixth of the cost, per Zhipu’s own benchmarking.
Selectable High/Max reasoning modes, letting you trade latency for depth on harder multi-step coding tasks.

Good for

Teams that want a genuinely open, frontier-tier coding model to self-host, fine-tune, or run at scale without per-token lock-in.

Learn Prompting

Mon, 01 Jan 0001 00:00:00 +0000

A free, structured course covering prompting techniques from fundamentals through more advanced patterns, independent of any single vendor’s tools.

Not coding-specific, but the underlying skills — clear task framing, few-shot examples, structured output — transfer directly into working with coding agents.

MCP Builder

Mon, 01 Jan 0001 00:00:00 +0000

The MCP Builder skill packages the boilerplate and conventions for writing a new MCP server — the protocol handshake, tool and resource definitions, and error handling patterns that a well-behaved server needs.

Sentry

Mon, 01 Jan 0001 00:00:00 +0000

The Sentry server gives an agent access to issues, stack traces, and event details from a Sentry project, so it can investigate a production error with the same data a human engineer would open the dashboard to see.

Algorithmic Art

Mon, 01 Jan 0001 00:00:00 +0000

The Algorithmic Art skill packages a two-step process for computational art: first drafting a short “algorithmic philosophy” — a named aesthetic movement with its own manifesto — then expressing that philosophy as a p5.js sketch using noise fields, particles, and seeded randomness. It outputs a philosophy doc, an interactive HTML viewer, and the generative JS itself.

Lovable

Mon, 01 Jan 0001 00:00:00 +0000

Lovable is built for people who want to go from an idea to a working product without writing code themselves — you describe the app conversationally, and it scaffolds the frontend, backend, and database, with a visual editor layered on top for tweaks.

MiniMax M3

Mon, 01 Jan 0001 00:00:00 +0000

MiniMax M3 is Shanghai-based MiniMax’s frontier open-weight release, combining a 1M-token context window with native multimodal input — text, image, and video — aimed at full-repository code understanding rather than file-by-file work.

Playwright

Mon, 01 Jan 0001 00:00:00 +0000

Playwright MCP gives an agent structured control over a real browser — Chromium, Firefox, or WebKit — using Playwright’s accessibility tree instead of pixel-based screenshots. It exposes tools for navigation, clicking, form filling, and page inspection so an agent can complete multi-step web tasks deterministically.

Chrome DevTools

Mon, 01 Jan 0001 00:00:00 +0000

Chrome DevTools MCP connects a coding agent to a live Chrome instance, exposing the same network, console, and performance-tracing tools available in DevTools. It lets an agent navigate pages, inspect requests, read console errors, and record performance traces from inside its own workflow.

Claude API

Mon, 01 Jan 0001 00:00:00 +0000

The Claude API skill is a language-aware reference for the Anthropic SDK and Messages API — model selection, adaptive thinking, streaming, prompt caching, token counting, and tool/MCP integration — with explicit guidance to verify API shapes against live docs rather than a model’s memorized training data.

Codex CLI

Mon, 01 Jan 0001 00:00:00 +0000

Codex CLI is OpenAI’s terminal-based coding agent: an open-source command-line tool that reads a local repository, plans a multi-step change, edits files, and runs commands, with approval settings ranging from step-by-step confirmation to fully autonomous runs.

Devin

Mon, 01 Jan 0001 00:00:00 +0000

Devin, built by Cognition, is positioned as an autonomous software engineer rather than an in-editor assistant: hand it a ticket-sized task and it plans the work, writes and tests code in its own cloud environment, and comes back with a pull request rather than requiring turn-by-turn direction.

Doc Co-Authoring

Mon, 01 Jan 0001 00:00:00 +0000

Doc Co-Authoring packages a structured process for writing technical specs, PRDs, decision docs, and proposals: gathering context up front, iteratively building sections through brainstorming and editing, then stress-testing the draft by having a fresh, context-free Claude read it as a real reader would.

Notion

Mon, 01 Jan 0001 00:00:00 +0000

Notion MCP exposes a workspace’s pages, databases, and blocks to an agent through Notion’s API, so it can search, read, and edit content without a human copying text back and forth. It’s available both as a locally run npm package and a hosted remote endpoint.

Frontend Design

Mon, 01 Jan 0001 00:00:00 +0000

The Frontend Design skill packages a design-lead mindset for building web UI: pin down the subject and its audience, build a compact token system — palette, type pairing, layout concept, one signature element — then critique that plan against known AI-generic defaults before writing any code.

Gemini CLI

Mon, 01 Jan 0001 00:00:00 +0000

Gemini CLI is Google’s open-source command-line agent built on Gemini models: it works directly against a local repository from the terminal, answering questions about the code, making edits, and running commands as part of a multi-step task.

Linear

Mon, 01 Jan 0001 00:00:00 +0000

Linear MCP is Linear’s own hosted server, reachable at mcp.linear.app, that lets an agent create, update, and search issues, projects, and cycles in natural language instead of through the UI. It authenticates via OAuth on first connection rather than a static API token.

Amazon Q Developer

Mon, 01 Jan 0001 00:00:00 +0000

Amazon Q Developer is AWS’s coding assistant, combining inline code completion with an agentic mode that can plan and execute multi-file changes, review code for issues, and automate tasks like dependency upgrades — all with native awareness of AWS services and infrastructure.

Figma

Mon, 01 Jan 0001 00:00:00 +0000

Figma’s Dev Mode MCP server exposes a selected frame or component’s structure, styles, and metadata directly to a coding agent, from either the Figma desktop app or a hosted endpoint. It lets an agent generate frontend code grounded in the real design file instead of a screenshot or description of it.

Internal Comms

Mon, 01 Jan 0001 00:00:00 +0000

Internal Comms packages format- and tone-specific guidelines for recurring internal writing tasks — progress/plans/problems updates, company newsletters, FAQ answers, leadership updates, and incident reports — loading the matching template based on which type of communication is requested.

Skill Creator

Mon, 01 Jan 0001 00:00:00 +0000

Skill Creator packages the full lifecycle of authoring an Agent Skill: drafting the skill, writing test prompts, running evaluations with variance analysis, reviewing results, and rewriting the skill based on feedback, then optimizing the skill’s description for more reliable triggering.

Stripe

Mon, 01 Jan 0001 00:00:00 +0000

Stripe’s official MCP server exposes its payments API — customers, charges, subscriptions, refunds, invoices — as tools an agent can call directly, available as a local npx package or Stripe’s hosted remote endpoint. It’s part of Stripe’s broader agent toolkit for LLM framework integration.

Warp

Mon, 01 Jan 0001 00:00:00 +0000

Warp rebuilds the terminal itself around AI: a block-based interface for command history, natural-language-to-command translation, and an agent mode that can carry out multi-step coding tasks — editing files, running builds, chaining commands — inside the same session you already work in.

Cloudflare

Mon, 01 Jan 0001 00:00:00 +0000

Cloudflare’s official MCP server gives an agent access to a Cloudflare account — deploying Workers, querying D1 databases, managing KV namespaces and R2 buckets, and more — through a single hosted endpoint using code-execution-style tools.

Factory (Droid)

Mon, 01 Jan 0001 00:00:00 +0000

Factory positions its agents — “droids” — as configurable workers for an engineering organization rather than a single personal assistant: separate droids can be set up for coding, code review, incident response, or release management, each usable from the terminal or CI.

Slack GIF Creator

Mon, 01 Jan 0001 00:00:00 +0000

Slack GIF Creator packages Slack’s specific GIF constraints — 128×128 for emoji, 480×480 for messages, 10–30fps, 48–128 colors, sub-3-second emoji duration — along with a frame-building workflow and validation tools, so requests like “make a GIF of X doing Y for Slack” produce a file that actually fits Slack’s limits.

Context7

Mon, 01 Jan 0001 00:00:00 +0000

Context7 resolves a library name (like “Next.js” or “shadcn/ui”) to a version-specific ID, then pulls current documentation and code snippets straight from the source into an agent’s prompt. It works with no signup for basic usage, with a free API key available for higher rate limits.

Theme Factory

Mon, 01 Jan 0001 00:00:00 +0000

Theme Factory packages a set of curated color-palette-and-font-pairing themes — Ocean Depths, Sunset Boulevard, Modern Minimalist, and others — shown via a visual showcase, that can be applied to slide decks, documents, or HTML artifacts, or used as a starting point for generating a new theme on the fly.

Zed

Mon, 01 Jan 0001 00:00:00 +0000

Zed is a code editor built from the ground up (not forked from VS Code) for raw editing and rendering speed, with AI collaboration — chat, inline edits, and agentic multi-step changes — designed in as a core feature rather than bolted on through extensions.

JetBrains Junie

Mon, 01 Jan 0001 00:00:00 +0000

Junie is JetBrains’ agentic coding assistant for IntelliJ-based IDEs (IntelliJ IDEA, PyCharm, WebStorm, and others), able to plan and carry out multi-file changes using the same deep code-understanding engine — indexing, refactoring, inspections — that powers the rest of the IDE.

Sequential Thinking

Mon, 01 Jan 0001 00:00:00 +0000

The Sequential Thinking server provides a single tool that lets an agent externalize a chain of reasoning as discrete, revisable steps rather than reasoning silently in one pass. The host model decides when to call it, and can branch, revise, or extend earlier steps as its understanding develops.

Superpowers

Mon, 01 Jan 0001 00:00:00 +0000

Superpowers packages a battle-tested library of 20+ Claude Code skills — test-driven development, systematic debugging, brainstorming techniques, git worktree management, and root-cause tracing — installable in one shot as a plugin marketplace.

Fetch

Mon, 01 Jan 0001 00:00:00 +0000

The Fetch server retrieves a given URL and converts its HTML into clean markdown sized for an LLM context window, with a start-index parameter so an agent can page through long documents in chunks. It’s one of the official reference servers in the modelcontextprotocol/servers repo.

Superpowers Lab

Mon, 01 Jan 0001 00:00:00 +0000

Superpowers Lab is the experimental proving ground for Superpowers — newer, less-settled techniques that graduate into the stable library once they hold up in real use.

Why a skill for this

Skill development benefits from the same staging discipline as software releases — trying new techniques in a lab environment before committing them to a widely-installed stable marketplace avoids regressions for everyone else.

Tabnine

Mon, 01 Jan 0001 00:00:00 +0000

Tabnine focuses on enterprise privacy and control: it can run fully air-gapped or in a private cloud, and its Enterprise Context Engine tunes suggestions to an organization’s own codebase rather than relying solely on public training data.

Playwright Browser Automation

Mon, 01 Jan 0001 00:00:00 +0000

This skill gives Claude Code direct, model-invoked control of Playwright — driving a real browser through a web app’s flows to click, fill forms, and validate behavior end-to-end.

Why a skill for this

Reading component code doesn’t confirm a flow actually works in a browser. A dedicated Playwright skill turns that verification into a repeatable, invokable step instead of an ad hoc script written from scratch each time.

Redis

Mon, 01 Jan 0001 00:00:00 +0000

Redis’s official MCP server lets an agent read and write Redis data structures — strings, hashes, lists, sets, streams — and run vector similarity search, using natural language instead of raw Redis commands. It connects to any reachable Redis instance via a connection URL.

Sourcegraph Cody

Mon, 01 Jan 0001 00:00:00 +0000

Cody is Sourcegraph’s AI assistant, built on top of its code-search infrastructure so it can pull accurate context from codebases far larger than a single repo — a distinguishing strength for organizations running sprawling monorepos or many interconnected services.

Continue.dev

Mon, 01 Jan 0001 00:00:00 +0000

Continue.dev is an open-source extension that adds chat, autocomplete, and agentic editing to VS Code or a JetBrains IDE, with every model provider — hosted or fully local — configurable through one JSON config file rather than being tied to a single vendor.

iOS Simulator

Mon, 01 Jan 0001 00:00:00 +0000

The iOS Simulator skill lets Claude drive Apple’s Simulator directly — building the app, navigating its screens, and exercising flows the way a developer would during manual QA.

Why a skill for this

iOS development often has no equivalent to a browser’s headless test runner conveniently available mid-conversation. This skill closes that gap by giving Claude a controllable simulator instead of relying on the developer to manually verify every change.

Supabase

Mon, 01 Jan 0001 00:00:00 +0000

Supabase’s official MCP server gives an agent access to a Supabase project’s Postgres schema and data, Edge Functions, and project configuration, with a read-only mode for safer exploratory use. It’s built and maintained directly by the Supabase team.

FFUF Web Fuzzing

Mon, 01 Jan 0001 00:00:00 +0000

This skill integrates the ffuf web fuzzer, letting Claude run authenticated fuzzing scans, auto-calibrate for noisy responses, and analyze results for real vulnerabilities during a penetration test.

Why a skill for this

Fuzzing tools have enough flags and calibration nuance that getting authenticated, low-noise scans right by hand takes real fuzzer expertise. Packaging that expertise as a skill makes competent fuzzing runs repeatable for anyone using it.

OpenHands

Mon, 01 Jan 0001 00:00:00 +0000

OpenHands (formerly OpenDevin) is an open-source platform for running autonomous coding agents that execute real engineering work — planning a task, writing code, running commands, and applying changes — rather than just suggesting edits, with a composable SDK for building custom agent workflows on top of it.

Augment Code

Mon, 01 Jan 0001 00:00:00 +0000

Augment Code targets a specific problem: giving an agent reliable context across codebases too large and interdependent for most tools to index well. It combines an editor extension with an agent that can plan and execute multi-file changes grounded in that broader context.

Threat Hunting with Sigma Rules

Mon, 01 Jan 0001 00:00:00 +0000

This skill uses Sigma detection rules — a vendor-neutral format for describing log-based threat signatures — to hunt for suspicious activity and analyze security events.

Why a skill for this

Sigma’s rule format is expressive but verbose to write and match by hand across large event logs. A skill that already knows the format turns threat hunting into a repeatable query task instead of a manual log-reading exercise.

Kiro

Mon, 01 Jan 0001 00:00:00 +0000

Kiro is AWS’s agentic IDE, built around “spec-driven development”: instead of jumping straight from a prompt to code, it first produces a written specification and task breakdown for you to review, then implements against that spec — a departure from AWS’s usual approach of tying developer tools tightly to its own cloud services, since Kiro is cloud-agnostic.

Trail of Bits Security Skills

Mon, 01 Jan 0001 00:00:00 +0000

Trail of Bits’ security skills bring their own audit tooling — static analysis with CodeQL and Semgrep, variant analysis, and vulnerability pattern detection — into Claude Code.

Why a skill for this

Security auditing firms encode years of hard-won pattern knowledge into their tooling configs. Packaging that as a skill means Claude Code inherits Trail of Bits’ actual audit methodology instead of a generic security pass.

D3.js Visualization

Mon, 01 Jan 0001 00:00:00 +0000

This skill teaches Claude to build D3.js charts and interactive data visualizations, handling D3’s verbose selection-and-binding API on the model’s behalf.

Why a skill for this

D3’s power comes with a steep, idiosyncratic API that’s easy to get subtly wrong. A skill that already knows D3’s conventions produces working visualizations faster than re-deriving the pattern from documentation each time.

Google Antigravity

Mon, 01 Jan 0001 00:00:00 +0000

Antigravity reframes the IDE around managing agents rather than writing code directly: a standalone desktop app lets you run several Gemini-powered coding agents in parallel, schedule automated tasks, and give agents built-in browser automation to test and verify their own work.

CSV Data Summarizer

Mon, 01 Jan 0001 00:00:00 +0000

The CSV Data Summarizer skill automatically profiles a CSV file and produces insights with visualizations, without needing a detailed prompt describing what to look for.

Why a skill for this

Most CSV exploration starts with the same handful of questions — distributions, outliers, missing data, obvious correlations. Automating that first pass saves the back-and-forth of asking for it column by column.

Trae

Mon, 01 Jan 0001 00:00:00 +0000

Trae is ByteDance’s AI-first code editor, forked from VS Code like several competitors, differentiated mainly by offering free access to multiple frontier models for chat, inline completion, and agentic multi-file edits.

Chef

Mon, 01 Jan 0001 00:00:00 +0000

Chef is Convex’s prompt-to-app builder, distinguished from most “vibecoding” app generators by actually understanding backend concerns: it scaffolds a real Convex database schema, server functions, and authentication alongside the frontend, rather than generating UI backed by mock data.

Claude Scientific Skills

Mon, 01 Jan 0001 00:00:00 +0000

This is a collection of ready-to-use skills for working with specialized scientific libraries and databases, packaging domain knowledge that’s otherwise scattered across niche documentation.

Why a skill for this

Scientific computing libraries often have small, specialist user bases and thin documentation. Bundling working knowledge of them as skills saves re-deriving usage patterns from source code or sparse docs each time.

Recursive Research

Mon, 01 Jan 0001 00:00:00 +0000

Recursive Research runs PhD-level research across any domain — tiering sources by reliability and checkpointing findings to disk so long research sessions survive context compaction.

Why a skill for this

Deep research spanning many sources tends to lose earlier findings once a conversation compacts. Checkpointing to disk mid-research means a long investigation doesn’t have to restart from scratch after compaction.

Same.new

Mon, 01 Jan 0001 00:00:00 +0000

Same.new generates full-stack web apps from a prompt, a screenshot, or a reference URL, with the URL-to-app path in particular built to closely reproduce an existing site’s look and structure rather than a loose approximation. It defaults to Next.js so frontend and backend logic live in one codebase.

Builder.io Visual Copilot

Mon, 01 Jan 0001 00:00:00 +0000

Visual Copilot is a Figma plugin and CLI that converts a design directly into production code, using an open-source compiler (Mitosis) to build a structural code hierarchy from the design, then an LLM pass to match your target framework’s conventions and styling.

NotebookLM Integration

Mon, 01 Jan 0001 00:00:00 +0000

This skill lets Claude Code chat directly with Google NotebookLM, grounding answers in a specific set of uploaded source documents rather than general knowledge.

Why a skill for this

NotebookLM’s source-grounding is useful precisely because it won’t answer beyond what’s in the uploaded documents. Wiring that into Claude Code keeps document-grounded research and general coding work in the same session.

Markdown to EPUB Converter

Mon, 01 Jan 0001 00:00:00 +0000

This skill converts markdown documents and chat summaries into properly formatted EPUB ebook files, handling the packaging EPUB readers expect.

Why a skill for this

EPUB is a zipped bundle of XHTML, metadata, and a manifest — not something you get right by hand-writing markup. A skill that knows the format’s requirements produces a file that actually opens cleanly in e-readers.

Qodo

Mon, 01 Jan 0001 00:00:00 +0000

Qodo focuses on what happens before and around a merge rather than writing the code itself: a multi-agent review system analyzes pull requests for bugs and standards violations, paired with Qodo Cover for generating unit tests against existing code.

CodeRabbit

Mon, 01 Jan 0001 00:00:00 +0000

CodeRabbit reviews every pull request automatically, posting a summary of the change plus inline comments on specific lines, aimed at being the fastest AI reviewer to set up and the least noisy in what it flags.

Master Claude for Legal

Mon, 01 Jan 0001 00:00:00 +0000

This skill pack equips Claude for legal-team work — NDA triage, multi-party contract version diffing, citation verification, and meeting briefs — with reference docs on privilege and long-document review baked in.

AWS Skills

Mon, 01 Jan 0001 00:00:00 +0000

AWS Skills brings AWS-specific development practice into Claude Code — CDK patterns, cost optimization guidance, and serverless/event-driven architecture conventions.

Why a skill for this

AWS has enough service-specific gotchas and cost traps that generic cloud advice often misses them. A skill scoped specifically to AWS and CDK keeps recommendations grounded in what actually works on that platform.

Greptile

Mon, 01 Jan 0001 00:00:00 +0000

Greptile reviews pull requests with context pulled from the entire indexed codebase rather than just the diff itself, aiming to catch bugs that only show up when you know how a changed function is actually called elsewhere.

Expo Skills

Mon, 01 Jan 0001 00:00:00 +0000

Expo Skills is the official skill set from the Expo team for building React Native apps with Expo, covering the framework’s specific conventions and tooling.

Why a skill for this

Being maintained by the Expo team itself means the skill tracks the framework’s actual conventions and release changes, rather than a third party’s best guess at Expo’s current best practices.

Void

Mon, 01 Jan 0001 00:00:00 +0000

Void is an open-source fork of VS Code built as a transparent alternative to Cursor and Copilot: every AI request is visible and configurable, and nothing routes through a proprietary backend unless you choose to.

shadcn/ui Skill

Mon, 01 Jan 0001 00:00:00 +0000

The shadcn/ui skill gives Claude Code direct context on shadcn/ui’s components and enforces consistent usage patterns across a project.

Why a skill for this

shadcn/ui ships as copyable component source rather than an installed package, so consistency depends on the model actually knowing each component’s intended API. A skill scoped to shadcn/ui keeps generated UI code matching the library’s real patterns instead of guessing.

Supermaven

Mon, 01 Jan 0001 00:00:00 +0000

Supermaven built its name on speed: a purpose-tuned completion model with an unusually large context window, designed to suggest code with minimal lag as you type. In late 2024 it was acquired by Anysphere, the makers of Cursor, and its completion engine now powers Cursor’s Tab feature.

Get Shit Done

Mon, 01 Jan 0001 00:00:00 +0000

Get Shit Done is a lightweight meta-prompting and context-engineering system for Claude Code, built around spec-driven development rather than ad hoc prompting.

Why a skill for this

Spec-first workflows tend to produce more predictable output than freeform prompting, especially on larger features. Packaging that discipline as a skill makes it the default instead of something re-explained per task.

Pear AI

Mon, 01 Jan 0001 00:00:00 +0000

Pear AI is an open-source code editor built on top of VS Code and the Continue extension, aiming to package the best available AI coding tools into a single, ready-to-use interface rather than making users assemble their own stack of extensions.

Melty

Mon, 01 Jan 0001 00:00:00 +0000

Melty is an open-source code editor built around a persistent chat pane rather than inline suggestions: it watches your terminal, compiler output, debugger, and GitHub activity so it can propose changes, fix errors, and draft commit messages with real context on what you’re doing.

Skill Seekers

Mon, 01 Jan 0001 00:00:00 +0000

Skill Seekers automatically converts any documentation website into a ready-to-use Claude skill, turning scattered docs into structured, invokable reference material.

Why a skill for this

Most third-party libraries have documentation but no packaged skill. Automating the conversion means any well-documented tool can get a working skill without hand-authoring one from scratch.

Chrome Relay

Mon, 01 Jan 0001 00:00:00 +0000

Chrome Relay drives the user’s already-signed-in Chrome session — cookies, SSO, localhost included — through a local CLI bridge, as a real-browser counterpart to headless Playwright automation.

Why a skill for this

Some flows only work correctly inside an authenticated, already-logged-in browser session — SSO-gated internal tools, for instance. Relaying through the real Chrome session sidesteps re-authenticating a separate automated browser.

JetBrains AI Assistant

Mon, 01 Jan 0001 00:00:00 +0000

JetBrains AI Assistant brings chat, code completion, and the agentic Junie assistant into the full JetBrains IDE family, from IntelliJ IDEA to PyCharm and WebStorm, using the deep static-analysis context those IDEs already build.

Full-Page Screenshot

Mon, 01 Jan 0001 00:00:00 +0000

This skill captures full-page screenshots of web pages via the Chrome DevTools Protocol, with zero external dependencies.

Why a skill for this

Full-page capture (beyond the visible viewport) usually needs either a heavier automation framework or manual scrolling-and-stitching. Talking to the DevTools Protocol directly gets a clean full-page image without either.

Visual Studio IntelliCode

Mon, 01 Jan 0001 00:00:00 +0000

IntelliCode extends Visual Studio’s and VS Code’s built-in IntelliSense with AI-ranked suggestions, moving the completions you’re statistically most likely to want to the top of the list instead of a plain alphabetical order.

CodeGPT

Mon, 01 Jan 0001 00:00:00 +0000

CodeGPT is an IDE extension that adds AI chat, autocomplete, and agent workflows to VS Code and JetBrains IDEs, with a bring-your-own-key model that lets you connect the provider and model of your choice rather than routing through a single fixed backend.

n8n Skills

Mon, 01 Jan 0001 00:00:00 +0000

n8n Skills lets Claude directly understand and operate n8n automation workflows — reading, editing, and reasoning about workflow graphs rather than treating them as opaque JSON.

Why a skill for this

n8n workflows are graphs of connected nodes that are awkward to reason about as raw exported JSON. A skill that understands the workflow model can edit and debug workflows the way a human building them in the n8n UI would.

Blackbox AI

Mon, 01 Jan 0001 00:00:00 +0000

Blackbox AI is a multi-model coding assistant that works both as a standalone web chat and as an extension across more than 30 IDEs, giving developers code search, autocomplete, image-to-code, and agentic app-building from a single account.

PICT Test Case Design

Mon, 01 Jan 0001 00:00:00 +0000

This skill designs comprehensive pairwise-combinatorial test suites from requirements or code, using Microsoft’s PICT methodology to keep the case count manageable.

Why a skill for this

Testing every combination of inputs is usually infeasible, but pairwise coverage catches most real-world combinatorial bugs with far fewer cases. PICT’s methodology is the standard way to generate that reduced set correctly.

Tabby

Mon, 01 Jan 0001 00:00:00 +0000

Tabby is an open-source coding assistant you run on your own infrastructure, giving teams Copilot-style completions and chat while keeping code entirely inside their own network instead of a vendor’s cloud.

Web Asset Generator

Mon, 01 Jan 0001 00:00:00 +0000

The Web Asset Generator skill produces web assets like favicons, app icons, and social media images in the sizes and formats each platform actually expects.

Why a skill for this

Every platform — favicons, Open Graph images, app store icons — has its own required dimensions and formats, which is tedious to track by hand. A skill that already knows those specs saves re-exporting assets that come out the wrong size.

anydesign

Mon, 01 Jan 0001 00:00:00 +0000

anydesign analyzes any image, URL, or Figma file and produces a structured design.md capturing the full design system and component inventory, portable to other AI builders.

Why a skill for this

Design systems usually live implicitly in a Figma file or an existing site rather than as a portable spec. Extracting that into a structured document means the design system can travel with the project instead of staying locked in one tool.

Refact.ai

Mon, 01 Jan 0001 00:00:00 +0000

Refact.ai is an open-source coding assistant that pairs unlimited code completions with an in-IDE chat and agent for refactoring and multi-file changes, backed by a codebase-aware vector index and available either as a managed plan or a self-hosted deployment.

Frontend Slides

Mon, 01 Jan 0001 00:00:00 +0000

Frontend Slides creates animation-rich HTML presentations from scratch, or converts an existing PowerPoint deck into one.

Why a skill for this

HTML/CSS presentations can do things static slide decks can’t — real animation, interactivity, embedded live content — but building one from scratch is its own frontend project. This skill packages that so the format doesn’t have to be reinvented per deck.

Zencoder

Mon, 01 Jan 0001 00:00:00 +0000

Zencoder is an IDE extension built around a repo-grokking engine that indexes an entire codebase so its agent can plan, edit, and test changes across multiple files with a fuller picture of the project than single-file context provides.

Firebase Studio

Mon, 01 Jan 0001 00:00:00 +0000

Firebase Studio is Google’s browser-based development environment, evolved from Project IDX, that combines a full cloud IDE with Gemini-powered app generation, previews, and one-click deployment through Firebase.

Why it stands out

Runs entirely in the browser, spinning up a cloud workspace with no local setup required.
Gemini-driven app scaffolding, able to generate a working full-stack app from a prompt and iterate on it inside the same workspace.
Direct path to deployment, since workspaces connect straight into Firebase App Hosting and other Google Cloud services.

Good for

Developers building on Firebase or Google Cloud who want AI-assisted scaffolding and deployment without leaving the browser.

Loki Mode

Mon, 01 Jan 0001 00:00:00 +0000

Loki Mode orchestrates dozens of coordinated AI agents to build, deploy, and operate a complete startup end-to-end, from a PRD through to a live, revenue-generating product.

Why a skill for this

Coordinating many agents toward one large goal needs explicit role division and hand-off structure, or the agents duplicate work or conflict. This skill packages that orchestration pattern rather than leaving it to be improvised per project.

Rampstack Brand Build Skills

Mon, 01 Jan 0001 00:00:00 +0000

This 59-skill library covers a website’s full lifecycle — brand, design, content, SEO, development, ops, and growth — including a dedicated SEO audit suite.

Why a skill for this

Building and running a marketing site touches many disciplines that don’t usually live in one toolkit. Bundling them together keeps brand, content, and technical SEO work consistent instead of drifting apart across separate tools.

Aide

Mon, 01 Jan 0001 00:00:00 +0000

Aide is an open-source VS Code fork from CodeStory AI that merges chat and editing into one flow — you can brainstorm a problem by referencing files in chat, then jump straight into applying edits across multiple files in the same session.

Solo Skills

Mon, 01 Jan 0001 00:00:00 +0000

Solo Skills packages seven bilingual (English/Chinese) skills for solo founders and indie developers — launch tweets, customer emails, decision frameworks, and postmortems.

Why a skill for this

Solo founders repeat the same small set of communication and decision tasks — announcing a launch, writing a postmortem — often enough that having them as ready skills beats rewriting the format each time.

Google Workspace Skills

Mon, 01 Jan 0001 00:00:00 +0000

This is a suite of Google Workspace integration skills covering Gmail, Calendar, Chat, Docs, Sheets, Slides, and Drive, with cross-platform OAuth handling.

Why a skill for this

Each Workspace API has its own auth flow and quirks; wiring up OAuth correctly per app is easy to get wrong. A packaged skill suite means that setup work is done once rather than per integration.

Qoder

Mon, 01 Jan 0001 00:00:00 +0000

Qoder is an AI-powered IDE from Alibaba that pairs project-aware code completion with autonomous agents capable of taking on long-running, multi-step development tasks in a dedicated workspace, tracked alongside their status and generated artifacts.

OpenCode

Mon, 01 Jan 0001 00:00:00 +0000

OpenCode brings an agentic coding workflow into the terminal with a polished text-user-interface, built provider-agnostic so it can run against Anthropic, OpenAI, local models, or anything else you point it at.

Postgres Query Skill

Mon, 01 Jan 0001 00:00:00 +0000

This skill executes safe, read-only SQL queries against PostgreSQL databases, with multi-connection support and defense-in-depth safeguards against destructive statements.

Why a skill for this

Letting a model run arbitrary SQL against a real database is risky without hard guardrails. Restricting the skill to read-only queries with explicit safeguards makes database exploration usable without risking accidental writes.

Amp

Mon, 01 Jan 0001 00:00:00 +0000

Amp is Sourcegraph’s take on an agentic coding tool: a single agent, unconstrained by a fixed model or hand-tuned prompt, that plans and executes multi-file changes from either the command line or a lightweight editor extension.

Jules Delegate

Mon, 01 Jan 0001 00:00:00 +0000

Jules Delegate hands off coding tasks to Google’s Jules AI agent for async work — bug fixes, docs, and tests — directly on a GitHub repo.

Why a skill for this

Some tasks are better run asynchronously in the background than synchronously in the current session. This skill packages the hand-off so Claude Code can delegate rather than block on work another agent can do independently.

Goose

Mon, 01 Jan 0001 00:00:00 +0000

Goose, built by Block (the company behind Square and Cash App), is an open-source agent that runs on your own machine and can plan, write code, execute commands, and iterate on a task with minimal hand-holding.

Outline Wiki Skill

Mon, 01 Jan 0001 00:00:00 +0000

The Outline Wiki skill searches, reads, creates, and manages documents in an Outline wiki instance, whether cloud-hosted or self-hosted.

Why a skill for this

Team knowledge often lives in a wiki rather than the codebase, so a coding-only agent misses it. Wiring in direct wiki access keeps documentation work and code work in the same conversation.

Deep Research (Gemini)

Mon, 01 Jan 0001 00:00:00 +0000

This skill hands off research tasks to Google’s Gemini Deep Research agent for autonomous multi-step work — market analysis, competitive landscaping, and literature reviews.

Why a skill for this

Deep, multi-step research benefits from a purpose-built research agent rather than a general coding assistant improvising a research plan. Delegating to Gemini’s dedicated research agent gets a more thorough pass on that kind of task.

Plandex

Mon, 01 Jan 0001 00:00:00 +0000

Plandex is a terminal AI coding agent aimed at tasks too large for a single chat exchange — refactors and features spanning dozens of files — with a sandboxed diff review step before changes are applied.

Mercury MCP Cheatsheet

Mon, 01 Jan 0001 00:00:00 +0000

This reference skill covers the Mercury (Proton) MCP tools for messaging agent teammates, managing threads, and scheduling automations across a coordinated team of agents.

Why a skill for this

Multi-agent coordination tools tend to have enough surface area — threading, scheduling, teammate addressing — that a quick reference beats re-deriving the API each time. This skill keeps that reference on hand.

Agent Skills Open Standard

Mon, 01 Jan 0001 00:00:00 +0000

Agent Skills is the open SKILL.md standard for packaging reusable agent capabilities — originated by Anthropic and now adopted across Codex, Gemini CLI, Grok Build, Cursor, GitHub Copilot, and more.

Crush

Mon, 01 Jan 0001 00:00:00 +0000

Crush is Charm’s entry into the terminal coding agent space, pairing their signature polished TUI design with an agent that can read, edit, and run code across your project, and switch between LLM providers on the fly.

Codex Skills System

Mon, 01 Jan 0001 00:00:00 +0000

OpenAI Codex’s built-in skills system discovers SKILL.md skills from ~/.codex/skills/ and installs new ones via $skill-installer, either from OpenAI’s curated catalog or any GitHub repo.

Why a skill for this

Having a first-party install path and curated catalog, rather than only community-assembled lists, is what makes a skills ecosystem practical to actually adopt inside Codex.

RA.Aid

Mon, 01 Jan 0001 00:00:00 +0000

RA.Aid (Research-Augmented AI Development) is an open-source CLI agent built around a research-then-plan-then-execute loop, so the agent gathers context on how your codebase actually works before proposing a change.

Why it stands out

Explicit research phase. Instead of jumping straight to edits, RA.Aid first investigates relevant code paths and dependencies.
Separates planning from execution, making it easier to review the intended approach before code gets touched.
Open source and self-hostable, with no dependency on a proprietary backend.

Good for

Developers who want an agent that reasons through unfamiliar code before making changes rather than editing on the first pass.

OpenAI Skills/Plugins Catalog

Mon, 01 Jan 0001 00:00:00 +0000

This is OpenAI’s official, curated repository of Codex skills and plugins — covering design tools, testing, security, observability, and one-command cloud deploys.

Why a skill for this

A first-party curated catalog is a stronger trust signal than an assembled community list — these skills are maintained by, or reviewed by, OpenAI itself rather than crowdsourced without a review bar.

Qwen Code

Mon, 01 Jan 0001 00:00:00 +0000

Qwen Code is Alibaba’s open-source command-line coding agent, built as a fork of Google’s Gemini CLI and adapted to work best with Qwen models while still supporting other providers.

Why it stands out

Purpose-tuned for Qwen models, with prompts and tool-calling behavior optimized for that model family’s strengths.
Built on a proven base. Forking Gemini CLI means it inherits a mature agentic loop rather than starting from scratch.
Fully open source, so it can be self-hosted and modified freely.

Good for

Teams standardizing on Qwen models who want a terminal agent tuned specifically for them.

Codebuff

Mon, 01 Jan 0001 00:00:00 +0000

Codebuff is a terminal AI agent that takes a plain-language description of a task and figures out which files to read and edit across a codebase, aiming to feel less like prompting a chatbot and more like delegating to a teammate.

Figma Design-to-Code Skill

Mon, 01 Jan 0001 00:00:00 +0000

This curated Codex skill bundle wires up Figma — Code Connect, Create Design System Rules, and Generate Design — so Codex can work directly from real design files.

Why a skill for this

Turning a Figma file into accurate code depends on knowing Figma’s specific APIs, like Code Connect and design tokens, rather than guessing from a screenshot. Packaging that as a skill keeps the translation accurate.

Playwright Testing Skill

Mon, 01 Jan 0001 00:00:00 +0000

OpenAI’s curated Playwright skill gives Codex the same browser-automation and interactive test-authoring capability as its Claude Code counterpart, packaged for Codex’s skill system.

Why a skill for this

Verifying a web app in a real browser matters regardless of which coding agent is driving the session — this is the Codex-native equivalent of that same verification step.

Smol Developer

Mon, 01 Jan 0001 00:00:00 +0000

Smol Developer is one of the earliest open-source “AI junior developer” tools: point it at a plain-text spec describing what you want built, and it scaffolds a working small application from scratch.

Cosine

Mon, 01 Jan 0001 00:00:00 +0000

Cosine builds an AI software engineer, Genie, that plugs into a team’s existing repos and issue tracker to pick up tickets, work through a codebase, and submit pull requests for review rather than just suggesting snippets inline.

GitHub PR Review Skill

Mon, 01 Jan 0001 00:00:00 +0000

This curated Codex skill reads a GitHub pull request’s review comments and drives the corresponding fixes back into the branch.

Why a skill for this

Addressing review feedback is a mechanical loop — read a comment, make the matching change, reply — that’s a good fit for automation once the skill knows how to map comments to specific diffs.

CI Fix Skill

Mon, 01 Jan 0001 00:00:00 +0000

This curated Codex skill diagnoses and fixes failing GitHub Actions CI runs directly from the failure logs.

Why a skill for this

CI failures are usually diagnosable from the log output alone, but pulling and parsing that log by hand is tedious. A skill that already knows how to fetch and read Actions logs shortens the loop from red CI to a fix.

SWE-agent

Mon, 01 Jan 0001 00:00:00 +0000

SWE-agent wraps an LLM in an “Agent-Computer Interface” — a constrained set of commands for viewing, searching, and editing files and running tests — so it can work through real GitHub issues end-to-end. It’s the reference agent behind much of the SWE-bench benchmark work.

Security Best Practices Skill

Mon, 01 Jan 0001 00:00:00 +0000

This curated Codex skill applies a secure-coding checklist during code generation and review, catching common vulnerability classes as code is written.

Why a skill for this

Security issues are cheaper to prevent during generation than to catch in a later review pass. Baking a checklist into the generation step catches classes of bugs before they’re ever committed.

Security Threat Model Skill

Mon, 01 Jan 0001 00:00:00 +0000

This curated Codex skill walks through producing a structured threat model for a system — assets, trust boundaries, and attack surfaces — rather than an ad hoc security discussion.

Why a skill for this

Threat modeling is only useful if it’s structured and complete; an unstructured conversation tends to miss entire categories of risk. A skill that enforces the methodology produces a threat model that’s actually useful to a security reviewer.

Softgen

Mon, 01 Jan 0001 00:00:00 +0000

Softgen generates full-stack web apps — UI, backend logic, and database — from a chat interface, aimed at founders and builders who want to go from idea to working product without hand-writing the initial implementation.

Create

Mon, 01 Jan 0001 00:00:00 +0000

Create turns a written description of an app into a functioning build — pages, interactions, and backend data — that updates as you keep describing changes, without requiring the user to touch code.

Sentry Triage Skill

Mon, 01 Jan 0001 00:00:00 +0000

This curated Codex skill pulls and triages error reports directly from Sentry, connecting production error data to the code that’s causing it.

Why a skill for this

Triaging errors well means correlating a stack trace with the actual code path and recent changes — something that’s faster with direct Sentry access than copy-pasting error reports into a prompt.

Base44

Mon, 01 Jan 0001 00:00:00 +0000

Base44 lets non-developers describe a product idea in chat and get back a working, hosted application with a database, authentication, and integrations already wired up, without touching code or assembling separate services.

Jupyter Notebook Skill

Mon, 01 Jan 0001 00:00:00 +0000

This curated Codex skill authors and edits Jupyter notebooks programmatically, handling the notebook’s cell-and-metadata JSON structure correctly.

Why a skill for this

Notebook files are structured JSON with execution metadata and outputs, not plain text — editing them without understanding that structure easily corrupts the file. A skill that knows the format keeps notebooks valid while editing.

HeyBoss

Mon, 01 Jan 0001 00:00:00 +0000

HeyBoss positions itself as an AI “product team in a chat window” — describe a website, app, or landing page and it generates, hosts, and lets you keep iterating on it conversationally, aimed squarely at non-developers.

Notion Spec-to-Implementation Skill

Mon, 01 Jan 0001 00:00:00 +0000

This curated Codex skill turns a Notion spec document directly into an implementation plan and pull request.

Why a skill for this

Specs often live in Notion, separate from the codebase, which means implementation work starts with manually re-reading and re-typing the spec. A skill that reads Notion directly removes that translation step.

Cloud Deploy Skills

Mon, 01 Jan 0001 00:00:00 +0000

These curated Codex skills drive one-command deploys to Vercel, Netlify, Render, or Cloudflare directly from the agent, without a separate manual deploy step.

Why a skill for this

Each platform has its own CLI and deploy conventions; a skill scoped to a specific target means deploys work correctly on the first try instead of trial-and-error against unfamiliar CLI flags.

Emergent

Mon, 01 Jan 0001 00:00:00 +0000

Emergent builds working full-stack applications from a described idea, handling frontend, backend, and data layer generation in one flow so builders can go from prompt to a functioning app without assembling separate tools.

Databutton

Mon, 01 Jan 0001 00:00:00 +0000

Databutton pairs a chat-driven agent with a workspace for building internal tools, dashboards, and small full-stack apps, generating Python backends and React frontends and handling hosting so teams can ship without setting up infrastructure.

Skill Creator (OpenAI)

Mon, 01 Jan 0001 00:00:00 +0000

This system skill, auto-installed with Codex, scaffolds a new SKILL.md-compliant skill from a plain description of what it should do.

Why a skill for this

Getting a skill’s folder structure and frontmatter right by hand is easy to get subtly wrong. A scaffolding skill means authoring a new skill starts from a correct template instead of a blank file.

Google Antigravity Skills System

Mon, 01 Jan 0001 00:00:00 +0000

Google Antigravity’s skills system supports the same SKILL.md format as Claude Code and Codex, with both global (~/.gemini/config/skills/) and per-project (.agents/skills/) scopes.

Why a skill for this

Supporting the shared SKILL.md format means skills built for Antigravity aren’t locked to Google’s tooling — the same skill folder is portable to other compatible agents.

Val Town

Mon, 01 Jan 0001 00:00:00 +0000

Val Town lets you write a small TypeScript script in the browser and run it instantly as a hosted endpoint, cron job, or webhook — no deploy pipeline required — with an AI assistant that can generate and modify vals from a prompt.

Gemini CLI Skills System

Mon, 01 Jan 0001 00:00:00 +0000

Gemini CLI natively supports the Agent Skills (SKILL.md) open standard, letting it load the same skill format used by Claude Code, Codex, and other compatible agents.

Why a skill for this

A shared skills format means a skill only has to be written once to work across Gemini CLI and other compatible agents, rather than maintaining separate versions per tool.

Magic

Mon, 01 Jan 0001 00:00:00 +0000

Magic is developing its own frontier models trained specifically for software engineering, with a focus on extremely long context windows so an agent can reason over an entire large codebase at once. It’s earlier-stage and less publicly available than most tools in this list, but notable for the scale of investment behind an autonomous-engineer approach.

Devika

Mon, 01 Jan 0001 00:00:00 +0000

Devika emerged as an open-source answer to Devin — an agent that takes a high-level coding objective, plans the steps to get there, browses for information it needs, and writes and iterates on code with visibility into its reasoning at each step.

Grok Build Skills System

Mon, 01 Jan 0001 00:00:00 +0000

Grok Build’s skills system reads SKILL.md skills from .grok/skills/, ~/.grok/skills/, and plugin directories — and is directly Claude Code-compatible, reading .claude/skills and CLAUDE.md with zero extra configuration.

Why a skill for this

Direct compatibility with Claude Code’s own skill and config files means a project that’s already set up for Claude Code works in Grok Build without any migration step.

MetaGPT

Mon, 01 Jan 0001 00:00:00 +0000

MetaGPT assigns different LLM agents distinct roles — product manager, architect, project manager, engineer — and has them collaborate through standard software-team artifacts like PRDs and design docs on the way to generating a working codebase from a single requirement.

bolt.diy

Mon, 01 Jan 0001 00:00:00 +0000

bolt.diy takes StackBlitz’s Bolt.new — an AI app builder that runs a full dev environment in the browser via WebContainers — and opens it up so anyone can plug in their own model, including local or open-weight ones, instead of being locked to a single provider.

Locofy

Mon, 01 Jan 0001 00:00:00 +0000

Locofy plugs into Figma and turns static designs into responsive, framework-ready code, using AI to infer component structure, responsiveness rules, and interactions that designers don’t always mark explicitly.

Why it stands out

AI-assisted component detection that recognizes buttons, inputs, and repeating layers, and turns them into reusable components instead of one-off divs.
Multiple code targets, including React, HTML/CSS, and React Native, from the same Figma file.
Responsiveness inference that fills in breakpoint behavior designers often leave implicit in static frames.

Good for

Product teams who want to shorten the handoff between Figma design files and a working frontend codebase.

Anima

Mon, 01 Jan 0001 00:00:00 +0000

Anima sits inside Figma and Adobe XD, exporting selected frames into React, Vue, or plain HTML/CSS, while also generating living style guides and specs so engineering and design stay aligned after handoff.

TeleportHQ

Mon, 01 Jan 0001 00:00:00 +0000

TeleportHQ combines a drag-and-drop visual editor with a Figma import pipeline, exporting the result as readable component code across several popular frontend frameworks instead of locking output to one stack.

Uizard

Mon, 01 Jan 0001 00:00:00 +0000

Uizard generates editable UI mockups from text prompts, hand-drawn sketches, or screenshots, letting non-designers produce a workable prototype and hand developers something closer to spec than a napkin drawing.

Why it stands out

Sketch-to-UI conversion, turning a photographed whiteboard wireframe into an editable digital layout.
Text-prompt design generation for teams that want to start from a description rather than a blank canvas.
Theme and rebranding tools that restyle an entire mockup’s color and typography in one pass.

Good for

Founders, PMs, and non-designers who need a credible UI prototype fast, without starting a Figma file from scratch.

Google Stitch

Mon, 01 Jan 0001 00:00:00 +0000

Google acquired Galileo AI in 2025 and folded its UI-generation engine into Google Labs as Stitch — a Gemini-powered tool that turns a short text description or an uploaded wireframe into polished, editable interface designs, complete with exportable front-end code.

Figma Make

Mon, 01 Jan 0001 00:00:00 +0000

Figma Make builds on Figma’s design surface directly, letting teams turn a prompt or an existing frame into an interactive prototype, and iterate on it with follow-up prompts without leaving Figma.

Subframe

Mon, 01 Jan 0001 00:00:00 +0000

Subframe is built for developers rather than designers: a visual canvas for laying out UI that outputs production-quality React and Tailwind code at every step, instead of a design file that needs a separate translation pass.

Magic Patterns

Mon, 01 Jan 0001 00:00:00 +0000

Magic Patterns turns a text prompt or rough sketch into a working React UI, aimed at product managers and designers who want to validate an idea’s interface before it becomes an engineering ticket.

Framer AI

Mon, 01 Jan 0001 00:00:00 +0000

Framer AI generates a complete, responsive website from a short text prompt, dropping the result into Framer’s visual canvas where it can be restyled, rearranged, and published without touching code.

Onlook

Mon, 01 Jan 0001 00:00:00 +0000

Onlook works the opposite direction from most design-to-code tools: it opens an existing React and Tailwind app in a visual, Figma-like canvas so designers can edit a real running product directly, with changes written back into the actual source code.

Superflex

Mon, 01 Jan 0001 00:00:00 +0000

Superflex converts Figma frames or plain screenshots into frontend code, tuned specifically to match the conventions and components already present in a target codebase rather than generating generic markup.

Why it stands out

Codebase-aware generation, matching existing component patterns and styling conventions instead of producing one-off code.
Screenshot-to-code support, working from a plain image when there’s no Figma file available.
IDE integration, delivering generated code inside the editor developers already use rather than a separate export step.

Good for

Frontend teams who want design-to-code output that actually matches their existing component library, not generic boilerplate.

Polymet

Mon, 01 Jan 0001 00:00:00 +0000

Polymet generates multi-screen product design concepts from a text prompt, giving product designers a set of coherent, on-brand screens to react to and refine instead of starting ideation from a blank file.

Visily

Mon, 01 Jan 0001 00:00:00 +0000

Visily specializes in getting a rough idea into an editable wireframe fast — importing screenshots of existing apps, sketches, or prompts and turning them into a design that non-designers can still rearrange and present.

Screenshot to Code

Mon, 01 Jan 0001 00:00:00 +0000

Screenshot to Code takes a single image — a screenshot, a hand-drawn mockup, or a Figma export — and uses a vision-capable AI model to reconstruct it as working front-end code, with no design file required.

Codacy

Mon, 01 Jan 0001 00:00:00 +0000

Codacy runs static analysis, security scanning, and coverage checks on every commit and pull request, surfacing issues as a quality score and letting teams enforce consistent standards across large codebases.

DeepSource

Mon, 01 Jan 0001 00:00:00 +0000

DeepSource continuously analyzes repositories for bugs, security vulnerabilities, performance issues, and anti-patterns, and can generate automated fix-it patches that developers review and merge directly.

Why it stands out

Autofix patches — many detected issues come with a ready-to-merge fix rather than just a flagged line.
Low false-positive focus — rules are curated to avoid the noisy, low-value warnings common in generic linters.
Works alongside CI — runs as a check on every commit and PR without requiring teams to rewrite existing pipelines.

Good for

Teams that want continuous static analysis with actionable, auto-generated fixes rather than just a list of warnings.

CodeScene

Mon, 01 Jan 0001 00:00:00 +0000

CodeScene analyzes both code structure and version-control history to identify hotspots, code health decline, and knowledge risk (bus factor), and includes automated PR review that flags maintainability regressions in new and AI-generated code.

Bito

Mon, 01 Jan 0001 00:00:00 +0000

Bito is an AI coding assistant that pairs an IDE/CLI chat companion with an automated code review agent (AI Code Review Agent) that comments on pull requests, checking for bugs, security issues, and code standard violations.

What The Diff

Mon, 01 Jan 0001 00:00:00 +0000

What The Diff installs as a GitHub app and posts an AI-generated plain-language summary of what changed in each pull request, aimed at making diffs faster to understand for reviewers and teammates outside the immediate context.

Sourcery

Mon, 01 Jan 0001 00:00:00 +0000

Sourcery started as a Python refactoring tool built into the IDE and has expanded into automated pull request review, suggesting concrete code improvements for readability, performance, and adherence to best practices.

Ellipsis

Mon, 01 Jan 0001 00:00:00 +0000

Ellipsis reviews pull requests automatically, leaving comments on bugs and style issues, and can go a step further by opening follow-up commits that fix the problems it finds rather than just describing them.

Graphite

Mon, 01 Jan 0001 00:00:00 +0000

Graphite is a code review and PR workflow tool built around stacked diffs, helping teams break large changes into small, dependent pull requests, and pairs that workflow with Graphite’s own AI reviewer (Diamond) that comments automatically on new PRs.

Reviewpad

Mon, 01 Jan 0001 00:00:00 +0000

Reviewpad lets teams define pull request automation as code, covering reviewer assignment, labeling, and merge rules, and layers AI-generated review comments on top so common issues get flagged without manual triage.

Codeflash

Mon, 01 Jan 0001 00:00:00 +0000

Codeflash analyzes Python functions, generates candidate optimizations, and verifies each one for correctness and measured speedup before opening a pull request, focusing specifically on runtime performance rather than general style or bugs.

Sonar

Mon, 01 Jan 0001 00:00:00 +0000

Sonar has scanned code for bugs, vulnerabilities, and code smells since SonarQube’s early days, and now extends that static analysis foundation with AI Code Assurance and AI-powered review features that specifically check AI-generated code against the same quality gates used for human-written code.

The State of AI Coding Tools in 2026

Mon, 16 Feb 2026 00:00:00 +0000

A year ago, “AI coding tool” mostly meant autocomplete. Today the category has split into three distinct shapes — terminal agents, IDE-integrated copilots, and browser-based builders — each covered in our tools directory.

Breaking Big Tasks Into Agent-Sized Steps

Mon, 09 Feb 2026 00:00:00 +0000

Vague, large prompts produce vague, large diffs — and vague diffs are the hardest kind to review. The fix isn’t a cleverer prompt; it’s decomposition.

Signs a task is too big

You can’t describe what “done” looks like in one sentence
The task touches more than two or three unrelated parts of the system
You’d need to check in multiple times even if a human were doing it

If any of these are true, break it down before prompting.

Context Is the Whole Game

Mon, 02 Feb 2026 00:00:00 +0000

When an agent produces something wrong, the instinct is to blame the model. Most of the time, the real cause is upstream: it was missing context a human in the same seat would have had automatically.

How to Review AI-Generated Diffs Without Rubber-Stamping Them

Mon, 26 Jan 2026 00:00:00 +0000

The single most common failure mode in vibecoding isn’t a bad prompt — it’s a good diff that nobody actually read. Agents are confident, and confident wrong code is easy to approve on autopilot.

Choosing Your First AI Coding Agent

Mon, 19 Jan 2026 00:00:00 +0000

Before comparing specific products, it helps to pick a category first. Every tool in the directory falls into one of a few shapes, and the shape matters more than the brand.

What Vibecoding Actually Means

Mon, 12 Jan 2026 00:00:00 +0000

The term “vibecoding” gets used two very different ways. One camp treats it as a punchline — typing vague prompts and accepting whatever an AI spits out, bugs and all. The other treats it as a real discipline: directing an AI collaborator with enough precision and judgment that the result is actually production-worthy.

Agent Skill

Mon, 01 Jan 0001 00:00:00 +0000

An agent skill is a self-contained folder of instructions — plus, optionally, helper scripts or reference documents — that teaches an agent a specific procedure it wouldn’t reliably do well from a generic system prompt alone, such as formatting a spreadsheet correctly or scaffolding an MCP server.

Agentic Loop

Mon, 01 Jan 0001 00:00:00 +0000

An agentic loop is the repeating cycle an AI coding agent uses to complete a task on its own: it plans a next step, takes an action (reads a file, edits code, runs a command), observes the result, and decides what to do next — looping until the task is done or it needs your input.

Chain of Thought

Mon, 01 Jan 0001 00:00:00 +0000

Chain of thought refers to breaking a problem into intermediate reasoning steps instead of answering in one leap — either because the model does this naturally or because it’s explicitly prompted to (“think step by step”). It’s the underlying technique that extended thinking builds on: the model is more likely to reach a correct answer on a multi-step problem when it works through the intermediate logic rather than pattern-matching straight to an output.

Context Engineering

Mon, 01 Jan 0001 00:00:00 +0000

Context engineering is prompt engineering’s broader successor. Instead of focusing only on how you phrase an instruction, it’s about managing the whole working set the agent sees: which files get loaded, which past turns are kept or summarized, which tool outputs are retained, and what gets trimmed. As agents run longer, multi-step tasks, this curation matters more than any single sentence of instruction.

Context Rot

Mon, 01 Jan 0001 00:00:00 +0000

Models don’t treat every token in their context window equally — attention tends to be strongest at the start and end of a long context and weaker in the middle. As a session accumulates file reads, search results, and tool output, the model has to search through more noise to find what’s relevant, and its reliability on that information drops, even without hitting the hard context-window limit.

Context Window

Mon, 01 Jan 0001 00:00:00 +0000

The context window is the maximum amount of text a model can hold in memory at one time, measured in tokens. Everything the model reasons about — your prompt, the conversation history, any files it has read — has to fit inside this window.

Diff Review

Mon, 01 Jan 0001 00:00:00 +0000

Diff review is reading the precise set of changes an agent proposes — added lines, removed lines, touched files — before they’re applied or committed. It’s the same discipline as reviewing a human teammate’s pull request, applied to AI output.

Embedding

Mon, 01 Jan 0001 00:00:00 +0000

An embedding is a list of numbers (a vector) that a model produces for a piece of text, positioned so that texts with similar meaning end up with similar vectors — even if they don’t share any of the same words. Comparing two embeddings mathematically gives a rough measure of how semantically related two pieces of text are.

Extended Thinking

Mon, 01 Jan 0001 00:00:00 +0000

Extended thinking is a setting, available in several current coding-agent tools, that lets a model work through a harder problem in a visible intermediate stage before committing to a final response or action. Rather than answering immediately, it reasons out loud — weighing tradeoffs, checking assumptions — and that reasoning is often surfaced to the user as a collapsible “thinking” block separate from the final answer.

Git Worktree

Mon, 01 Jan 0001 00:00:00 +0000

Normally, a Git repository has one working directory tied to whichever branch you’ve checked out — switching branches changes the files on disk. A worktree lets you attach a second (or third) working directory to the same repository, each checked out to a different branch, all sharing the same underlying Git history.

Hallucination

Mon, 01 Jan 0001 00:00:00 +0000

A hallucination is output that’s stated with full confidence but isn’t grounded in reality — an AI referencing a function that was never defined, importing a package that was never installed, or describing behavior a piece of code doesn’t actually have.

Headless Mode

Mon, 01 Jan 0001 00:00:00 +0000

Most coding agents default to an interactive mode: you type a request, watch it work, and respond to prompts. Headless mode strips that interface away — you pass in a task via a command-line flag or script, the agent runs to completion (or a defined stopping point) unattended, and the result comes back as output you can capture programmatically.

MCP (Model Context Protocol)

Mon, 01 Jan 0001 00:00:00 +0000

MCP (Model Context Protocol) is an open standard for connecting AI agents to external systems — a database, a project management tool, an internal API — through a single, consistent interface instead of a custom integration for every tool.

Plan Mode

Mon, 01 Jan 0001 00:00:00 +0000

In plan mode, an agent is restricted to read-only actions — it can read files, search the codebase, and ask clarifying questions, but it can’t make edits or run state-changing commands. What it produces instead is a written plan: what it understands the task to be, which files it intends to touch, and the approach it plans to take. You can then approve it, correct it, or send it back before any code changes.

Prompt Caching

Mon, 01 Jan 0001 00:00:00 +0000

When a model processes a prompt, it does real computational work to “read” every token, even ones it’s seen before. Prompt caching lets a provider skip that repeated work for content that hasn’t changed since the last call — a long system prompt, a set of tool definitions, a large file — storing an intermediate representation and reusing it, rather than recomputing from scratch each time.

Prompt Engineering

Mon, 01 Jan 0001 00:00:00 +0000

Prompt engineering is the practice of writing instructions — wording, structure, examples, constraints — so a model produces the output you actually intend, reliably, rather than something that merely looks plausible.

Prompt Injection

Mon, 01 Jan 0001 00:00:00 +0000

A prompt injection attack works by planting text designed to look like an instruction somewhere the agent will read it — a code comment, a README, a scraped webpage, an API response. If the agent doesn’t distinguish content it’s reading from commands it should follow, it can end up doing something the attacker wanted instead of what the user asked for.

Repo Map

Mon, 01 Jan 0001 00:00:00 +0000

A repo map is a condensed representation of a codebase — file names, function and class signatures, import relationships — that gives an agent a sense of the overall structure without loading every file’s full contents into its context window.

Retrieval-Augmented Generation (RAG)

Mon, 01 Jan 0001 00:00:00 +0000

RAG combines a search step with a generation step. Before the model writes its answer, a separate process retrieves the most relevant chunks of text from an external source — a set of docs, a codebase, a knowledge base — and inserts them into the context window. The model then answers using that retrieved material rather than guessing from memory alone.

Sandboxing

Mon, 01 Jan 0001 00:00:00 +0000

A sandbox limits what an agent’s actions can actually affect: it might run in a disposable container with no network access, a copy of your repo instead of the original, or an OS-level permission boundary that blocks writes outside a specific folder. If something goes wrong — a bad command, a misunderstood instruction, a prompt injection — the damage is contained to the sandbox instead of your real machine or production systems.

Subagent

Mon, 01 Jan 0001 00:00:00 +0000

Instead of one agent doing everything in a single, ever-growing context, a main agent can delegate a self-contained piece of work — researching how a library’s API works, searching a large codebase for a pattern — to a subagent. That subagent runs its own mini agentic loop in an isolated context, then returns a summary, keeping the noisy intermediate steps (file reads, failed searches) out of the main conversation.

System Prompt

Mon, 01 Jan 0001 00:00:00 +0000

A system prompt is a set of instructions given to a model before any conversation begins, establishing how it should behave, what tools it can use, and what rules it must follow — as distinct from the individual messages a user sends afterward.

Temperature

Mon, 01 Jan 0001 00:00:00 +0000

Temperature is a parameter that controls how much randomness a model applies when choosing its next output token. Low temperature makes output more deterministic and focused; high temperature makes it more varied and, at the extreme, less coherent.

Token

Mon, 01 Jan 0001 00:00:00 +0000

A token is the basic unit of text a language model processes — often a whole short word, but sometimes a fragment of a longer word or a piece of punctuation. Models don’t read raw characters; they read sequences of tokens.

Tool Use (Function Calling)

Mon, 01 Jan 0001 00:00:00 +0000

On its own, a language model just predicts text. Tool use (also called function calling) is the layer that lets it take real actions: the model is given a list of available functions with descriptions of what they do, and when it decides one is needed, it outputs a structured request to call it — the surrounding system executes the function and feeds the result back in.

Vector Database

Mon, 01 Jan 0001 00:00:00 +0000

A vector database indexes embeddings so that, given a new query, it can quickly return the most similar entries out of potentially millions — a search that would be far too slow to do by brute-force comparison. It’s the storage-and-retrieval layer that most semantic search and RAG systems sit on top of.

Vibecoding

Mon, 01 Jan 0001 00:00:00 +0000

Vibecoding is the practice of building software primarily through natural-language direction of an AI agent — describing intent, letting the agent write and edit code, and steering the result — while still applying the judgment of an experienced engineer: reviewing diffs, verifying behavior, and making architectural calls.

YOLO Mode

Mon, 01 Jan 0001 00:00:00 +0000

YOLO mode (also called auto-approve or auto-accept in different tools) lets an agent execute its planned actions — file edits, shell commands, even commits — without pausing to ask for confirmation on each step.