DEV Community: kyoungsookim

Stop pasting other people's agent skills into your repo as-is

kyoungsookim — Fri, 09 Oct 2026 02:44:17 +0000

Agent skills (the SKILL.md files that Claude Code and Codex load) are easy to share, and GitHub is full of them. Each one was written for its author's project, with their stack, their scripts and their habits.

Copy one into your repo unchanged and your agent inherits all of that. A frontend skill tells it to reach for Tailwind when you use CSS modules. A workflow skill says "run the tests" when your project calls it pnpm test:unit. A cleanup skill says "delete unused files" while your AGENTS.md says never to touch docs/.

I built skilladopt to fix the skill before it goes in.

What it does

npx skilladopt anthropics/skills frontend-design

It fetches the skill at a pinned commit and hands the text, plus a short summary of your project, to an isolated Claude or Codex worker. The worker makes one decision per paragraph:

Decision	Meaning
`keep`	stays as written
`bind`	a generic command becomes yours: "run the tests" → "run `npm test`"
`rewrite`	the intent applies, the details don't (you always approve these)
`drop`	doesn't apply here, with the reason
`review`	the AI wasn't sure, so you decide

Each decision has to cite evidence from your repo: a dependency, an npm script, a line in AGENTS.md or CLAUDE.md. Then plain code checks the answer. A bind may insert exactly one command that really exists in your project and must leave the rest of the sentence identical. A "stack mismatch" drop must point at something your project actually lacks. Paragraphs that carry a duty (a prohibition, an approval step, a verification step) are never dropped or rewritten without you.

Nothing from the skill is executed, and the worker runs without tools (claude -p --safe-mode) or in a read-only sandbox (codex).

A week later

Your teammate renames the test script and adds a rule to AGENTS.md.

npx skilladopt impact

Because every decision recorded its evidence, skilladopt can tell which ones no longer hold. In the demo run that's 1 decision out of 25, plus the new rule that might conflict. You re-check those lines and leave the rest alone. skilladopt update <name> re-fits a skill to its latest upstream version and reuses every decision whose paragraph and evidence haven't changed.

Let your agent do it

npx skilladopt setup

This installs a small skill for Claude Code and Codex. After that you can ask, in any project, "add a frontend design skill to this project". The agent searches for one, adopts it with skilladopt, shows you what changed and asks before installing.

Where it stands

It's v0.1, MIT, with no runtime dependencies. It only handles Markdown skills and refuses skills that need scripts. I haven't measured how much time it saves, and that's the part I'd most like to hear about. If it makes a decision you disagree with, an issue with the skill and the decision would help a lot.

GitHub: https://github.com/kks0488/skilladopt

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.