Vibe Coding Statistics 2026: AI Coding Agent Adoption Across 105 Production Open-Source Stacks

Vibe coding is no longer a weekend-hackathon label. Across 105 verified production open-source architectures indexed in the STACK IT FAST directory, 43.8% (46 of 105) now ship through an AI-assisted delivery pipeline: 27.6% (29) run a hybrid mode where AI-generated code passes a human review gate, and 16.2% (17) are AI-agent-heavy codebases purpose-built for tools like Cursor, Claude Code, Windsurf, and AGY. A further 9.5% (10 of 105) carry the stricter “vibecoded” flag: repositories built from inception with extensive AI pair programming.

The adoption curve is anything but uniform. 76.9% (10 of 13) of AI/LLM applications such as Ollama, Dify, and LangChain run in agent mode, while 0 of 14 data and storage infrastructure projects do. The rest of this report breaks the numbers down by project category, programming language, team size, framework, and data layer, then shows how to make your own stack agent-ready with production AGENTS.md, Cursor rules, and Agent Skills.

Definitions used throughout this report. Classic: traditional hand-written engineering with conventional review. Hybrid: AI code generation (Copilot, Cursor, Claude Code) merged through human review pipelines. AI-Agent: agent-heavy delivery where the codebase is structured for autonomous coding agents (explicit type contracts, atomic module boundaries, agent instruction files). Vibecoded: a separate flag for projects built from inception with extensive AI pair programming. See the methodology notes for how labels are assigned.

1. The Master Matrix: Development Mode by Project Category

AI coding agent adoption tracks the product category more closely than any other variable in the dataset. The table below covers all 13 categories across the 105 verified projects:

Three patterns stand out:

• Agent-mode delivery is concentrated in two categories. AI/LLM apps and SaaS products account for 15 of the 17 agent-mode projects (88.2%). The only exceptions are Papermark (analytics) and Coolify (DevOps), both solo-founder products.
• Security-critical and storage-critical software stays hand-written. Auth and identity providers (Authentik, Authelia, Logto, Vaultwarden) are 4 of 4 classic. Data and storage infrastructure (ClickHouse, MinIO, Meilisearch, SurrealDB) is 13 of 14 classic, with Mage AI as the lone hybrid.
• Developer tools adopt AI in review-gated form only. The largest category (21 projects) has 0 agent-mode codebases but 7 hybrid ones, including Next.js, Astro, tRPC, shadcn/ui, and Trigger.dev. Framework maintainers use AI generation, but always behind human merge gates.

2. Which Languages Work Best With AI Coding Assistants

The language split answers a question engineers ask constantly: does Cursor or Claude Code work better with TypeScript, Python, Go, or Rust? The production data shows a clear divide between application languages and systems languages.

Language counts are non-exclusive: a project is counted for every language listed in its verified stack, so the column totals exceed 105.

TypeScript: The Largest AI-Assisted Pool

TypeScript appears in 47 of 105 stacks and contributes the largest absolute number of AI-assisted projects: 21 of 47 (44.7%). The dominant pattern is hybrid (16 projects) rather than agent-heavy (5), and it is driven by mature product teams such as PostHog, Twenty CRM, Dub, n8n, and Tooljet. The five TypeScript agent-mode projects (Taxonomy, Documenso, Formbricks, Typebot, and CopilotKit) are all built on Next.js with strict schema-first data layers. Production rules for that pattern: Next.js 15 + Drizzle ORM + Supabase and Next.js 15 + Prisma ORM + PostgreSQL.

Python: The Highest AI-Assisted Share

Python has the highest AI-assisted ratio of any language with at least five projects: 12 of 15 (80%), split evenly between agent mode (6) and hybrid mode (6). The driver is category, not syntax. Python agent-mode projects are almost all LLM infrastructure: Dify, Open WebUI, Flowise, mem0, MindsDB, and vLLM. Teams building LLM products with Pydantic v2 schemas and FastAPI routers are, unsurprisingly, the earliest adopters of agentic coding workflows. Production rules: LangGraph + Python + FastAPI and FastAPI + Python + PostgreSQL.

Go and Rust: Systems Software Stays Hand-Written

Go is the most “classic” language in the dataset: 16 of 18 projects (88.9%) are hand-written, including Grafana, MinIO, Gitea, and Mattermost. Ollama is the only Go project in agent mode. Rust has 0 agent-mode projects out of 14 and only 3 hybrid ones. Both languages dominate storage daemons, proxies, and single-binary tools where correctness and memory behavior matter more than feature velocity. Production rules: Go + Echo + SQLite, Go + PostgreSQL + React, and Rust + Axum + PostgreSQL.

Framework-Level Breakdown

Frameworks amplify the language signal. Next.js is the single most agent-friendly framework in production:

Half of all Next.js production projects (8 of 16) run in agent mode, the highest agent share of any framework with more than three projects. NestJS is 4 of 4 hybrid, and FastAPI is 4 of 4 AI-assisted. Vue-based platforms such as n8n, Directus, and Hoppscotch adopt AI only in hybrid form.

3. AI-Assisted Development by Team Size

Team size is the second strongest predictor of delivery mode. The data shows a clean gradient: agent-heavy delivery peaks in small teams, hybrid delivery peaks in mid-sized teams, and classic engineering dominates large organizations.

• 2-5 person teams are the agent-mode epicenter. 45% (9 of 20) run agent-heavy delivery, the highest share of any team size bracket. These are the founding teams behind Ollama, Maybe, Taxonomy, CopilotKit, mem0, Documenso, Flowise, Formbricks, and Open WebUI.
• 6-20 person teams prefer the review gate. Hybrid mode reaches 53.1% (17 of 32) here, while agent mode drops to a single project (Langfuse). Once a team has dedicated reviewers, AI generation is routed through them.
• 20+ person organizations are 81.8% classic. Only 3 of 33 large-team projects are agent-mode (Dify, MindsDB, vLLM) and all three are AI/LLM infrastructure companies.
• Solo builders are split. 5 of 11 solo projects are AI-assisted, including agent-mode products Papermark, Coolify, and Typebot. The other 6 are hand-written tools such as Gotify and Gatus.

4. Inside the 17 Agent-Mode and 10 Vibecoded Projects

Here is the full roster of production codebases classified as AI-agent-heavy, grouped by category:

• AI / LLM (10): Ollama, Dify, LangChain, Langfuse, CopilotKit, mem0, Flowise, Open WebUI, MindsDB, vLLM
• SaaS (5): Maybe, Taxonomy, Documenso, Formbricks, Typebot
• Analytics (1): Papermark
• DevOps (1): Coolify

The 10 vibecoded projects are a strict subset of this list. All 10 run in agent mode: 5 SaaS products (Maybe, Taxonomy, Documenso, Formbricks, Typebot), 3 AI/LLM products (Ollama, Dify, Langfuse), plus Papermark and Coolify. Half of them (5 of 10) were built by 2-5 person teams and 3 by solo founders.

What Agent-Mode Stacks Have in Common

Two data-layer findings deserve emphasis:

1. Prisma is the ORM of agent-mode teams. 6 of the 9 Prisma projects (66.7%) run in agent mode, and 8 of 9 are AI-assisted. Declarative schema files give coding agents a single source of truth for the data model. Production rule: Next.js 15 + Prisma ORM + PostgreSQL.
2. Embedded and low-level storage stays classic. SQLite projects are 76.5% classic (13 of 17), Docker-distributed daemons are 73.1% classic (19 of 26), and every project using WebSockets, Tokio, or RocksDB is hand-written.

Agent-Mode Codebases Are Young

The strongest correlate of all is age. Using each project’s verified time in production:

• Agent-mode projects: median 2 years in production (average 2.1). 11 of 17 have been live for 2 years or less, and 0 of 17 for 5 years or more.
• Hybrid projects: median 3 years (average 3.4).
• Classic projects: median 5 years (average 5.1). 31 of 59 have been in production for 5 years or more.

The reading is not that AI tooling makes codebases young. It is that codebases started after 2023 were architected for coding agents from day one, while decade-old systems adopt AI incrementally through hybrid review pipelines, if at all.

5. How to Make Your Stack AI-Agent Ready (AGENTS.md, CLAUDE.md, Cursor Rules, Agent Skills)

Every agent-mode project in this report shares one operational trait: the repository tells the coding agent how to behave. In 2026, that means four instruction artifacts living next to the code.

my-product/
├── AGENTS.md                 # Universal agent instructions (Codex, AGY, Windsurf, Jules)
├── CLAUDE.md                 # Claude Code project memory and workflow rules
├── .cursor/
│   └── rules/
│       └── stack.mdc         # Cursor rules with globs and always-apply directives
├── .claude/
│   └── skills/
│       └── <stack>/SKILL.md  # Agent Skills: reusable, on-demand capabilities
├── apps/web/
└── packages/db/

AGENTS.md

The vendor-neutral entry point read by most coding agents. Production examples in the directory pin the package manager, the migration command, the test runner, and the file layout so an agent never guesses. Every stack rule on STACK IT FAST ships a copy-paste AGENTS.md derived from verified repositories.

CLAUDE.md

Claude Code loads this file into every session. The agent-mode teams above use it for non-negotiables: strict TypeScript flags, Zod or Pydantic validation at every boundary, and “never run destructive migrations without confirmation” rules.

Cursor Rules (.cursor/rules/*.mdc)

Cursor reads MDC files with globs and alwaysApply frontmatter, so rules can be scoped to apps/web/** or packages/db/**. Each rule page provides a ready .mdc file matching the stack.

Agent Skills (SKILL.md)

Agent Skills package a capability (for example, “add a Drizzle migration and regenerate types”) as a folder with a SKILL.md that agents load on demand. Every rule page on STACK IT FAST now serves a downloadable SKILL.md, for example /rules/nextjs-drizzle-supabase/SKILL.md.

Which Rule Set Matches Your Category

Browse all 20 rule sets with AGENTS.md, CLAUDE.md, Cursor rules, and SKILL.md files in the Production Stack Rules catalog.

6. Decision Heuristics: Classic, Hybrid, or Agent-Heavy?

Use the production distribution as a prior for your own team:

1. A 2-5 person team building an LLM product should default to agent-mode delivery. It is the majority pattern in that bracket (9 of 20) and the near-universal pattern in the AI category (10 of 13).
2. A 6-20 person product team should adopt hybrid delivery: AI generation gated by human review is what 17 of 32 teams that size run in production.
3. An organization of 20+ engineers should expect classic engineering to remain the default (27 of 33) and introduce AI through scoped hybrid pipelines rather than repository-wide agent workflows.
4. Storage engines, auth providers, and proxies stay hand-written in production: 0 of 14 data-infra and 0 of 4 auth projects are agent-mode. Treat agent-generated code in these domains as a review-heavy exception.
5. Choosing a stack for agent-friendliness? Next.js (50% agent), Prisma (66.7% agent), and FastAPI (100% AI-assisted) have the strongest production track record. Go and Rust stacks work with AI tooling, but only 2 of 18 Go and 3 of 14 Rust projects use it.
6. Whatever the mode, ship instruction files. Agent-mode projects are defined by explicit AGENTS.md, CLAUDE.md, and Cursor rule files. Start from a verified rule set instead of writing them from scratch.

7. Methodology & Classification Notes

Sample and classification. This report is computed from 105 verified and approved production open-source architectures in the STACK IT FAST directory as of September 11, 2026. Development modes (classic, hybrid, AI-agent) and the vibecoded flag are assigned by directory curators after reviewing each repository, based on the presence of agent instruction files (AGENTS.md, CLAUDE.md, .cursor/rules), commit and review patterns, and maintainer documentation. They are not self-reported by project teams. Language, framework, and database counts are non-exclusive stack tags: a project is counted for a technology only when it is listed in its verified stack, which is why 8 agent-mode projects list Next.js while only 5 list TypeScript explicitly. Technology names are canonicalized through the directory taxonomy (for example, “Postgres” and “PostgreSQL” are merged, which yields 61 PostgreSQL projects here versus the 54 reported before canonicalization in the Top 10 Production Tech Stacks report). Survey responses are excluded from this analysis. No synthetic data, estimates, or external industry extrapolations have been introduced into these figures.