catlog22/claude-code-workflow
Overview
This skill enables interactive, documented brainstorming driven by a file-backed workflow and parallel subagent collaboration. It expands a seed idea through progressive questioning, concurrent multi-perspective analysis, and iterative refinement, producing a complete thought-evolution timeline and structured artifacts. The workflow is optimized for Codex-style agents and JSON-driven orchestration.
How this skill works
The workflow parses a seed idea, generates exploration vectors, and gathers codebase context. It then spawns parallel subagents (creative, pragmatic, systematic) to explore perspectives concurrently, aggregates their outputs, and runs iterative refinement cycles using multi-round agent inputs. Final synthesis and idea deep-dives are written to a session folder with a documented brainstorm.md timeline and related JSON artifacts.
When to use it
- When you need fast, multi-perspective exploration of a technical idea tied to a codebase.
- When you want a documented history of idea evolution and decision rationale.
- When parallel analysis (creative vs pragmatic vs systematic) surfaces better options.
- When you need Codex-compatible agent orchestration with lifecycle control.
- When you want structured outputs for follow-up engineering or product planning.
Best practices
- Start each session with a clear seed idea and chosen brainstorm mode (creative, balanced, structured).
- Let the workflow auto-detect project root to ensure artifacts land in .workflow/.brainstorm session folder.
- Use exploration vectors to steer each perspective agent and keep tasks focused and measurable.
- Spawn parallel agents, batch-wait for results, then synthesize—preserve each agent’s output for auditability.
- Iterate via send_input within agents for multi-round refinement instead of spawning new agents for small follow-ups.
Example use cases
- Evaluate multiple implementation approaches for a new feature while preserving the decision timeline.
- Run rapid innovation sprints that contrast moonshot ideas with pragmatic trade-offs and architecture constraints.
- Audit legacy code to find viable integration strategies and record findings in exploration-codebase.json.
- Produce prioritized recommendations and implementation plans with documented reasoning in synthesis.json.
- Generate and refine multiple candidate designs, each saved as an ideas/{idea-slug}.md deep dive.
FAQ
Agents are spawned concurrently, the workflow uses a batch wait for all agent IDs, then aggregates outputs and closes agents to preserve lifecycle control.
Where do artifacts get stored?
All artifacts live under {projectRoot}/.workflow/.brainstorm/BS-{slug}-{date}/ including brainstorm.md, perspectives/*.json, exploration-codebase.json, ideas/, and synthesis.json.
23 skills
This skill facilitates interactive brainstorming with parallel subagents, documenting thought evolution and synthesizing actionable ideas across multiple
This skill orchestrates unified issue resolution by routing sources, queuing tasks, and exporting JSON task plans for seamless AI-driven planning.
This skill orchestrates a two-person team plan-execute workflow, routing tasks by role and enabling concurrent planning and execution.
This skill orchestrates and executes issue queue solutions end-to-end with per-solution commits and batch processing support.
This skill generates a complete six-phase specification package including product brief, PRD, architecture, and epics to streamline planning.
This skill captures memory with compact session or quick tips, routing input to structured exports or rapid notes.
This skill designs and generates unified team skills with role-based routing, producing a single entry point and per-role execution in a complete skill package.
This skill orchestrates unified multi-dimensional code reviews with dual-mode discovery and automated fix pipelines to accelerate quality and consistency.
This skill coordinates team testing roles to progressively improve test coverage through generator-critic cycles and shared memory for collaborative quality
This skill orchestrates unified brainstorming with auto and single-role modes to generate, analyze, and synthesize actionable feature specs.
This skill generates a requirement roadmap in JSONL with testable convergence criteria, decomposing work into MVP and iterations for progressive or direct
This skill helps you debug with documented exploration, hypothesis logging, and analysis-driven corrections to isolate and fix bugs efficiently.
This skill orchestrates an autonomous end-to-end test-fix cycle, generating sessions and iteratively fixing until 95% pass rate.
This skill converts any planning artifact into .task/.json multi-file format for unified execution and traceable task management.
This skill guides interactive codebase analysis with documented exploration, multi-perspective reasoning, and traceable decisions to convert findings into
This skill helps you orchestrate serial domain planning with a Plan Note, detecting cross-domain conflicts and producing a final plan.
This skill orchestrates CLAUDE.md updates and API/documentation generation by routing inputs and prompting interactive needs assessment.
This skill orchestrates multi-CLI planning and execution by routing to plan or execution modes with enhanced prompts for context-aware results.
This skill orchestrates a four-phase workflow plan, verification, and replanning to deliver IMPL_PLAN.md, tasks, and reports.
This skill orchestrates unified CLI tool execution using config-driven selection to analyze, write, and review code efficiently.
This skill coordinates a parallel four-agent development cycle to analyze requirements, plan exploration, code, and validate with inline orchestration.
This skill orchestrates stateless iterative development loops with file-based state tracking, enabling auto or manual develop, debug, and validate phases.
This skill orchestrates autonomous issue planning and execution for Codex, batching tasks, maintaining persistent dual agents, and generating unified planning
