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.

7 stars

Best use case

kimchi:validate is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

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.

Teams using kimchi:validate 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

$curl -o ~/.claude/skills/validate/SKILL.md --create-dirs "https://raw.githubusercontent.com/Tromml/kimchi/main/plugins/kimchi/skills/validate/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/validate/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How kimchi:validate Compares

Feature / Agentkimchi:validateStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

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.

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 Validate

<command_purpose>
Ensure each bead is standalone-executable by running 4 validators. Auto-enrich failing beads. Flag for human review if enrichment can't fix them.
</command_purpose>

## Input

Read all `.beads/*.yaml` files (excluding `manifest.yaml`).

Parse `$ARGUMENTS`:
- `--loops N`: Max enrichment iterations per bead (default: 3)
- `--bead ID`: Validate only one specific bead

## Process

### 1. Run All Validators Per Bead

For each bead, run these 4 checks:

**Context Completeness:**
- Every file reference has a `find:` strategy
- Find terms are specific enough to be unique
- Find terms are stable (class/method names, not comments or TODOs)
- Scope is appropriate for purpose
- Error handling patterns referenced when task involves error handling
- FAIL if: any line number reference, implicit references, find terms matching multiple locations

**Deliverables Clarity:**
- Each deliverable has explicit type (file_create, file_modify, file_delete)
- file_create has full path
- file_modify has find: anchor point
- Descriptions are concrete (not "update the service")
- FAIL if: missing path, file_modify without anchor, vague descriptions

**Test Specification:**
- Test file path specified
- Test cases are scenarios, not vague ("uploads file" not "test uploading")
- Edge cases included (minimum by complexity: S=2, M=4, L=6)
- Run command provided
- FAIL if: no test file, fewer than minimum cases, no run command

**Isolation Check:**
- No references to other beads' internal details
- Dependencies only reference bead IDs
- All context is embedded or findable via find: landmarks
- No pronouns without antecedents ("it", "the others")
- Acceptance criteria don't reference other beads' outputs
- FAIL if: prose references to other beads, missing context

### 2. Enrichment Loop

For each failing bead:
```
while (score < passing) and (iterations < max_loops):
    identify what's missing
    enrich the bead:
      - Add missing context references (search codebase for find: terms)
      - Add missing find: anchors for file_modify deliverables
      - Add test cases to meet minimum
      - Replace vague descriptions with concrete ones
      - Resolve cross-bead references to actual file references
    re-validate
```

### 3. Flag Unrepairable Beads

If a bead can't pass after max_loops:
- Flag it in the report
- List specific failures
- Suggest manual fixes

### 4. Write Validation Report

Write `.kimchi/VALIDATION-REPORT.md`:

```markdown
# Bead Validation Report

**Validated:** [today's date]

## Summary

| Bead | Context | Deliverables | Tests | Isolation | Status |
|------|---------|-------------|-------|-----------|--------|
| 001 | PASS | PASS | PASS | PASS | PASS |
| 002 | ENRICHED | PASS | PASS | PASS | PASS |
| 003 | PASS | PASS | ENRICHED | PASS | PASS |

## Enrichments Applied

### Bead [ID]
- [What was enriched and why]

## Failed Beads (Require Manual Fix)

### Bead [ID]
- [What failed and suggested fix]

## Result

[N] of [N] beads validated and ready.
```

### 5. Post-Validation Guidance

Read `.beads/manifest.yaml` and check the `orchestration` field.

**If `acfs` or missing:** Offer to push beads to beads-sync branch:
```
Push beads to beads-sync branch? [y/n]
```
If yes:
```bash
git add .beads/
git commit -m "kimchi: validated beads for [feature name]"
git push origin HEAD:beads-sync
```

**If `gastown`:**
```
🏘️ These are GasTown-compatible beads. Do NOT push to beads-sync.
The .beads/ directory is ready for the mayor to pick up.
Use the GasTown mayor process to begin execution.
```

Report: "[N] beads validated. Saved report to .kimchi/VALIDATION-REPORT.md"

Related Skills

kimchi:verification-before-completion

7
from Tromml/kimchi

Use when about to claim work is complete, fixed, or passing — before committing or creating PRs. Evidence before assertions, always.

kimchi:tdd

7
from Tromml/kimchi

Use when implementing any feature, bugfix, or behavior change — before writing implementation code. Enforces RED-GREEN-REFACTOR cycle.

kimchi:systematic-debugging

7
from Tromml/kimchi

Use when encountering any bug, test failure, or unexpected behavior — before proposing fixes. Enforces 4-phase root cause analysis.

kimchi:status

7
from Tromml/kimchi

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

7
from Tromml/kimchi

Use when designing solutions, implementing features, or considering abstractions. Enforces YAGNI, minimal code, and preferring duplication over wrong abstraction.

kimchi:review

7
from Tromml/kimchi

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

7
from Tromml/kimchi

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

7
from Tromml/kimchi

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

7
from Tromml/kimchi

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

7
from Tromml/kimchi

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

7
from Tromml/kimchi

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.

kimchi:plan-synthesize

7
from Tromml/kimchi

This command should be used to synthesize multiple cross-model plan revisions into a superior hybrid plan. Eighth stage of the Kimchi planning pipeline. Reads PLAN-REVISED-*.md files and outputs PLAN-SYNTHESIZED.md — the TRUE final plan.