by vibeeval
AI software team for Claude Code - 138 agents, 295 skills, 73 hooks. Self-learning, multi-agent swarm, autonomous skill evolution.
# Add to your Claude Code skills
git clone https://github.com/vibeeval/vibecosystemNo comments yet. Be the first to share your thoughts!

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:
vibecoCLI 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 initnpm installer,plugin.jsonfor 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.
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.
vibecosystem is a complete Claude Code ecosystem that creates a self-organizing AI team:
After setup, you say "build a feature" and 20+ agents coordinate across 5 phases.
npx vibecosystem init
curl -fsSL https://raw.githubusercontent.com/vibeeval/vibecosystem/main/install-remote.sh | bash
git clone https://github.com/vibeeval/vibecosystem.git
cd vibecosystem
./install.sh
That's it. Use Claude Code normally. The team activates.
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
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
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.
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
Every error becomes a rule. Automatically.

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)
Patterns learned in one project automatically benefit all your pro