zenflow

Audit codebase against code standards. Pass "changed" for diff-only mode.

Diagnose and fix a bug with parallel diagnostic agents

Run all quality gates — lint, format, tests, docs, journal

Shed context mid-session with a knowledge handoff document for clean resumption after /clear.

Execute a plan with parallel subagents per task

Create or update project documentation

Execute a plan step-by-step with review checkpoints

Brainstorm and design — three modes (explore, discover, design) based on idea maturity

Write a detailed implementation plan from a spec or design

Structured refactoring — analyze, propose, test, execute

Request a code review from a reviewer subagent

Quick project snapshot. Pass "recent" to verify recent work.

Show the zenflow workflow menu — pick a skill to invoke

Fresh specialist agent spawned by zenflow:collab to handle issues extracted from the primary working session. Receives a structured handoff with full context, fixes the issue independently and reports back.

Expert error coordinator specializing in distributed error handling, failure recovery, and system resilience. Masters error correlation, cascade prevention, and automated recovery strategies across multi-agent systems with focus on minimizing impact and learning from failures.

Expert error detective specializing in complex error pattern analysis, correlation, and root cause discovery. Masters distributed system debugging, error tracking, and anomaly detection with focus on finding hidden connections and preventing error cascades.

Audit codebase sections against configurable code standards using parallel specialist agents. Use when checking code quality, enforcing standards, or running periodic health checks on the codebase.

Use when fixing bugs, errors, or unexpected behavior. Launches parallel diagnostic agents then a specialist to fix. Use for any issue that starts with "X is broken", "X doesn't work", error reports, or failing tests.

Validate completed work passes all quality gates (lint, format, tests, docs, journal). Use after finishing implementation tasks to ensure nothing is missed. Fixes failures automatically using subagents.

Collaborative working session — you and the user are a team exploring, building, and troubleshooting together. When issues arise, extract them with full context and delegate to fresh agents so the primary session stays clean and productive.

Shed accumulated context mid-session. Writes a knowledge handoff document capturing session state, decisions, observations, and behavioral calibration, then guides the user through /clear and resumption.

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

Create or update project documentation. Use when adding new features, changing architecture, or when docs are missing or outdated. Generates README, ARCHITECTURE, API docs, and guides.

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

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.

Study the codebase and available agents to generate a zen.local.md config. Run once to onboard a new project, or re-run to update config after adding agents.

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

Structured refactoring pipeline — analyze target code, propose changes with before/after examples, plan, execute with regression coverage. Use when improving existing code without changing behavior.

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

Quick project status — active plans, task progress, git state, and session history. Use when resuming work, checking progress, or handing off between sessions. Pass 'recent' to verify each task was actually completed.

Prevent common testing anti-patterns that undermine test effectiveness and code quality by ensuring tests verify real behavior rather than mock behavior, keeping production code free from test-only pollution, and enforcing thoughtful mocking strategies. Use this skill when writing or modifying any test files (.test.ts, .test.js, .spec.ts, _test.py, test_*.py, *_test.go, *_spec.rb), when adding mock objects, stubs, spies, or test doubles to test suites, when considering adding methods or properties to production classes that are only called from test code, when setting up complex test fixtures or test data, when tests are failing and you're tempted to adjust mocks to make them pass, when deciding how to isolate code under test from external dependencies, when implementing dependency injection or test seams, during code reviews when reviewing test implementation and mocking strategies, when refactoring tests that have become brittle or hard to maintain, when test setup code is becoming longer than the actual test assertions, or when choosing between integration tests with real components versus unit tests with mocks.