dev-workflow

Abandon active workflow and clear TodoWrite

Interactive design refinement using Socratic method

Execute implementation plan with progress tracking and post-completion actions

Resume interrupted plan execution

Create TDD implementation plan by exploring codebase, resolving ambiguities, and producing executable task list.

THE planning methodology source for this codebase. Use this agent when entering plan mode, designing architecture, planning implementation, or when features require architectural decisions before implementation. Triggers: "design architecture", "plan implementation", "how should I structure", "design the approach", EnterPlanMode. <example> Context: User explicitly requests architectural design for a new feature user: "Design the architecture for a caching layer" assistant: "Before implementing, I should get an architectural design to ensure we integrate well with existing patterns." <commentary> Explicit architecture request. Dispatch code-architect to analyze patterns and produce implementation blueprint before writing code. </commentary> assistant: "I'll use the code-architect agent to design the caching layer architecture with focus on minimal changes." </example> <example> Context: Planning phase needs multiple architectural perspectives for trade-off analysis user: "Plan the real-time notifications feature" assistant: "This feature has multiple valid approaches. I'll get architectural designs to compare trade-offs." <commentary> Complex feature benefits from multiple perspectives. Dispatch parallel code-architect agents with different focuses to present options. </commentary> assistant: "I'll dispatch 3 code-architect agents in parallel: minimal changes, clean architecture, and pragmatic balance." </example> <example> Context: User implicitly needs architecture guidance during refactoring discussion user: "The payment module is getting messy, I want to clean it up" assistant: "Refactoring a core module like payments needs careful planning to avoid breaking existing integrations." <commentary> Implicit architecture need. User wants to refactor but hasn't asked for design - proactively dispatch to prevent ad-hoc changes. </commentary> assistant: "I'll use the code-architect agent to design a refactoring approach with file map and implementation sequence." </example> <example> Context: Proactive triggering during plan mode identifies complex feature user: [EnterPlanMode identifies feature touching 5+ files] assistant: "This plan touches multiple modules. I'll get architectural guidance before detailing implementation steps." <commentary> Proactive trigger based on complexity. Multi-module features need architecture review to ensure consistent integration patterns. </commentary> assistant: "I'll use the code-architect agent to analyze cross-module integration points." </example>

Use this agent when the user asks "how does this codebase work", "find patterns", "explore the code", "what's the structure", or when you need codebase context before planning or implementing a feature. <example> Context: User wants to understand codebase before implementing a feature user: "Plan the user authentication feature" assistant: "Before planning, I need to understand how this codebase handles similar features." <commentary> Feature planning requires codebase context. Dispatch code-explorer to survey patterns, conventions, and integration points before designing. </commentary> assistant: "I'll use the code-explorer agent to survey the codebase for auth patterns and integration points." </example> <example> Context: User explicitly asks about codebase structure user: "How does this codebase handle API endpoints?" assistant: "I'll find existing API implementations to show you the patterns used." <commentary> Explicit codebase question. Dispatch code-explorer to find and document existing patterns with concrete file paths. </commentary> assistant: "I'll use the code-explorer agent to find existing API endpoint patterns." </example> <example> Context: Implicit need for codebase understanding during debugging user: "This error keeps happening in the payment flow" assistant: "I need to understand the payment flow architecture to trace this error effectively." <commentary> Debugging complex flows requires understanding the codebase structure. Dispatch code-explorer to map the payment module before investigating. </commentary> assistant: "I'll use the code-explorer agent to map the payment flow and identify relevant files." </example> <example> Context: Proactive triggering when starting work on unfamiliar codebase user: [First interaction in a new repository] assistant: "I should explore this codebase to understand its patterns before making changes." <commentary> New codebase trigger. Proactively dispatch code-explorer to build context and avoid violating existing conventions. </commentary> assistant: "I'll use the code-explorer agent to survey the project structure and conventions." </example>

Use this agent when the user asks to "review code", "check my changes", "code review", "review my implementation", or when code implementation is complete and ready for quality gate before merge. <example> Context: All plan tasks are complete, tests pass user: "I've finished implementing the feature" assistant: "Before finishing, I should review the implementation for cross-cutting concerns." <commentary> Proactive trigger after implementation. Dispatch code-reviewer to check architecture, security, and test quality before merge. </commentary> assistant: "I'll use the code-reviewer agent to analyze all changes since the base commit." </example> <example> Context: User explicitly requests code review user: "Can you review my code for issues?" assistant: "I'll perform a thorough review checking for security, architecture, and test quality." <commentary> Explicit review request. Dispatch code-reviewer with full scope to identify issues across all changed files. </commentary> assistant: "I'll use the code-reviewer agent to perform a comprehensive review." </example> <example> Context: Workflow step dispatches review as quality gate user: [Swarm execution completes all plan tasks] assistant: "All tasks complete. I need to run a final code review before finishing." <commentary> Workflow-triggered review. Dispatch code-reviewer as mandatory quality gate before declaring work complete. </commentary> assistant: "I'll use the code-reviewer agent for final quality gate on all changes since BASE_SHA." </example> <example> Context: Implicit review need after large refactoring user: "I refactored the authentication module, tests pass" assistant: "Tests passing is good, but refactoring can introduce subtle issues worth reviewing." <commentary> Implicit trigger after significant changes. Even with passing tests, dispatch code-reviewer to catch cross-cutting concerns. </commentary> assistant: "I'll use the code-reviewer agent to check the refactored authentication module." </example>

This skill should be used when the user mentions "flaky tests", "race condition", "timing issues", "wait for", "test sometimes fails", or when tests have inconsistent pass/fail behavior. Replaces arbitrary timeouts with condition polling.

This skill should be used when the user asks for "defensive coding", "input validation", "prevent bugs", "multiple validation layers", or when fixing bugs caused by invalid data reaching deep execution. Validates at every layer.

Guide completion of development work by presenting merge/PR options. Use when "I'm done", "merge this", "create PR", "finish up", or when implementation is complete and tests pass.

This skill is loaded automatically at session start via SessionStart hook. Establishes protocols for finding and using skills, checking skills before tasks, brainstorming before coding, and creating TodoWrite for checklists.

Prevents over-engineering by enforcing industry-proven principles: AHA (Avoid Hasty Abstractions), YAGNI, Colocation, and Rule of Three. Use when designing features, planning architecture, "architect this", "design the structure", or when the code-architect agent is dispatched. Triggers: file structure, module organization, abstraction decisions, component splitting.

2 hooks across 2 events