dev-flow

Orchestrate memory-first software development across parallel lead and wing lanes.

Updated Dec 20, 2025
One-click install
npx skills add https://github.com/chronista-club/claude-plugin-vantage-point --skill dev-flow-chronista-club
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: dev-flow
Source: https://github.com/chronista-club/claude-plugin-vantage-point/tree/main/skills/dev-flow
Command: npx skills add https://github.com/chronista-club/claude-plugin-vantage-point --skill dev-flow-chronista-club

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It solves the fragmentation of the software development process by unifying idea, discussion, spec, implementation, review, and merge into a single memory-first orchestration stream across parallel lanes.

Core Features & Use Cases

  • Lead×Wing development orchestration: Use lead to hear, debate, and decide, then hand off work to wing lanes for implementation and reporting.
  • Wire-based stateful communication: Transport decisions and progress as thread messages with explicit kinds (task/question/approve/complete) to derive control state.
  • Memory-first decision lineage: Persist decisions and rationale in canonical spec memory, then project it into future session contexts.
  • Parallel wing tracking with HITL escalation: Automatically self-run when specs are clear, and switch to human-in-the-loop when design decisions or ambiguity require lead control.
  • Multi-phase dev flow: Run a structured 6-phase loop (hearing → council discussion → spec memory → wing handoff → parallel tracking → merge + feedback).

Quick Start

Ask your AI to set up a dev-flow run by creating a wing lane, sending a task spec via wire, and then tracking control state until the wing reports complete and you proceed to merge.

Frequently Asked Questions about dev-flow

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

FAQPage Schema
How do I manage parallel development lanes and track task handoffs?

Parallel development is managed by orchestrating a lead×wing×memory stream, where the lead lane hands off task specs to wing lanes and tracks progress via wire protocol messages until completion and merge.

What is the best way to maintain decision lineage across multiple development sessions?

Maintaining decision lineage requires a memory-first orchestration approach that persists decisions and rationale in canonical spec memory, projecting this context into future sessions for consistent parallel tracking.

How do I trigger human-in-the-loop escalation during an automated parallel development workflow?

Human-in-the-loop escalation is triggered automatically when the workflow encounters design decisions or ambiguity, switching control from autonomous wing execution back to the lead for direction.

Does parallel development orchestration require a specific message protocol for state tracking?

Parallel development orchestration requires a message-kind wire protocol using task, question, approve, and complete messages to derive control state and manage the finite state machine across wing lanes.

Can I use a structured multi-phase development loop for spec creation and merge feedback?

A structured multi-phase development loop runs sequentially through hearing, council discussion, spec memory creation, wing handoff, parallel tracking, and merge feedback to unify scattered ideas into implementation.

When should I avoid autonomous task execution in a multi-lane development workflow?

You should avoid autonomous task execution when specifications lack clarity, requiring the lead to retain control and resolve ambiguity before proceeding with wing handoff and parallel tracking.