vibecosystem

Your AI software team. Built on Claude Code.

Turkce | English | Espanol | Francais | Deutsch | Portugues | Italiano | Nederlands | 中文 | 日本語 | 한국어 | العربية | हिन्दी | Русский

vibecosystem turns Claude Code into a full AI software team — 139 specialized agents that plan, build, review, test, and learn from every mistake. No configuration needed — just install and code.

v2.0: 13 new agents (sast-scanner, mutation-tester, graph-analyst, mcp-manager, community-manager, benchmark, dependency-auditor, api-designer, incident-responder, data-modeler, test-architect, release-engineer, documentation-architect) + 23 new skills (SAST, compliance, product, marketing, MCP) + 4 new hooks + Agent Monitoring Dashboard + GitHub Actions CI/CD + MCP Auto-Discovery. See UPGRADING.md for details.

v2.1: 7 new skills (minimax-pdf, minimax-docx, minimax-xlsx, pptx-generator, frontend-dev, fullstack-dev, clone-website) + 2 new agents (document-generator, website-cloner). Document generation, pixel-perfect website cloning, and enhanced frontend/fullstack patterns.

v2.1.1: 7 new skills from oh-my-claudecode (smart-model-routing, deep-interview, agent-benchmark, visual-verdict, ai-slop-cleaner, factcheck-guard, notepad-system) + 1 new rule (commit-trailers).

v2.2: 5 features from Claude Code source — Agent Memory (persistent per-agent memory), Magic Docs (auto-updating docs), Dream Consolidation (cross-session memory cleanup), Smart Recall (frontmatter-based memory scoring), Plugin Toggle (hook enable/disable CLI). +7 hooks, skill references for 21 agents.

v2.2.1: Monetization stack — 1 new agent (monetization-expert), 2 new skills (paywall-optimizer, codex-orchestration), 3 updated skills (revenuecat-patterns, paywall-strategy, subscription-pricing). AI-powered paywall optimization with 14-category benchmarks, RevenueCat SDK patterns, Codex + Claude Code orchestration.

v2.3: vibeco CLI tool (stats, doctor, profiles, dashboard), 6 preset profiles for token savings, one-liner install (curl | bash).

v2.4: Terminal HUD (real-time statusline), prompt auto-improver (enriches vague prompts with context), persistent planning system (PLAN.md/PROGRESS.md/CONTEXT.md for 96.7% task completion). Competitive gap closure from analysis of 20+ ecosystem repos.

v3.0: npx vibecosystem init npm installer, plugin.json for official plugin ecosystem, worktree isolation on 60 producer agents, multi-LLM model routing (Haiku/Sonnet/Opus tiers), knowledge graph integration (6-71x token savings), dashboard v2 with token/cost tracking.

The Problem

Claude Code is powerful, but it's one assistant. You prompt, it responds, you review. For complex projects you need a planner, a reviewer, a security auditor, a tester — and you end up being all of them yourself.

The Solution

vibecosystem is a complete Claude Code ecosystem that creates a self-organizing AI team:

1. 138 agents — specialized roles from frontend-dev to security-analyst
2. 295 skills — reusable knowledge from TDD workflows to Kubernetes patterns
3. 73 hooks — TypeScript sensors that observe, filter, and inject context
4. 20 rules — behavioral guidelines that shape every agent's output
5. Self-learning — every error becomes a rule, automatically

After setup, you say "build a feature" and 20+ agents coordinate across 5 phases.

Quick Start

npm (recommended)

npx vibecosystem init

One-liner

curl -fsSL https://raw.githubusercontent.com/vibeeval/vibecosystem/main/install-remote.sh | bash

Manual

git clone https://github.com/vibeeval/vibecosystem.git
cd vibecosystem
./install.sh

That's it. Use Claude Code normally. The team activates.

vibeco CLI

After install, the vibeco command is available:

vibeco stats                          # ecosystem statistics
vibeco list agents --search security  # browse components
vibeco profile frontend               # switch profile (saves tokens)
vibeco doctor                         # health check
vibeco dashboard                      # start monitoring UI
vibeco update                         # pull latest & reinstall

Profiles

Save tokens by loading only what you need:

Profile	Agents	Skills	Use case
minimal	~15	~40	Core only (review, test, verify)
frontend	~30	~60	React/Next.js/CSS/a11y
backend	~44	~74	API/DB/security
fullstack	~59	~96	Frontend + Backend
devops	~33	~61	CI/CD/K8s/cloud
all	139	295	Everything (default)

vibeco profile frontend  # switch to frontend profile
vibeco profile all       # back to everything

How It Works

YOU SAY SOMETHING                VIBECOSYSTEM ACTIVATES              RESULT
┌──────────────┐                 ┌──────────────────────┐            ┌──────────┐
│ "add a new   │──→ Intent ──→  │ Phase 1: scout +     │──→ Code   │ Feature  │
│  feature"    │   Classifier   │   architect plan     │   Written │ built,   │
│              │                 │ Phase 2: backend-dev │   Tested  │ reviewed,│
│              │                 │   + frontend-dev     │   Reviewed│ tested,  │
│              │                 │ Phase 3: code-review │           │ merged   │
│              │                 │   + security-review  │           │          │
│              │                 │ Phase 4: verifier    │           │          │
│              │                 │ Phase 5: self-learner│           │          │
└──────────────┘                 └──────────────────────┘            └──────────┘

Hooks are sensors — they observe every tool call and inject relevant context:

"fix the bug"       → compiler-in-loop + error-broadcast      ~2,400 tok
"add api endpoint"  → edit-context + signature-helper + arch   ~3,100 tok
"explain this code" → (nothing extra)                          ~800 tok

Agents are muscles — each one specialized for a specific job:

GraphQL API      → graphql-expert   (backup: backend-dev)
Kubernetes       → kubernetes-expert (backup: devops)
DDD modeling     → ddd-expert       (backup: architect)
Bug reproduction → replay           (backup: sleuth)
... 70 more routing rules

Self-Learning Pipeline turns mistakes into permanent knowledge:

Error happens → passive-learner captures pattern (+ project tag)
→ consolidator groups & counts (per-project + global)
→ confidence >= 5 → auto-inject into context
→ 2+ projects, 5+ total → cross-project promotion
→ 10x repeat → permanent .md rule file

No manual intervention. The system writes its own rules — and shares them across projects.

What's New in v2.0

• SAST Security Scanner — static analysis agent + hook for automated vulnerability detection
• Agent Monitoring Dashboard — real-time web UI for agent activity and performance
• MCP Auto-Discovery — automatic MCP server recommendations based on project type
• Changelog Automation — automatic changelog generation at session end
• Compliance Skills — SOC2, GDPR, HIPAA compliance checking
• Product & Marketing Skills — PRD writer, analytics setup, growth playbooks
• GitHub Actions CI/CD — automated PR review + issue fix workflows
• Mutation Testing — test quality measurement via mutation analysis
• Code Knowledge Graph — codebase structure analysis with graph-analyst

---

Core Features

Agent Swarm

Say "add a new feature" and 20+ agents activate across 5 phases.

Phase 1 (Discovery):    scout + architect + project-manager
Phase 2 (Development):  backend-dev + frontend-dev + devops + specialists
Phase 3 (Review):       code-reviewer + security-reviewer + qa-engineer
Phase 4 (QA Loop):      verifier + tdd-guide (max 3 retry → escalate)
Phase 5 (Final):        self-learner + technical-writer

Self-Learning Pipeline

Every error becomes a rule. Automatically.

Dev-QA Loop

Every task goes through a quality gate:

Developer implements → code-reviewer + verifier check
→ PASS → next task
→ FAIL → feedback to developer, retry (max 3)
→ 3x FAIL → escalate (reassign / decompose / defer)

Cross-Project Learning

Patterns learned in one project automatically benefit all your projects.

Project A: add-error-handling (3x) ─┐
                                     ├→ 2+ projects, 5+ total → GLOBAL
Project B: add-error-handling (4x) ─┘
                                     ↓
Next session in ANY project → "add-error-handling" injected as global pattern

Each project gets its own pattern store. When the same pattern appears in 2+ projects with 5+ total occurrences, it's promoted to a global pattern that benefits every project — even brand new ones.

node ~/.claude/hooks/dist/instinct-cli.mjs portfolio      # All projects
node ~/.claude/hooks/dist/instinct-cli.mjs global          # Global patterns
node ~/.claude/hooks/dist/instinct-cli.mjs project <name>  # Project detail
node ~/.claude/hooks/dist/instinct-cli.mjs stats           # Statistics

Canavar Cross-Training

When one agent makes a mistake, the entire team learns from it.

Agent error → error-ledger.jsonl → skill-matrix.json
→ All agents get the lesson at session start
→ Team-wide error prevention

Adaptive Hook Loading

73 hooks exist but they don't all run at once. Intent determines which hooks fire.

---

Architecture

┌─────────────────────────────────────────────────────────┐
│                    Claude Code                          │
│                                                         │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐              │
│  │  Hooks   │  │  Agents  │  │  Skills  │              │
│  │  (73)    │→ │  (139)   │← │  (295)   │              │
│  └────┬─────┘  └────┬─────┘  └──────────┘              │
│       │              │                                   │
│       ▼              ▼                                   │
│  ┌──────────┐  ┌──────────┐                              │
│  │  Rules   │  │  Memory  │                              │
│  │  (20)    │  │ (PgSQL)  │                              │
│  └──────────┘  └──────────┘                              │
│                                                         │
│  ┌──────────────────────────────────────┐                │
│  │  Self-Learning Pipeline             │                │
│  │  instincts → consolidate → rules    │                │
│  │  + cross-project promotion          │                │
│  └──────────────────────────────────────┘                │
│                                                         │
│  ┌──────────────────────────────────────┐                │
│  │  Canavar Cross-Training             │                │
│  │  error-ledger → skill-matrix → team │                │
│  └──────────────────────────────────────┘                │
└─────────────────────────────────────────────────────────┘

---

Agent Categories

Category	Count	Examples
Core Dev	14	frontend-dev, backend-dev, kraken, spark, devops, browser-agent, website-cloner
Review & QA	8	code-reviewer, security-reviewer, verifier, qa-engineer
Domain Experts	36	graphql-expert, kubernetes-expert, ddd-expert, redis-expert, paywall-planner
Architecture	8	architect, planner, clean-arch-expert, cqrs-expert
Testing	6	tdd-guide, e2e-runner, arbiter, mocksmith
DevOps & Cloud	12	aws-expert, gcp-expert, azure-expert, terraform-expert
Analysis	11	scout, sleuth, data-analyst, profiler, strategist, harvest
Orchestration	16	nexus, sentinel, commander, neuron, vault, nitro
Documentation	6	technical-writer, doc-updater, copywriter, api-doc-generator, document-generator
Learning	7	self-learner, canavar, reputation-engine, session-replay-analyzer

---

Comparison

Feature	vibecosystem	Single Claude Code	Cursor	aider
Specialized agents	139	0	0	0
Self-learning	Yes	No	No	No
Agent swarm coordination	Yes	No	No	No
Cross-project learning	Yes	No	No	No
Cross-agent error training	Yes	No	No	No
Dev-QA retry loop	Yes	No	No	No
Adaptive hook loading	Yes	No	No	No
Assignment matrix routing	Yes	No	No	No
Claude Code native	Yes	Yes	No	No
Zero config after install	Yes	Yes	No	No

---

What's Included

Component	Count	Description
agents/	139	Markdown agent definitions with specialized prompts
skills/	295	Reusable knowledge — TDD, security, patterns, frameworks
hooks/src/	73	TypeScript hooks — sensors, learners, validators
rules/	20	Behavioral guidelines — coding style, safety, QA

---

Tech Stack

Component	Technology
Runtime	Claude Code (Claude Max)
Models	Opus 4.6 / Sonnet 4.6
Hook engine	TypeScript → esbuild → .mjs
Memory DB	PostgreSQL + pgvector (Docker)
Agent format	Markdown + YAML frontmatter
Skill format	prompt.md / SKILL.md
Cross-training	JSONL ledger + JSON skill matrix
Cross-project learning	Per-project instinct stores + global promotion

---

Philosophy

hooks are sensors. observe, filter, signal.
agents are muscles. build, produce, fix.
the bridge between them: context injection.
no direct RPC. no message passing. by design.
implicit coordination through context.

---

Data & Privacy

• All data stays on your machine (~/.claude/)
• No network requests, no telemetry, no cloud sync
• Self-learned rules go to ~/.claude/rules/
• Hooks run locally via Claude Code's native hook system

---

Multi-CLI Support

vibecosystem works with multiple AI coding tools:

CLI	Installer	Instructions File	What You Get
Claude Code	./install.sh	CLAUDE.md	Full support (agents + skills + hooks + rules)
Cursor IDE	./install-cursor.sh	AGENTS.md + .cursor/rules/	6 MDC rules + AGENTS.md + skills
Codex CLI (OpenAI)	./install-codex.sh	AGENTS.md	Skills only (295 skills)
OpenCode	Manual	AGENTS.md	Skills only

# For Cursor IDE users:
./install-cursor.sh /path/to/your/project

# For Codex CLI users:
./install-codex.sh

See docs/codex-setup.md for Codex CLI setup, or copy .cursor/rules/ into any Cursor project.

---

Inspired By

vibecosystem stands on the shoulders of great open-source projects:

• Shannon by KeygraphHQ — Result<T,E> pattern, pentest pipeline, comment philosophy
• UI UX Pro Max by nextlevelbuilder — Named UX rules, UI style catalog, design token architecture
• Game Studios by Donchitos — Context resilience, incremental writing, gate-check system
• Skill Gateway by buraksu42 — Invisible skill routing, external catalog, one-question rule
• Pyxel by kitao — Retro game engine patterns, pixel art constraints, MML audio
• copilot-orchestra by ShepAlderson -- Phase-gated commits, plan documentation trail, 90% confidence threshold
• RevenueCat -- Subscription infrastructure, category benchmarks, paywall patterns
• Trail of Bits Skills by trailofbits -- Security audit patterns, variant analysis, false positive verification, sharp edges detection

---

Contributing

Contributions welcome! Areas where help is needed:

• More agent definitions — specialized roles for your domain
• More skill patterns — framework-specific knowledge (Rails, Flutter, etc.)
• Better hooks — new sensors, smarter context injection
• Documentation — tutorials, guides, examples
• Translations — improve existing or add new languages

---

Turkce

Nedir?

vibecosystem, Claude Code'u tam bir AI yazilim ekibine donusturur. Tek bir asistan degil — planlayan, gelistiren, review yapan, test eden ve her hatasindan ogrenen 139 uzman agent'lik bir ekip.

Ozel model yok. Ozel API yok. Sadece Claude Code'un hook + agent + rules sistemi, sonuna kadar kullanilmis.

Hizli Baslangic

git clone https://github.com/vibeeval/vibecosystem.git
cd vibecosystem
./install.sh

Nasil Calisir?

1. Hook'lar sensor — gozlemler, filtreler, isaret eder
2. Agent'lar kas — calisir, uretir, duzeltir
3. Aralarindaki kopru: context injection
4. Direkt RPC yok — bilerek boyle
5. Context uzerinden implicit koordinasyon calisiyor

Felsefe

Kullanicinin hicbir sey hatirlamasina gerek yok.
Her sey otomatik.

---

License

MIT

---

Built by @vibeeval

No custom model. No custom API. Just good engineering.