playbooks

home / skills / first-fluke / fullstack-starter / workflow-guide

workflow-guide skill

/.agent/skills/workflow-guide

This skill guides multi-agent coordination for complex projects, decomposing tasks with PM Agent, spawning parallel tasks, and ensuring QA review.

npx playbooks add skill first-fluke/fullstack-starter --skill workflow-guide

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

Files (2)
SKILL.md
2.0 KB
---
name: multi-agent-workflow
description: Guide for coordinating PM, Frontend, Backend, Mobile, and QA agents on complex projects via CLI
---

# Multi-Agent Workflow Guide

## When to use

- Complex feature spanning multiple domains (full-stack, mobile)
- Coordination needed between frontend, backend, mobile, and QA
- User wants step-by-step guidance for multi-agent coordination

## When NOT to use

- Simple single-domain task -> use the specific agent directly
- User wants automated execution -> use orchestrator
- Quick bug fixes or minor changes

## Core Rules

1. Always start with PM Agent for task decomposition
2. Spawn independent tasks in parallel (same priority tier)
3. Define API contracts before frontend/mobile tasks
4. QA review is always the final step
5. Assign separate workspaces to avoid file conflicts
6. Always use Serena MCP tools as the primary method for code exploration and modification
7. Never skip steps in the workflow — follow each step sequentially without omission

## Workflow

### Step 1: Plan with PM Agent

PM Agent analyzes requirements, selects tech stack, creates task breakdown with priorities.

### Step 2: Spawn Agents by Priority

Spawn agents via CLI:

1. Use spawn-agent.sh for each task
2. CLI selection follows agent_cli_mapping in user-preferences.yaml
3. Spawn all same-priority tasks in parallel using background processes

```bash
# Example: spawn backend and frontend in parallel
oh-my-ag agent:spawn backend "task description" session-id -w ./backend &
oh-my-ag agent:spawn frontend "task description" session-id -w ./frontend &
wait
```

### Step 3: Monitor & Coordinate

- Use memory read tool to poll `progress-{agent}.md` files
- Verify API contracts align between agents
- Ensure shared data models are consistent

### Step 4: QA Review

Spawn QA Agent last to review all deliverables. Address CRITICAL issues by re-spawning agents.

## Automated Alternative

For fully automated execution without manual spawning, use the **orchestrator** skill instead.

## References

- Workflow examples: `resources/examples.md`

Overview

This skill guides coordination of PM, Frontend, Backend, Mobile, and QA agents for complex projects via a CLI-driven multi-agent workflow. It provides a repeatable sequence for planning, spawning parallel agent tasks, monitoring progress, and final QA review to deliver cross-domain features reliably. The emphasis is on clear API contracts, separated workspaces, and stepwise verification to avoid conflicts.

How this skill works

Start with a PM agent to decompose the request into prioritized tasks and assign workspaces. Spawn domain agents (frontend, backend, mobile, etc.) via the CLI in parallel for same-priority tasks, using background processes and the configured agent mappings. Monitor each agent through progress files and memory tools, confirm API contracts and shared models, then run the QA agent last to validate deliverables and trigger fixes if needed.

When to use it

  • Building a feature that touches frontend, backend, and mobile codebases simultaneously
  • Coordinating multiple specialist agents across a monorepo or polyrepo setup
  • Needing step-by-step guidance for human-in-the-loop multi-agent collaboration
  • Projects where clear API contracts and consistent data models are critical
  • When separate workspaces are required to prevent file conflicts during parallel work

Best practices

  • Always run the PM agent first to produce a prioritized task breakdown
  • Spawn same-priority tasks in parallel but use dedicated workspaces per agent
  • Define and confirm API contracts before frontend or mobile implementation begins
  • Continuously poll progress artifacts (e.g., progress-{agent}.md) to detect drift
  • Keep QA as the final step and re-spawn agents to address critical findings
  • Prefer the established code exploration/modification tools recommended by your team for consistency

Example use cases

  • Implementing a new user onboarding flow that requires backend endpoints, web UI, and mobile screens
  • Coordinating a schema change that affects API, frontend forms, and mobile validation logic
  • Delivering a payment integration where backend, web checkout, mobile flow, and QA testing must align
  • Refactoring shared data models across Next.js and Flutter clients while keeping FastAPI backward compatible
  • Rolling out infrastructure changes with Terraform that require backend and mobile adjustments

FAQ

What if I need fully automated execution?

Use an orchestrator skill designed for end-to-end automation instead of manual CLI spawning.

Can agents write to the same workspace?

No — assign separate workspaces per agent to avoid file conflicts and merge issues; reconcile changes via defined integration steps.