Forem: kyoungsookim

I Built a Complex AI Orchestration System. Then I Deleted 93% of It.

kyoungsookim — Fri, 06 Mar 2026 17:06:20 +0000

I Built a Complex AI Orchestration System. Then I Deleted 93% of It.

I built Vibe-Claude — a multi-agent orchestration system for Claude Code. Over 4 versions it grew to 13 agents, 8 skills, a 5-phase pipeline, and 8K lines.

Then I deleted almost all of it. Here's why.

The platform was faster than me

Every feature I built, Claude Code shipped natively within weeks:

My memory system → Auto Memory shipped
My context compression → Compaction API shipped
My session restore → built-in
My orchestrator agent → built-in subagents
My parallel execution → built-in
My 13 persona agents → Claude already does all of it

The real problem

My 13 agents were markdown files like "you are an analyst." But Claude doesn't need a costume to analyze code. It already knows how.

Worse — all those prompts consumed context window. Context is the model's working memory. I was filling it with instructions about how to think, leaving less room for actual thinking.

After deleting 93%, Claude performed better on the same tasks.

What survived

Two actual failure modes in practice:

Claims "done" without running the code
Breaks syntax after edits

v5: 5 rules + 2 hooks. 138 lines. Done.

Lessons

The platform will eat your features. What's a plugin today is a built-in tomorrow.
Prompts are suggestions, code is enforcement. If you need a guarantee, write a hook, not a markdown file.
Less prompting = more capability. Context is finite. Don't waste it on instructions the model already follows.
The hardest skill is deletion.

Full postmortem in the README: github.com/kks0488/vibe-claude

I built Codex-native Agent Teams in vibe-codex (v0.4.1)

kyoungsookim — Mon, 09 Feb 2026 13:26:24 +0000

What I wanted

I wanted a practical way to coordinate multiple coding agents with:

explicit lifecycle controls
strict request/response safety
debuggable runtime state
CI-level validation

## What shipped

vc teams for create/delete/add/remove/send/status
protocol-safe waits via await
live monitoring via watch
file mailbox runtime + event logs
dedupe and stale-lock recovery
PR E2E automation (node --test scripts/vc-teams.test.mjs)

https://github.com/kks0488/vibe-codex/

Opus 4.6 + 13 AI Agents = Autopilot for Claude Code

kyoungsookim — Thu, 05 Feb 2026 20:26:31 +0000

The problem: AI coding assistants need constant supervision. Context fills up. No verification. Start over on
failure.

The solution: vibe-claude — one command orchestrates 13 specialized agents.

/vibe "build a real-time chat with typing indicators"

Opus 4.6 analyzes and plans. Sonnet 4.5 builds. Haiku searches. Three Opus agents verify at max effort before
anything ships.

What Opus 4.6 brings:

Adaptive thinking — reasoning depth scales with task complexity
128K output — entire features in one pass
Compaction API — infinite conversations
Effort: max — full cognitive power when it matters

Effort routing saves cost:

Hard problems → Opus 4.6 (max)
Normal tasks → Sonnet 4.5 (high)
Simple lookups → Haiku 4.5 (low)

Open source, MIT licensed. Install in 30 seconds:
claude plugin install vibe-claude@vibe-claude-marketplace

GitHub: https://github.com/kks0488/vibe-claude

I Built an Enhancement Layer for Claude Code - No Modifications Required

kyoungsookim — Fri, 23 Jan 2026 16:37:25 +0000

The Problem

Claude Code is powerful. But after using it for months, I
noticed patterns:

Context window runs out mid-task
Same errors repeat without learning
Complex tasks need clarification upfront
No checkpoint = lost progress when sessions die

I didn't want to replace Claude Code. I wanted to enhance
it.

## The Solution: An Enhancement Layer

Vibe-Claude is a set of markdown files that sit on top of
vanilla Claude Code. No modifications to Claude Code itself.

~/.claude/
├── CLAUDE.md # System prompt enhancements
├── skills/ # Capability modules
│ ├── vibe/ # Core orchestration
│ ├── v-turbo/ # Parallel execution
│ └── ...
└── agents/ # 13 specialized agents

Install:


bash
  git clone https://github.com/kks0488/vibe-claude
  ~/.claude-vibe
  cp -r ~/.claude-vibe/* ~/.claude/

  That's it. No config files. No API keys. No complex setup.

  What It Adds

  1. Multi-Agent Orchestration

  Instead of one Claude doing everything, tasks are delegated to
   specialists:
  ┌────────┬────────────────────────────────┬────────────────┐
  │  Tier  │             Agents             │    Purpose     │
  ├────────┼────────────────────────────────┼────────────────┤
  │ Opus   │ v-analyst, v-planner, v-critic │ Heavy thinking │
  ├────────┼────────────────────────────────┼────────────────┤
  │ Sonnet │ v-worker, v-designer           │ Execution      │
  ├────────┼────────────────────────────────┼────────────────┤
  │ Haiku  │ v-finder, v-writer             │ Speed tasks    │
  └────────┴────────────────────────────────┴────────────────┘
  /vibe build a dashboard with charts

  Claude (Conductor):
  ├─ v-analyst: Analyze requirements
  ├─ v-finder: Find existing patterns
  ├─ v-worker: Build components
  ├─ v-designer: Style the UI
  └─ v-critic: Review quality

  2. Context Management

  Context window is the most valuable resource. Vibe-Claude
  treats it that way.

  100% ████████████████████ Fresh session
   60% ████████████░░░░░░░░ Caution → compress
   40% ████████░░░░░░░░░░░░ WARNING → checkpoint
   20% ████░░░░░░░░░░░░░░░░ DANGER → clear

  Key rules:
  - Subagent-First: Exploration delegated to agents, main
  context protected
  - Two-Strike Rule: Same failure twice → evaluate context →
  compress or clear
  - Checkpoints: Save progress at phase completion

  3. Dynamic Routing

  Not every task needs the full workflow:
  Complexity: TRIVIAL
  Route: Execute only
  Example: "Fix typo in README"
  ────────────────────────────────────────
  Complexity: SIMPLE
  Route: Recon → Execute → Verify
  Example: "Add error handling"
  ────────────────────────────────────────
  Complexity: MODERATE
  Route: Recon → Execute → Verify
  Example: "Build login page"
  ────────────────────────────────────────
  Complexity: COMPLEX
  Route: Interview → Recon → Plan → Execute → Verify → Polish
  Example: "Refactor auth system"
  4. Interview Protocol (for Complex Tasks)

  Before starting complex work, Claude asks clarifying
  questions:

  Claude: Before I start, a few questions:

  SCOPE
  - Should this include OAuth or just email/password?
  - Admin panel included or separate task?

  TECHNICAL
  - Any existing auth patterns I should follow?
  - Session storage preference (JWT, cookies)?

  EDGE CASES
  - Behavior on failed login attempts?
  - Password reset flow needed?

  VERIFICATION
  - What tests should pass when done?

  This prevents the "I built the wrong thing" problem.

  5. Failure Pattern Detection

  Vibe-Claude recognizes common anti-patterns:
  ┌─────────────────┬─────────────────────────┬────────────────┐
  │     Pattern     │       What It Is        │ Auto-Response  │
  ├─────────────────┼─────────────────────────┼────────────────┤
  │ Kitchen Sink    │ Multiple unrelated      │ Split sessions │
  │                 │ tasks                   │                │
  ├─────────────────┼─────────────────────────┼────────────────┤
  │ Death Spiral    │ Fix breaks something,   │ Clear + root   │
  │                 │ fix that breaks another │ cause          │
  ├─────────────────┼─────────────────────────┼────────────────┤
  │ Infinite        │ Reading files without   │ Stop +         │
  │ Exploration     │ clear goal              │ delegate       │
  ├─────────────────┼─────────────────────────┼────────────────┤
  │ Trust-Verify    │ "Should work" without   │ Run actual     │
  │ Gap             │ proof                   │ tests          │
  └─────────────────┴─────────────────────────┴────────────────┘
  6. Evidence-Based Completion

  Nothing is "done" without proof:

  ✓ Code runs: [actual output pasted]
  ✓ Tests pass: 12 passed, 0 failed
  ✓ Features verified:
    - Login: src/auth/login.ts:42
    - Logout: src/auth/logout.ts:18
  ✓ Tribunal approved

  Forbidden phrases:
  - "Should work" → Must test
  - "I think it's done" → Must prove
  - "Looks correct" → Must run

  Usage

  # Simple task
  /vibe add dark mode toggle

  # Complex task (triggers interview)
  /vibe refactor the entire authentication system

  # With specific skills
  /vibe build landing page  # auto-activates v-style
  /vibe fix this bug        # auto-activates v-analyst

  The Philosophy

  "Don't think. Just vibe."

  Traditional development:
  1. Write requirements
  2. Design architecture
  3. Write code
  4. Write tests
  5. Debug
  6. Repeat...

  Vibe coding:
  1. "Make this"
  2. Done

  Is it expensive (Opus usage)? Yes.
  Does it work? Also yes.

  What's New in v2.1.0

  - Context management with budget visualization
  - Interview protocol for complex tasks
  - Anti-pattern detection and recovery
  - Batch operations with parallel workers
  - Enhanced session management with checkpoints

  Try It

  git clone https://github.com/kks0488/vibe-claude
  ~/.claude-vibe
  cp -r ~/.claude-vibe/* ~/.claude/

  Then open Claude Code and try:

  /vibe build me something cool

  GitHub: https://github.com/kks0488/vibe-claude

  ---
  Questions? Feedback? Let me know in the comments.

I Built a Self-Evolving AI Coding System

kyoungsookim — Sat, 10 Jan 2026 08:20:20 +0000

TL;DR

I built Vibe-Claude, a multi-agent system for Claude Code that:

Delegates tasks to specialized agents automatically
Creates new agents when it lacks capabilities
Learns from failures
Keeps retrying until done

GitHub: https://github.com/kks0488/vibe-claude

The Problem

Traditional AI coding: prompt → result → fix → prompt → result → fix...

You're still doing the work.

The Solution

/vibe build a login page with OAuth

Walk away. Come back to working code.

How It Works

Multi-Agent Architecture

11 specialized agents:

Agent	Model	Purpose
v-analyst	Opus	Debugging
v-planner	Opus	Architecture
v-worker	Sonnet	Implementation
v-designer	Sonnet	UI/UX
v-finder	Haiku	Fast search

Self-Evolution

When Claude struggles with a task type:

Creates a new specialized agent
Saves to ~/.claude/agents/
Routes future tasks to it

The system improves itself.

Failure Learning

Logs mistakes to ~/.claude/lessons-learned.md. Same mistake never happens twice.

Infinite Retry

Attempt 1: Try
Attempt 2: Different approach  
Attempt 3: Escalate model
...until success

Quick Start

curl -fsSL https://raw.githubusercontent.com/kks0488/vibe-claude/main/scripts/install.sh | bash

GitHub: https://github.com/kks0488/vibe-claude

Feedback welcome.