gilfoyle

Full board deliberation with discussion rounds - directors debate and reach consensus

Quick board review - get expert opinions from 5 directors without full deliberation

You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores requirements and design before implementation.

Get strategic business advice from an expert CEO advisor with 30 years of entrepreneurship experience

Get marketing strategy and brand positioning advice from an expert CMO advisor with 30 years of marketing leadership experience

Validate Conductor installation and project state

Show all available Conductor commands organized by category

Run the Evaluate-Loop on a track from current state to completion

Show human-readable message bus history for a track

Migrate legacy tracks to v4 format

Create a new development track with spec, plan, and metadata - interactive workflow

Gracefully pause an in-flight orchestration

Run post-execution quality gate (renamed from phase-review)

Initialize the Conductor environment in a new project - creates conductor/ directory structure

Show current track status with timeline view, active track progress, and next action recommendation

CTO-level technical architecture review (renamed from cto-advisor)

Run CTO-level technical review of the current execution plan - architecture, tech debt, engineering excellence

Get technical architecture and engineering advice from an expert CTO advisor with 30 years of technology leadership experience

Execute plan in batches with review checkpoints

The single entry point to the Conductor system - state your goal and everything is handled via a 3-phase flow: Analyze, Propose, Execute. Supports resume mode, interactive planning, and flags for plan-only, dry-run, and autonomous execution.

Verify implementation quality. Evaluate-Loop Step 4.

Implement tasks from the plan. Evaluate-Loop Step 3.

Fix issues found by evaluation. Evaluate-Loop Step 5.

Validate execution plan against spec. Evaluate-Loop Step 2.

Create execution plan from specification. Evaluate-Loop Step 1.

Dispatch multiple task-workers in parallel based on DAG dependencies.

Run post-execution quality gate - verifies all deliverables before marking a track complete

Execute a single task from the plan. Used for parallel execution.

Run comprehensive UI/UX design validation against design principles, accessibility standards, and usability laws

**Date:** [YYYY-MM-DD]

Get UX strategy and design guidance from an expert UX Designer with 30 years of user experience and product design experience

Create detailed implementation plan with bite-sized tasks

Full Board of Directors deliberation with 5 expert directors assessing, discussing, and voting.

Expert CEO advisor with 30 years entrepreneurship experience. Provides strategic guidance, business analysis, and leadership advice. Advisory only - does not modify code.

Expert CMO advisor with 30 years of marketing leadership experience. Provides marketing strategy, brand positioning, and growth guidance. Advisory only - does not modify code.

Use this agent when a major project step has been completed and needs to be reviewed against the original plan and coding standards. Examples: <example>Context: The user is creating a code-review agent that should be called after a logical chunk of code is written. user: "I've finished implementing the user authentication system as outlined in step 3 of our plan" assistant: "Great work! Now let me use the code-reviewer agent to review the implementation against our plan and coding standards" <commentary>Since a major project step has been completed, use the code-reviewer agent to validate the work against the plan and identify any issues.</commentary></example> <example>Context: User has completed a significant feature implementation. user: "The API endpoints for the task management system are now complete - that covers step 2 from our architecture document" assistant: "Excellent! Let me have the code-reviewer agent examine this implementation to ensure it aligns with our plan and follows best practices" <commentary>A numbered step from the planning document has been completed, so the code-reviewer agent should review the work.</commentary></example>

Master coordinator for the Conductor Evaluate-Loop. Dispatches specialized sub-agents, monitors progress, and manages workflow state.

Expert CTO advisor with 30 years of technology leadership experience. Provides technical architecture, engineering strategy, and technology guidance. Advisory only - does not modify code.

Verifies implementation quality by dispatching specialized evaluators. Evaluate-Loop Step 4.

Implements tasks from the plan sequentially. Evaluate-Loop Step 3.

Fixes issues found by evaluation. Evaluate-Loop Step 5.

Validates execution plan against spec and existing work. Evaluate-Loop Step 2.

Creates execution plan with DAG from specification. Evaluate-Loop Step 1.

Creates tailored brand names through iterative refinement with user input. Use when users need help generating memorable, strategic brand names.

Dispatches multiple worker agents in parallel based on DAG dependencies.

Ephemeral worker for executing a single task. Coordinates via message bus.

Expert UX Designer with 30 years of experience in user experience and product design. Provides UX strategy, design critique, and usability guidance. Advisory only - does not modify code.

Technical leadership guidance for engineering teams, architecture decisions, and technology strategy. Includes tech debt analyzer, team scaling calculator, engineering metrics frameworks, technology evaluation tools, and ADR templates. Use when assessing technical debt, scaling engineering teams, evaluating technologies, making architecture decisions, establishing engineering metrics, or when user mentions CTO, tech debt, technical debt, team scaling, architecture decisions, technology evaluation, engineering metrics, DORA metrics, or technology strategy.

Technical architecture review agent for execution plans. Uses cto-advisor skill to evaluate technical decisions, architecture patterns, tech debt implications, and technology choices in plan.md. Triggered by: 'review technical plan', 'cto review', 'architecture review', or automatically during Step 2 (Evaluate Plan) for tracks involving architecture decisions, integrations, or infrastructure changes.

Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies

Specialized business logic evaluator for the Evaluate-Loop. Use this for evaluating tracks that implement core product logic — pipelines, dependency resolution, state machines, pricing/tier enforcement, packaging. Checks feature correctness against product rules, edge cases, state transitions, data flow, and user journey completeness. Dispatched by loop-execution-evaluator when track type is 'business-logic', 'generator', or 'core-feature'. Triggered by: 'evaluate logic', 'test business rules', 'verify business rules', 'check feature'.

Specialized code quality evaluator for the Evaluate-Loop. Use this for evaluating code implementation tracks where the deliverable is functional code — features, API routes, state management, utilities. Checks build integrity, type safety, code patterns, error handling, dead code, imports, test coverage, and naming conventions. Dispatched by loop-execution-evaluator when track type is 'feature', 'refactor', or 'infrastructure'. Triggered by: 'evaluate code', 'code review', 'quality check', 'build check'.

Specialized integration evaluator for the Evaluate-Loop. Use this for evaluating tracks that integrate external services — Supabase auth/DB, Stripe payments, Gemini API, third-party APIs. Checks API contracts, auth flows, data persistence, error recovery, environment config, and end-to-end flow integrity. Dispatched by loop-execution-evaluator when track type is 'integration', 'auth', 'payments', or 'api'. Triggered by: 'evaluate integration', 'test auth flow', 'check API', 'verify payments'.

Specialized UI/UX evaluator for the Evaluate-Loop. Use this for evaluating UI shell tracks, design system tracks, screen implementation tracks, or any track where the primary deliverable is visual/interactive UI. Checks design system adherence, visual consistency, layout structure, responsive behavior, component states, animations, accessibility baseline, and usability check (copy quality). Dispatched by loop-execution-evaluator when track type is 'ui', 'design-system', or 'screens'. Triggered by: 'evaluate UI', 'UI review', 'design review', 'visual audit'.

Use when implementing any feature or bugfix, before writing implementation code

Manage Conductor tracks, phases, and tasks. Use when working with track status, updating task markers, or navigating between tracks. Enforces the Evaluate-Loop workflow.

Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification

Use when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions

Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always

Use when you have a spec or requirements for a multi-step task, before touching code

Use when creating new skills, editing existing skills, or verifying skills work before deployment

Creates specialized worker agents dynamically from templates. Use when orchestrator needs to spawn task-specific workers for parallel execution. Handles agent lifecycle: create -> execute -> cleanup.

Simulate a 5-member expert board deliberation for major decisions. Use when evaluating plans, architecture choices, feature designs, or any decision requiring multi-perspective expert analysis. Triggers: 'board review', 'get expert opinions', 'board meeting', 'director evaluation', 'consensus review'.

You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.

Synchronize business documents when product, pricing, or model decisions change during track execution

Master coordinator for the Evaluate-Loop workflow v4. Supports GOAL-DRIVEN entry, PARALLEL execution via superpowers agents, BOARD OF DIRECTORS deliberation, and message bus coordination. Dispatches superpowers (writing-plans, executing-plans, systematic-debugging) as PRIMARY path with legacy loop agents as FALLBACK. Uses metadata.json v4 for parallel state tracking. Use when: '/gilfoyle <goal>', '/conductor run', 'start track', 'run the loop', 'orchestrate', 'automate track'.

Use this skill when working with Conductor's context-driven development methodology, managing project context artifacts, or understanding the relationship between product.md, tech-stack.md, and workflow.md files.

Load project context efficiently for Conductor workflows. Use when starting work on a track, implementing features, or needing project context without consuming excessive tokens.

Evaluate-Loop Step 3: EXECUTE. Use this agent to implement tasks from a verified plan. Works through plan.md tasks sequentially, writes code, updates plan.md after every task, and commits at checkpoints. Uses TDD where applicable. Triggered by: 'execute plan', 'implement track', 'build feature', '/conductor implement' (execution phase). Only runs after plan has passed evaluation.

Evaluate-Loop Step 5: FIX. Use this agent when an evaluation (plan or execution) returns FAIL. Takes the evaluator's fix list, creates specific fix tasks in plan.md, executes the fixes, and triggers re-evaluation. Handles the loop-back mechanism of the Evaluate-Loop. Triggered by: evaluation FAIL verdict, 'fix issues', 'address evaluation failures'.

Evaluate-Loop Step 2: EVALUATE PLAN. Use this agent to verify an execution plan before any code is written. Checks scope alignment, overlap with completed work, DAG validity, dependency correctness, task clarity, and invokes Board of Directors for major tracks. Outputs PASS/FAIL verdict. Triggered by: 'evaluate plan', 'review plan', 'check plan before executing'. Always runs after loop-planner and before loop-executor.

Evaluate-Loop Step 1: PLAN. Use this agent when starting a new track or feature to create a detailed execution plan. Reads spec.md, loads project context, and produces a phased plan.md with specific tasks, acceptance criteria, and dependencies. Triggered by: 'plan feature', 'create plan', 'start track', '/conductor implement' (planning phase).

File-based message queue for inter-agent coordination. Used by workers AND board directors to communicate. Provides: progress updates, task completion signals, file locking, board deliberation. Core infrastructure for parallel execution.

Parallel execution engine for dispatching worker agents. Used by conductor-orchestrator to spawn multiple workers simultaneously from DAG parallel groups. Handles dispatch, monitoring, aggregation, and failure recovery.

Harshly critique strategic documents (validation reports, competitive analyses, business plans) to identify blind spots, challenge assumptions, expose weaknesses, and generate Conductor-aligned action plans. Use when you need brutal honesty, "red team" analysis, or want to stress-test your thinking before execution. Applies multiple analytical frameworks (pre-mortem, assumption hunting, competitive gaps, market dynamics) and synthesizes findings into executive summaries with specific, actionable recommendations mapped to Conductor context artifacts.

Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation

Use when completing tasks, implementing major features, or before merging to verify work meets requirements

Use when executing implementation plans with independent tasks in the current session

Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes

Use when you have a written implementation plan to execute in a separate session with review checkpoints

Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup

The single entry point to the Conductor system. Implements the 3-phase flow (Analyze, Propose, Execute) with resume mode, interactive mode, goal clarification, and escalation decision cards. v4 metadata format.

Loads relevant patterns and known errors before track planning. Searches conductor/knowledge/ for solutions we've used before and errors we've encountered. Injects findings into the planner prompt to prevent reinventing solutions and repeating mistakes. Triggered automatically by orchestrator before PLAN step.

Runs after every track completion to extract learnings. Analyzes what worked, what failed, and what patterns emerged. Updates conductor/knowledge/patterns.md with new solutions and errors.json with new error patterns. Proposes skill updates if workflow improvements are identified. Triggered automatically by orchestrator after COMPLETE step.

Architecture consultation for Conductor orchestrator. Makes decisions about system design, patterns, component boundaries, and technical architecture. Can approve architectural choices within established patterns. Escalates novel patterns or breaking changes to user.

Product consultation for Conductor orchestrator. Clarifies scope, interprets ambiguous requirements, prioritizes features within a track. Can make scope interpretations that don't change deliverables. Escalates scope expansions or feature changes to user.

Quality assurance consultation for Conductor orchestrator. Sets test coverage requirements, validates quality gates, determines testing strategy. Can adjust coverage thresholds within ranges. Escalates skipping critical tests to user.

Technical implementation consultation for Conductor orchestrator. Advises on implementation approach, dependency choices, and coding patterns. Can approve dependencies under size threshold. Escalates large dependencies or breaking tooling changes to user.

Evaluate-Loop Step 4: EVALUATE EXECUTION. This is the dispatcher agent — it determines the track type and invokes the correct specialized evaluator. Does NOT run a generic checklist. Instead dispatches to: eval-ui-ux (screens/design), eval-code-quality (features/infrastructure), eval-integration (APIs/auth/payments), eval-business-logic (generator/rules/state). Triggered by: 'evaluate execution', 'review implementation', 'check build', '/phase-review'. Always runs after loop-executor.

1 hook across 1 event