home / skills / 89jobrien / steve / use-conductor

use-conductor skill

safe

This skill scans the conductor directory to extract project direction, workflows, and task plans, providing actionable context for next work.

npx playbooks add skill 89jobrien/steve --skill use-conductor

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

Files (1)

SKILL.md

3.2 KB

---
name: use-conductor
description: Scan conductor/ directory for project direction, workflows, and task planning when present
---

# Use Conductor

Scan the `conductor/` directory at project root for structured project management files that provide direction, workflows,
and task planning context.

## When to Use

Use this skill when:

- Starting work on a project that may have conductor files
- Looking for project context, guidelines, or current tasks
- Needing to understand the project's workflow methodology
- Determining what work is in progress or next in queue

## Conductor Directory Structure

The conductor system uses this structure:

```text
conductor/
├── product.md              # Product vision and purpose
├── product-guidelines.md   # Standards and conventions
├── tech-stack.md           # Technology decisions
├── workflow.md             # Task execution methodology
├── tracks.md               # Index of active work tracks
├── setup_state.json        # Setup progress state
├── code_styleguides/       # Language-specific style guides
│   ├── general.md
│   └── python.md
└── tracks/                 # Detailed track plans
    └── <track_name>/
        ├── spec.md         # Track specification
        ├── plan.md         # Task checklist with progress
        └── metadata.json   # Track metadata
```

## File Purposes

| File | Purpose |
|------|---------|
| `product.md` | Product vision, target audience, core features |
| `product-guidelines.md` | Naming conventions, quality standards, documentation rules |
| `tech-stack.md` | Approved technologies and libraries |
| `workflow.md` | TDD methodology, task workflow, commit guidelines |
| `tracks.md` | High-level index of all work tracks |
| `tracks/<name>/plan.md` | Detailed task checklist with `[ ]`, `[~]`, `[x]` status |
| `tracks/<name>/spec.md` | Goals, scope, and success criteria for the track |

## How to Scan

1. Check if `conductor/` directory exists at project root
2. If present, read core files to understand project context:
   - `product.md` for vision
   - `product-guidelines.md` for standards
   - `tracks.md` for active work
3. For active tracks (marked `[~]`), read the track's `plan.md` to find current tasks
4. Follow the workflow methodology defined in `workflow.md`

## Task Status Markers

In `plan.md` files:

- `[ ]` - Task not started
- `[~]` - Task in progress
- `[x]` - Task completed (may include commit SHA)

## Integration with Work

When conductor files are present:

1. **Respect the plan** - Follow the task order in `plan.md`
2. **Update status** - Mark tasks as `[~]` when starting, `[x]` when done
3. **Follow workflow** - Use the TDD methodology if specified
4. **Maintain standards** - Follow `product-guidelines.md` and style guides
5. **Stay in scope** - Check `spec.md` for what's in/out of scope

## Example Usage

Before starting work on a project:

```text
User: "What should I work on next?"

Claude: [Checks for conductor/ directory]
        [Reads tracks.md to find active track]
        [Reads tracks/<active>/plan.md to find next [ ] task]
        "According to the conductor plan, the next task is..."
```

Overview

This skill scans a project's conductor/ directory to extract direction, workflows, and task planning information. It surfaces product vision, standards, active work tracks, and per-track plans so you can quickly know what to work on next. The output highlights in-progress tasks, next actionable items, and relevant guidelines to follow.

How this skill works

The skill checks for a conductor/ folder at the project root and reads core files such as product.md, product-guidelines.md, tech-stack.md, workflow.md, and tracks.md. For any active tracks it finds, it opens tracks/<name>/plan.md and spec.md to identify task status markers ([ ], [~], [x]) and the next actionable items. It then summarizes vision, standards, workflow rules, and specific tasks to guide immediate work.

When to use it

On first day working in a repository to get project direction
Before starting any new task to find the next approved item
When you need to follow project-specific workflow or TDD rules
To check which tracks are active and what work is in progress
To verify style guides and tech stack decisions before implementing changes

Best practices

Always open product.md first to understand the goal before modifying code
Respect the plan order in tracks/*/plan.md and update task markers when you start/finish work
Follow workflow.md (for example TDD or commit guidelines) and the language style guides in code_styleguides/
Keep spec.md visible to ensure changes stay in-scope and meet success criteria
When updating plan.md include brief notes or commit SHAs for completed tasks

Example use cases

User asks “What should I work on next?” — skill finds active track and returns the next [ ] task from plan.md
Onboarding a new contributor — summarize product vision, guidelines, and where active work lives
Preparing a PR — confirm relevant style guide, tech decisions, and the track spec to ensure alignment
Daily standup prep — list [~] in-progress tasks and outstanding [ ] items across tracks

FAQ

What file indicates current work in progress?

tracks/<name>/plan.md uses [~] to mark tasks in progress and [ ] for not started.

What if conductor/ is missing?

If conductor/ is not present, the skill reports no conductor files and recommends checking repository docs or asking the team for project context.