home / skills / madappgang / claude-code / help

help skill

safe

This skill helps you get guidance on Conductor usage, commands, and best practices for planning, implementing, and tracking progress.

npx playbooks add skill madappgang/claude-code --skill help

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

3.1 KB

---
name: help
description: Get help with Conductor - commands, usage examples, and best practices
version: 1.0.0
tags: [conductor, help, documentation, guide]
keywords: [help, guide, usage, commands, reference]
---
plugin: conductor
updated: 2026-01-20

# Conductor Help

Conductor implements Context-Driven Development for Claude Code.

## Philosophy

**Context as a Managed Artifact:**
Your project context (goals, tech stack, workflow) is documented and maintained alongside your code. This context guides all development work.

**Pre-Implementation Planning:**
Before coding, create a spec (WHAT) and plan (HOW). This ensures clear direction and traceable progress.

**Safe Iteration:**
Human approval gates at key points. Git-linked commits for traceability. Easy rollback when needed.

## Available Skills

### conductor:setup
Initialize Conductor for your project.
- Creates conductor/ directory structure
- Generates product.md, tech-stack.md, workflow.md
- Interactive Q&A with resume capability

### conductor:new-track
Create a new development track.
- Generates spec.md with requirements
- Creates hierarchical plan.md (phases -> tasks)
- Updates tracks.md index

### conductor:implement
Execute tasks from your plan.
- Status progression: [ ] -> [~] -> [x]
- Git commits linked to track/task
- Follows workflow.md procedures

### conductor:status
View project progress.
- Overall completion percentage
- Current task and blockers
- Multi-track overview

### conductor:revert
Git-aware logical undo.
- Revert at Track, Phase, or Task level
- Preview before executing
- State validation after revert

## Quick Start

1. **Initialize:** Run `conductor:setup` to create context files
2. **Plan:** Run `conductor:new-track` to create your first track
3. **Implement:** Run `conductor:implement` to start working
4. **Check:** Run `conductor:status` to see progress
5. **Undo:** Run `conductor:revert` if you need to roll back

## Directory Structure

```
conductor/
├── product.md          # Project vision and goals
├── tech-stack.md       # Technical preferences
├── workflow.md         # Development procedures
├── tracks.md           # Index of all tracks
└── tracks/
    └── {track_id}/
        ├── spec.md     # Requirements specification
        ├── plan.md     # Hierarchical task plan
        └── metadata.json
```

## Best Practices

1. **Keep Context Updated:** Review product.md and tech-stack.md periodically
2. **One Task at a Time:** Focus on completing tasks fully before moving on
3. **Commit Often:** Each task should result in at least one commit
4. **Use Blockers:** Mark tasks as [!] blocked rather than skipping silently
5. **Review Before Proceeding:** Use phase gates to verify quality

## Troubleshooting

**"Conductor not initialized"**
Run `conductor:setup` to initialize the conductor/ directory.

**"Track not found"**
Check tracks.md for available tracks. Track IDs are case-sensitive.

**"Revert failed"**
Check for uncommitted changes. Commit or stash before reverting.

## Getting Help

Use `conductor:help` anytime for this reference.
For issues, check the project documentation or file an issue.

Overview

This skill helps you use Conductor to manage Context-Driven Development workflows for Claude Code projects. It provides commands, usage examples, and concise troubleshooting so you can initialize context, create plans, implement work, check progress, and safely revert changes. Use it as an in-tool reference while working through development tracks.

How this skill works

The help skill inspects the Conductor command set and project structure, and returns targeted guidance for each command (setup, new-track, implement, status, revert). It explains what files and folders Conductor generates, expected task states, and common troubleshooting steps. It points to best practices and quick-start steps so you can act immediately.

When to use it

You are starting a new project and need to initialize Conductor.
You want to create a new development track and turn requirements into a plan.
You are implementing tasks and need command syntax, status expectations, or commit guidance.
You need to check project progress, current blockers, or multi-track status.
You must revert recent work or preview a logical undo with git-aware validation.

Best practices

Keep product.md, tech-stack.md, and workflow.md up to date as living project artifacts.
Work one task at a time and move status from [ ] -> [~] -> [x] to keep progress clear.
Commit frequently; each finished task should have at least one linked commit for traceability.
Use blockers ([!]) instead of skipping work and document reasons for blocked tasks.
Run phase-gates and human approval checks before moving to the next phase to ensure quality.

Example use cases

Initialize Conductor: run conductor:setup to scaffold conductor/ and create product.md, tech-stack.md, and workflow.md.
Plan a new feature: run conductor:new-track to generate spec.md and a hierarchical plan.md, then update tracks.md.
Implement a task: run conductor:implement to advance task status and create git-linked commits following workflow.md.
Check progress: run conductor:status to get overall completion percentage, current task, and multi-track overview.
Undo a change: run conductor:revert to preview and execute a git-aware logical undo at track, phase, or task level.

FAQ

What do I do if Conductor is not initialized?

Run conductor:setup to create the conductor/ directory and required context files.

Why can't I find a track?

Open tracks.md to see available track IDs; IDs are case-sensitive and must match exactly.

Revert failed—what now?

Ensure there are no uncommitted changes. Commit or stash them, then retry revert; use the preview step to verify the outcome before executing.