bead-forge

Decompose feature descriptions and discussions into actionable beads with acceptance criteria.

1|Updated May 15, 2026
One-click install
npx skills add https://github.com/mslshao/claude-harness --skill bead-forge
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: bead-forge
Source: https://github.com/mslshao/claude-harness/tree/main/dotclaude/skills/bead-forge
Command: npx skills add https://github.com/mslshao/claude-harness --skill bead-forge

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill turns vague feature ideas, deep analysis threads, or partially explored implementation plans into well-structured beads that are immediately actionable. It reduces revision churn by front-loading scope clarification, acceptance criteria, dependencies, and design notes so work can start without repeated back-and-forth.

Core Features & Use Cases

  • Feature decomposition into execution-ready beads: Break a feature, port, or epic into bounded work items with priorities, estimates, dependencies, acceptance criteria, and implementation guidance.
  • Checkpointing important context: Preserve decisions, discoveries, reviews, and memory-worthy conclusions before conversation compaction loses them.
  • Built-in quality gates: Applies granularity rules, self-check criteria, challenge steps for multi-bead plans, and correct bead wiring and labeling conventions.
  • Use case: When a large migration or feature discussion has produced design conclusions across many turns, use this Skill to create beads that both capture the rationale and define the next implementation steps.

Quick Start

Ask the bead-forge skill to decompose your feature or checkpoint the current conversation into beads with acceptance criteria, design notes, and dependencies.

Frequently Asked Questions about bead-forge

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I decompose a large feature into actionable engineering tasks?

Feature decomposition breaks feature descriptions, source files, and existing epics into actionable beads with priorities, estimates, acceptance criteria, and dependency ordering. This front-loads scope clarification to reduce revision churn and implementation back-and-forth.

What is the best way to checkpoint engineering decisions before context is lost?

Checkpointing preserves decisions, discoveries, reviews, and memory-worthy conclusions into persistent memory records and beads before conversation compaction loses them. This captures both the rationale and the next implementation steps for future reference.

How do I map dependencies when planning a software migration?

Dependency mapping identifies and orders work item relationships during migration breakdowns or feature planning. It ensures correct bead wiring by structuring titles, priorities, estimates, and design notes so bounded work items execute in the proper sequence.

Can I use acceptance criteria to scope software implementation tasks?

Yes, acceptance criteria define specific conditions for task completion during implementation scoping. Structured bead drafting applies granularity rules and self-check criteria to ensure work items are bounded, testable, and immediately ready for execution.

Does task decomposition require source files and existing epics as input?

Task decomposition accepts feature descriptions, source files, existing epics, and accumulated discussion context as input. It processes this mixed context to produce structured beads with category labeling and memory index maintenance.

What are the limitations of using beads for work planning?

Work planning with beads requires structured drafting with titles, priorities, estimates, and design notes, which adds upfront effort. However, built-in quality gates apply challenge steps for multi-bead plans to maintain granularity and correct labeling conventions.