using-beads-bv

Use when coordinating dependency-aware task planning with beads (bd) CLI and bv graph sidecar - covers ready work selection, priority management, and robot flags for deterministic outputs

242 stars

Best use case

using-beads-bv is best used when you need a repeatable AI agent workflow instead of a one-off prompt. It is especially useful for teams working in multi. Use when coordinating dependency-aware task planning with beads (bd) CLI and bv graph sidecar - covers ready work selection, priority management, and robot flags for deterministic outputs

Use when coordinating dependency-aware task planning with beads (bd) CLI and bv graph sidecar - covers ready work selection, priority management, and robot flags for deterministic outputs

Users should expect a more consistent workflow output, faster repeated execution, and less time spent rewriting prompts from scratch.

Practical example

Example input

Use the "using-beads-bv" skill to help with this workflow task. Context: Use when coordinating dependency-aware task planning with beads (bd) CLI and bv graph sidecar - covers ready work selection, priority management, and robot flags for deterministic outputs

Example output

A structured workflow result with clearer steps, more consistent formatting, and an output that is easier to reuse in the next run.

When to use this skill

  • Use this skill when you want a reusable workflow rather than writing the same prompt again and again.

When not to use this skill

  • Do not use this when you only need a one-off answer and do not need a reusable workflow.
  • Do not use it if you cannot install or maintain the related files, repository context, or supporting tools.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/using-beads-bv/SKILL.md --create-dirs "https://raw.githubusercontent.com/aiskillstore/marketplace/main/skills/agentworkforce/using-beads-bv/SKILL.md"

Manual Installation

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

How using-beads-bv Compares

Feature / Agentusing-beads-bvStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Use when coordinating dependency-aware task planning with beads (bd) CLI and bv graph sidecar - covers ready work selection, priority management, and robot flags for deterministic outputs

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

# Using Beads and bv

## Overview

Beads provides a lightweight, dependency-aware issue database. The `bd` CLI manages tasks, while `bv` provides graph metrics and execution planning.

**Project:** [steveyegge/beads](https://github.com/steveyegge/beads)

## When to Use

- Coordinating multi-agent work with dependencies
- Finding ready work (no blockers)
- Priority management and task sequencing
- Understanding project graph metrics

**Don't use:** Simple single-session tasks (use TodoWrite instead).

## Quick Reference

| Command | Description |
|---------|-------------|
| `bd ready` | Show issues ready to work (no blockers) |
| `bd list --status=open` | All open issues |
| `bd list --status=in_progress` | Active work |
| `bd show <id>` | Issue details with dependencies |
| `bd create --title="..." --type=task` | Create new issue |
| `bd update <id> --status=in_progress` | Claim work |
| `bd close <id>` | Mark complete |

## bv Robot Flags (AI Sidecar)

**CRITICAL:** Always use `--robot-*` flags. The interactive TUI will block your session!

```bash
bv --robot-help          # All AI-facing commands
bv --robot-insights      # JSON graph metrics (PageRank, critical path, cycles)
bv --robot-plan          # JSON execution plan with parallel tracks
bv --robot-priority      # Priority recommendations with reasoning
bv --robot-recipes       # List available recipes
bv --robot-diff --diff-since <commit>  # Changes since commit/date
```

### Example: Get Execution Plan

```bash
bv --robot-plan
```

Returns JSON with:
- Parallel tracks (what can run concurrently)
- Items per track
- Unblocks lists (what each completion frees up)

## Common Workflows

### Starting Work

```bash
bd ready                                  # Find available work
bd show <id>                              # Review issue details
bd update <id> --status=in_progress       # Claim it
```

### Completing Work

```bash
bd close <id1> <id2> ...                  # Close completed issues
bd sync                                   # Push to remote
```

### Creating Dependent Work

```bash
bd create --title="Implement feature X" --type=feature --priority=P2
bd create --title="Write tests for X" --type=task --priority=P2
bd dep add <tests-id> <feature-id>        # Tests depend on feature
```

## Priority Levels

Use numeric priorities (NOT "high"/"medium"/"low"):

| Priority | Use Case |
|----------|----------|
| P0 | Critical - blocking everything |
| P1 | High - needs immediate attention |
| P2 | Medium - standard work |
| P3 | Low - nice to have |
| P4 | Backlog - future consideration |

## Conventions

- **Single source of truth:** Use Beads for task status/priority/dependencies
- **Shared identifiers:** Use beads issue ID (e.g., `agent-relay-123`) in commit messages
- **Message subjects:** Prefix with `[agent-relay-123]` for traceability

## Session Close Protocol

Before ending any session:

```bash
bd sync                 # Commit beads changes
git add <files>         # Stage code changes
git commit -m "..."     # Include bd-### in message
bd sync                 # Commit any new beads changes
git push                # Push to remote
```

## Anti-Patterns

| Mistake | Fix |
|---------|-----|
| Using `bv` without robot flags | Always use `--robot-*` flags |
| Managing tasks in markdown | Use `bd` as single task queue |
| Missing issue IDs in commits | Always include `bd-###` |
| Using high/medium/low priority | Use P0-P4 numeric format |

Related Skills

ralph-tui-create-beads

242
from aiskillstore/marketplace

Convert PRDs to beads for ralph-tui execution. Creates an epic with child beads for each user story. Use when you have a PRD and want to use ralph-tui with beads as the task source. Triggers on: create beads, convert prd to beads, beads for ralph, ralph beads.

ralph-tui-create-beads-rust

242
from aiskillstore/marketplace

Convert PRDs to beads for ralph-tui execution using beads-rust (br CLI). Creates an epic with child beads for each user story. Use when you have a PRD and want to use ralph-tui with beads-rust as the task source. Triggers on: create beads, convert prd to beads, beads for ralph, ralph beads, br beads.

using-neon

242
from aiskillstore/marketplace

Guides and best practices for working with Neon Serverless Postgres. Covers getting started, local development with Neon, choosing a connection method, Neon features, authentication (@neondatabase/auth), PostgREST-style data API (@neondatabase/neon-js), Neon CLI, and Neon's Platform API/SDKs. Use for any Neon-related questions.

when-using-flow-nexus-platform-use-flow-nexus-platform

242
from aiskillstore/marketplace

Comprehensive Flow Nexus platform management covering authentication, sandboxes, storage, databases, app deployment, payments, and monitoring. This SOP provides end-to-end platform operations.

when-using-advanced-swarm-use-swarm-advanced

242
from aiskillstore/marketplace

Advanced swarm patterns with dynamic topology switching and self-organizing behaviors for complex multi-agent coordination

beads-workflow

242
from aiskillstore/marketplace

Converting markdown plans into beads (tasks with dependencies) and polishing them until they're implementation-ready. The bridge between planning and agent swarm execution. Includes exact prompts used.

using-superpowers

242
from aiskillstore/marketplace

Meta-skill enforcing skill discovery and invocation discipline through mandatory workflows. Use when starting any conversation to check for relevant skills before any response, ensuring skill-first workflow before proceeding.

using-git-worktrees

242
from aiskillstore/marketplace

Git worktree–based workspace isolation for parallel or non-disruptive development. Use when work must occur without modifying or interfering with the current working tree.

using-argc-argcfile

242
from aiskillstore/marketplace

Create and modify Argcfiles using the special syntax required. Use this when editing Argcfile.sh, @argc, or any shell script that contains `argc --argc-eval`.

using-agent-relay

242
from aiskillstore/marketplace

Use when coordinating multiple AI agents in real-time - provides inter-agent messaging via tmux wrapper (sub-5ms latency) or file-based team inbox for async workflows

using-xtool

242
from aiskillstore/marketplace

This skill should be used when building iOS apps with xtool (Xcode-free iOS development), creating xtool projects, adding app extensions, or configuring xtool.yml. Triggers on "xtool", "SwiftPM iOS", "iOS on Linux", "iOS on Windows", "Xcode-free", "app extension", "widget extension", "share extension". Covers project setup, app extensions, and deployment.

azure-quotas

242
from aiskillstore/marketplace

Check/manage Azure quotas and usage across providers. For deployment planning, capacity validation, region selection. WHEN: "check quotas", "service limits", "current usage", "request quota increase", "quota exceeded", "validate capacity", "regional availability", "provisioning limits", "vCPU limit", "how many vCPUs available in my subscription".

DevOps & Infrastructure