kimchi:halmoni
This command should be used to run the Kimchi self-improvement system. Observes execution outcomes, proposes incremental improvements to skills/validators/personas, validates against history, and applies with versioning.
Best use case
kimchi:halmoni is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
This command should be used to run the Kimchi self-improvement system. Observes execution outcomes, proposes incremental improvements to skills/validators/personas, validates against history, and applies with versioning.
Teams using kimchi:halmoni should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/halmoni/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How kimchi:halmoni Compares
| Feature / Agent | kimchi:halmoni | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
This command should be used to run the Kimchi self-improvement system. Observes execution outcomes, proposes incremental improvements to skills/validators/personas, validates against history, and applies with versioning.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Kimchi Halmoni (할머니)
> "Taste, adjust, remember. Each batch teaches the next."
<command_purpose>
Self-improvement system that observes what happened during bead execution or from user feedback, proposes small improvements to skills/validators/personas, validates them, and applies with versioning.
</command_purpose>
## Input
Parse `$ARGUMENTS`:
- `--from-bead ID`: Analyze execution of a specific bead
- `--from-feedback "text"`: Process explicit user feedback
- `--taste-only`: Observe and report without proposing changes
- `--dry-run`: Show proposals without applying
- `--history`: Show skills/CHANGELOG.md
- (no args): Interactive improvement session — ask what to improve
## Process
### 1. TASTE (Observe)
**From bead execution (`--from-bead`):**
- Read `.beads/{id}.yaml` for the bead spec
- Check git log for commits with that bead ID
- Look for iteration count, search patterns, clarifying questions in logs
- Assess: Did the agent struggle? Where?
**From feedback (`--from-feedback`):**
- Parse the feedback text
- Identify which component it relates to (skill, validator, persona, template)
- Assess: Is this a pattern or one-off?
**Interactive (no args):**
- Ask: "What would you like to improve? (skill / validator / persona / template)"
- Ask: "What happened that should be better next time?"
Report observations:
```
Tasting...
Observations:
- [What happened]
- [What worked well]
- [What could be better]
```
### 2. ADJUST (Propose)
Generate specific, minimal changes:
```
Proposed adjustment:
File: [path to skill/validator/persona]
Change:
+ [line to add]
- [line to remove]
Rationale: [Why this helps, with evidence]
```
Rules:
- One change at a time
- Show as diff
- Explain rationale
- Reference specific evidence
### 3. REMEMBER (Validate)
Check the proposal:
| Check | Question |
|-------|----------|
| Conflicts | Does this contradict existing skills/validators? |
| Specificity | Is this actionable, not vague? |
| Generality | Will this help beyond this one case? |
| Protected | Does this touch protected components? |
**Protected components (CANNOT modify):**
- Bead schema required fields (bead_id, title, description, depends_on, context, deliverables, tests, acceptance_criteria)
- Command names
- Orchestration integration protocols (ACFS and GasTown)
If proposal touches protected components, reject it and explain why.
### 4. PASS DOWN (Apply)
If `--dry-run`: Show proposal and stop.
If `--taste-only`: Show observations and stop.
Otherwise, ask for confirmation:
```
Apply this change? [y/n/edit]
```
If confirmed:
1. Apply the change to the file
2. Update version in YAML frontmatter (patch bump)
3. Add entry to `skills/CHANGELOG.md`
4. Commit with message: `halmoni: [brief description]`
### 5. Show History (`--history`)
If `--history` flag, just read and display `skills/CHANGELOG.md`.Related Skills
kimchi:verification-before-completion
Use when about to claim work is complete, fixed, or passing — before committing or creating PRs. Evidence before assertions, always.
kimchi:validate
This command should be used to validate bead YAML files for standalone executability. Runs 4 validators (context completeness, deliverables clarity, test specification, isolation) and enriches failing beads. Eighth stage of the Kimchi planning pipeline.
kimchi:tdd
Use when implementing any feature, bugfix, or behavior change — before writing implementation code. Enforces RED-GREEN-REFACTOR cycle.
kimchi:systematic-debugging
Use when encountering any bug, test failure, or unexpected behavior — before proposing fixes. Enforces 4-phase root cause analysis.
kimchi:status
This command should be used to check the current state of the Kimchi planning pipeline, including which stages have completed, what artifacts exist, and bead validation status.
kimchi:simplicity-enforcement
Use when designing solutions, implementing features, or considering abstractions. Enforces YAGNI, minimal code, and preferring duplication over wrong abstraction.
kimchi:review
This command should be used to run multi-persona review of the implementation plan. Five specialized personas critique the plan for scope creep, complexity, premature optimization, and test coverage. Fifth stage of the Kimchi planning pipeline. Produces .kimchi/PLAN-REVIEWED.md.
kimchi:reset
This command should be used to clear the Kimchi working directory (.kimchi/) and start fresh. Preserves .beads/ directory. Use when starting a new planning session or recovering from a bad state.
kimchi:research
This command should be used to investigate codebase patterns, frameworks, and existing implementations before planning. Third stage of the Kimchi planning pipeline. Produces .kimchi/RESEARCH.md.
kimchi:requirements
This command should be used to extract and categorize requirements from CONTEXT.md into v1 (must have), v2 (next iteration), and out of scope. Second stage of the Kimchi planning pipeline. Produces .kimchi/REQUIREMENTS.md.
kimchi:refine
This command should be used to iteratively improve the plan until quality threshold is reached or diminishing returns detected. Sixth stage of the Kimchi planning pipeline. Produces .kimchi/PLAN-DRAFT.md.
kimchi:plan
This command should be used to run the Kimchi planning pipeline through refinement, transforming a vague idea into a draft plan ready for cross-model analysis. Orchestrates 6 stages: clarify, requirements, research, generate, review, refine. Use --full-auto to also run beads + validate after manual revise/synthesize.