beads-evolve

Manage adaptive issue graph refinement with git-tracked JSONL history.

1|Updated Feb 2, 2026
One-click install
npx skills add https://github.com/justin-delano/Claude-Config --skill beads-evolve
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: beads-evolve
Source: https://github.com/justin-delano/Claude-Config/tree/main/skills/conditional/beads/evolve
Command: npx skills add https://github.com/justin-delano/Claude-Config --skill beads-evolve

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Adaptive issue evolution patterns for evolving the issue graph during development. The issue graph is a living model of work, not a contract; initial planning captures current understanding, while implementation reveals what we couldn't anticipate. Beads stores history in git-tracked JSONL, enabling safe and auditable evolution.

Core Features & Use Cases

  • Session lifecycle with beads-orient (start) and beads-checkpoint (wind-down)
  • Comprehensive references: beads, beads-prime
  • In-flight adaptation: splitting issues, re-sequencing dependencies, discovering blockers
  • History preservation via git-backed JSONL and automatic graph recalculation

Quick Start

Start a beads session with beads-orient to begin evolution and capture progress with beads-checkpoint.

Frequently Asked Questions about beads-evolve

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

FAQPage Schema
How do I manage issue graph dependencies when implementation reveals new blockers?

Adaptive refinement of the issue graph handles this by supporting in-flight adaptation such as re-sequencing dependencies and discovering blockers. This ensures your development workflow maintains traceability even when initial planning needs adjustment.

What is the best way to split issues for parallel work in a structured workflow?

You can split issues to enable parallel work through a structured workflow using session lifecycle commands. Starting with beads-orient initiates the evolution session, and beads-checkpoint captures progress while preserving the history.

Does git-tracked JSONL format support auditable issue evolution history?

Git-tracked JSONL stores evolution history to provide safe and auditable issue graph refinement. This format enables automatic graph recalculation while maintaining full traceability and reproducibility of all structural changes.

Can I re-sequence dependencies in an issue graph without losing traceability?

Re-sequencing dependencies is supported through enforced safe graph operations that maintain traceability. The system orchestrates evolution commands to ensure dependency changes are captured in the git-backed history without breaking reproducibility.

When do I need adaptive refinement for evolving development graphs?

Adaptive refinement is needed when implementation reveals what you could not anticipate during initial planning. The issue graph acts as a living model of work, requiring in-flight adaptation like splitting issues or re-sequencing dependencies as development progresses.

Why does the issue graph model need automatic recalculation during development?

Automatic graph recalculation is required because the issue graph is a living model rather than a contract. As implementation reveals unanticipated dependencies and blockers, recalculating the graph ensures the evolving model stays accurate while preserving history.