← Back to Portal

CreatePlan Workflow

Multi-AI Project Planning with Agent Assignments & Parallel Execution

From Solution to Executable Plan

CreatePlan takes a solution design (or any "plan ask") and transforms it into an actionable project plan through multi-AI collaboration with explicit agent assignments.

Three AI perspectives (Claude, Gemini, Codex) independently create implementation plans, which are synthesized and peer-reviewed. The final plan specifies which agent handles each task and which tasks can run in parallel.

Result: A comprehensive project plan with clear agent assignments (PM, Architect, Security, Developer, QA) and parallel execution guidance for maximum efficiency.

Agent Assignments

Every task in the final plan specifies which agent should execute it. The available agents are:

🎯

PM

Project orchestration, multi-agent coordination, milestone tracking

🏗

Architect

System design, tech decisions, ADRs, integration patterns

🔒

Security

Network, auth, DNS, secrets, Keycloak, Traefik, SSL/TLS

💻

Developer

Implementation, Docker deployment, debugging, database ops

✅

QA

Test creation, GitLab CI pipelines, quality gates, validation

### Task Format in Final Plan: ### Task: Design OAuth2 Integration - Agent: Security - Support: Architect - Parallel Group: Sequential (blocks implementation) - Dependencies: None - Deliverable: OAuth2 flow diagram, Keycloak client config

Shared Agent Context

To ensure all AIs (Claude, Gemini, Codex) understand the agent capabilities and create consistent plans, a shared reference document is provided to each:

Agent Parallelization Guide

$HOME/projects/ainotes/agentparallel.md

This reference file is automatically included when dispatching to Gemini and Codex, ensuring they understand:

5 Available Agents

PM, Architect, Security, Developer, QA - with their specializations and when to use each.

Task Assignment Format

Standard format with Agent, Support, Parallel Group, Dependencies, and Deliverable fields.

Parallel Execution Rules

Group notation (A, B, C...), dependency rules, and when tasks can run simultaneously.

Best Practices

How to maximize parallelism, avoid pitfalls, and select the right agent for each task type.

How Context Flows to All AIs

flowchart LR subgraph REF["Reference Document"] A[agentparallel.md] end subgraph PLAN["Plan Generation"] A --> C1[Claude] A --> C2[Gemini] A --> C3[Codex] end subgraph REVIEW["Peer Review"] A --> R1[Gemini Review] A --> R2[Codex Review] end C1 --> D[Draft Plan] C2 --> D C3 --> D D --> R1 D --> R2 R1 --> F[Final Plan] R2 --> F style REF fill:#fef3c7,stroke:#f59e0b style PLAN fill:#faf5ff,stroke:#a855f7 style REVIEW fill:#eff6ff,stroke:#3b82f6
# Dispatch template sent to Gemini/Codex: First, read and understand the Agent Parallelization Guide at: $HOME/projects/ainotes/agentparallel.md This document describes: - 5 available agents: PM, Architect, Security, Developer, QA - How to assign agents to each task - How to identify tasks that can run in parallel - Task assignment format and dependency rules Your plan MUST: 1. Assign one of the 5 agents to each task 2. Identify which tasks can run in parallel (same group letter) 3. Specify dependencies between tasks 4. Use the standard task format

Parallel Execution

The final plan identifies which tasks can run simultaneously using parallel group notation:

Parallel Group Notation

Tasks with the same group letter (A, B, C...) can execute simultaneously. Multiple developers can work on independent services at the same time.

Example: Phased Execution with Parallel Groups

gantt title Project Timeline with Parallel Tasks dateFormat X axisFormat %s section Phase 1 Architecture Design (Architect) :a1, 0, 2 Security Review (Security) :a2, 0, 2 section Phase 2 - Parallel A User Service (Dev-1) :b1, 2, 3 Product Service (Dev-2) :b2, 2, 3 Test Specs (QA) :b3, 2, 3 section Phase 3 Integration (Developer) :c1, 5, 2 section Phase 4 - Parallel B CI Pipeline (QA) :d1, 7, 2 Security Audit (Security) :d2, 7, 2
# For parallel tasks, spawn multiple agents simultaneously: Task(pm, "Coordinate Phase 2 tasks...") Task(developer, "Implement User Service...", run_in_background=true) Task(developer, "Implement Product Service...", run_in_background=true) Task(qa, "Create test specifications...", run_in_background=true)

Parallel Execution Rules

Independent Tasks

Tasks with no shared dependencies can run in parallel (same group letter).

Same Agent Type

Multiple developers can work simultaneously on different services (Dev-1, Dev-2).

Cross-Agent Parallel

Architect can plan Phase 2 while Developers implement Phase 1.

The CreatePlan Workflow

End-to-End Process Flow

flowchart TB subgraph INPUT["1. Input"] A[Plan Ask] --> B[Clarify & Format] end subgraph PARALLEL["2. Parallel Plan Generation"] B --> C1[Claude Plan] B --> C2[Gemini Plan] B --> C3[Codex Plan] end subgraph SYNTHESIS["3. Synthesis"] C1 --> D[Claude Synthesizes
All 3 Plans] C2 --> D C3 --> D D --> E[Draft Plan
+ Agent Assignments
+ Parallel Groups] end subgraph REVIEW["4. Peer Review"] E --> F1[Gemini Review] E --> F2[Codex Review] F1 --> G[Incorporate Feedback] F2 --> G end subgraph OUTPUT["5. Output"] G --> H[Final Plan
w/ Agents & Parallel] H --> I[Executive Presentation] end style INPUT fill:#f0fdfa,stroke:#14b8a6 style PARALLEL fill:#faf5ff,stroke:#a855f7 style SYNTHESIS fill:#fef3c7,stroke:#f59e0b style REVIEW fill:#eff6ff,stroke:#3b82f6 style OUTPUT fill:#dcfce7,stroke:#22c55e

Three AI Perspectives

Each AI brings different training backgrounds and reasoning patterns to the planning process:

🟣

Claude

Practical Execution & Integration

Deep architectural analysis, nuanced technical decisions, and integration considerations.

🟢

Gemini

High-Level Architecture & User Workflows

System integration, user flow design, and best practices research with web search.

🔵

Codex

Technical Implementation & Feasibility

Code structure, technical stack choices, implementation order, and potential blockers.

Step-by-Step Process

1

Clarify & Format

Minimal clarification of the plan ask to ensure all AI reviewers interpret requirements consistently.

Output: {descriptor}.plan.ask.md
2

Parallel Plan Generation PARALLEL

All three AIs independently create implementation plans from the same input simultaneously.

Output: .plan.claude.md, .plan.gemini.md, .plan.codex.md
3

Plan Synthesis

Claude analyzes all three plans, assigns agents to tasks, identifies parallel opportunities, creates unified draft.

Output: {descriptor}.plan.draft.md
4

Peer Review PARALLEL

Gemini and Codex review the draft plan, providing feedback on completeness, feasibility, and agent assignments.

Output: .plan.gemini-review.md, .plan.codex-review.md
5

Final Plan

Incorporate peer review feedback, finalize agent assignments and parallel groups.

Output: {descriptor}.plan.final.md
6

Executive Presentation

Create a web-ready visual summary with timeline diagrams, agent workload, and parallel execution visualization.

Output: nginx/sites/{descriptor}-plan/

Final Plan Structure

The final plan includes these required sections:

Executive Summary

2-3 paragraph overview of the project scope and approach.

Phase Breakdown

Tasks organized by execution order with clear milestones.

Task Details

Each task with agent assignment, parallel group, dependencies, and deliverable.

Dependency Graph

Visual Mermaid diagram showing task dependencies and parallel groups.

Agent Workload Summary

Tasks per agent, parallel opportunities, and workload distribution.

Risk Register

Potential blockers and mitigation strategies from multi-AI analysis.

Dependency Graph Example

graph TD A[Architecture Design
Architect] --> B[User Service
Developer-1] A --> C[Product Service
Developer-2] A --> D[Test Specs
QA] B --> E[Integration
Developer] C --> E D --> F[CI Pipeline
QA] E --> F F --> G[Security Audit
Security] subgraph "Parallel Group A" B C D end subgraph "Parallel Group B" F G end

CreateSolution vs CreatePlan

These two skills work together in sequence:

CreateSolution

  • Answers: "What should we build?"
  • Focuses on requirements and design
  • Proposes architecture and approach
  • Defines technology choices
  • Creates solution design document

CreatePlan

  • Answers: "How do we build it?"
  • Assigns agents to each task
  • Identifies parallel execution opportunities
  • Defines phases and dependencies
  • Creates actionable project plan
Shape Requirements → CreateSolution → CreatePlan → Agent Execution

Shape requirements using /feature-forge, /spec-miner, or Spec Review (Open WebUI)

The Power of Multi-AI Planning with Agents

Different AI models see different risks, consider different edge cases, and prioritize different concerns.

By synthesizing three independent plans, assigning specialized agents, and identifying parallel execution paths, CreatePlan produces executable project plans that maximize team efficiency.

Output File Structure

All artifacts are saved to a consistent directory structure:

$HOME/projects/ainotes/createplan/ # Directory for all createplan outputs {descriptor}.plan.ask.md # Clarified plan ask {descriptor}.plan.claude.md # Claude's implementation plan {descriptor}.plan.gemini.md # Gemini's implementation plan {descriptor}.plan.codex.md # Codex's implementation plan {descriptor}.plan.draft.md # Synthesized draft plan {descriptor}.plan.gemini-review.md # Gemini's review feedback {descriptor}.plan.codex-review.md # Codex's review feedback {descriptor}.plan.final.md # Final plan with agents & parallel groups $HOME/projects/nginx/sites/{descriptor}-plan/ # Web presentation index.html # Executive summary with visuals

How to Use

Invoke the Skill

/createplan [your plan ask here]

Example:

/createplan Implement the options finder API as specified in the solution document

The skill will automatically:

  • Create a descriptor based on your input
  • Generate plans from all three AI nodes (in parallel)
  • Synthesize with agent assignments and parallel groups
  • Peer-review the draft (Gemini + Codex in parallel)
  • Deploy an executive presentation to nginx

Why This Approach Works

Clear Ownership

Every task has an assigned agent, eliminating ambiguity about who does what.

Maximum Parallelism

Independent tasks are explicitly grouped for simultaneous execution.

Diverse Perspectives

Three AI models catch blind spots that any single model would miss.

Executable Output

Plans can be directly executed using Claude Code's Task() for spawning agents.

Risk Mitigation

Peer review catches feasibility issues before implementation begins.

Executive Visibility

Web presentation provides stakeholders with clear timeline and workload visibility.