Deep Planning Command

/deep-planning converts Sypha into a thorough architect who examines your codebase, poses clarifying questions, and develops a detailed implementation plan prior to writing any code.

When you employ /deep-planning, Sypha executes a four-phase process that reflects how experienced developers tackle complex features: comprehensive investigation, discussion & clarification of requirements, meticulous planning, and organized task creation with progress monitoring.

The Four-Step Process

Step 1: Silent Investigation

Sypha assumes the role of a detective, quietly exploring your codebase to comprehend its architecture, patterns, and limitations. He inspects source files, evaluates import patterns, uncovers class hierarchies, and detects technical debt indicators. No commentary, no narration - purely concentrated research.

Throughout this phase, Sypha executes commands such as:

• Locating all class and function definitions throughout your codebase
• Evaluating import patterns to comprehend dependencies
• Uncovering project structure and file arrangement
• Detecting TODOs and technical debt

Step 2: Discussion and Questions

After Sypha comprehends your codebase, he poses focused questions that will influence the implementation. These aren't broad questions - they're tailored to your project and the feature you're developing.

Questions may address:

• Clarifying unclear requirements
• Selecting between equally viable implementation strategies
• Validating assumptions about system functionality
• Understanding preferences for technical choices

Step 3: Implementation Plan Document

Sypha produces a structured markdown document (implementation_plan.md) that functions as your implementation blueprint. This isn't an ambiguous outline - it's a comprehensive specification with precise file paths, function signatures, and implementation sequence.

The plan encompasses eight thorough sections:

• Overview: The objective and high-level strategy
• Types: Complete type definitions and data structures
• Files: Precise files to create, modify, or delete
• Functions: New and modified functions with signatures
• Classes: Class modifications and inheritance specifics
• Dependencies: Package requirements and versions
• Testing: Validation approaches and test requirements
• Implementation Order: Sequential execution steps

Step 4: Implementation Task Creation

Sypha generates a new task that references the plan document and incorporates trackable implementation steps. The task arrives with particular commands to access each section of the plan, guaranteeing the implementing agent (whether that's you or Sypha in Act Mode) can navigate the blueprint effectively.

Using Deep Planning

Initiate a deep planning session by entering /deep-planning followed by your feature description:

/deep-planning Add user authentication with JWT tokens and role-based access control

Sypha will commence his investigation promptly. You'll observe him reading files and executing commands to understand your codebase. After he's collected sufficient context, he'll engage you in discussion prior to generating the plan.

Example Workflow

Here's how I utilize /deep-planning for an actual feature:

Integration with Plan/Act Mode

Deep Planning is engineered to integrate seamlessly with Plan/Act Mode:

• Utilize /deep-planning in Plan Mode for the investigation and planning phases
• The generated task requests transitioning to Act Mode for implementation
• Focus Chain automatically monitors progress through the implementation steps

This separation guarantees planning remains concentrated on architecture while implementation remains concentrated on execution.

Best Practices

When to Use Deep Planning

Apply /deep-planning for:

• Features affecting multiple parts of your codebase
• Architectural modifications requiring meticulous coordination
• Complex integrations with external services
• Refactoring initiatives that demand systematic execution
• Any feature where you'd typically spend time whiteboarding

Making the Most of Investigation

Allow Sypha to complete his investigation comprehensively. The plan's quality directly correlates with how thoroughly he understands your codebase. If you have particular areas he should investigate, reference them in your initial request.

Reviewing the Plan

Always examine implementation_plan.md prior to beginning implementation. The plan is thorough but not unchangeable - you can modify it directly if necessary. Consider it as a collaborative document between you and Sypha.

Tracking Progress

With Focus Chain activated, your implementation progress appears in the task header. Each completed step receives automatic verification as Sypha progresses through the plan, providing you real-time visibility into complex implementations.

Inspiration

I utilize /deep-planning whenever I'm preparing to build something that would typically require a design document. Recent examples from my workflow:

• Migrating authentication systems: Deep Planning charted every endpoint, identified all authentication touchpoints, and developed a migration plan that prevented breaking changes.

• Adding real-time features: The plan encompassed WebSocket integration, event handling, state synchronization, and fallback mechanisms for disconnections.

• Database schema refactoring: Sypha identified all impacted queries, generated migration scripts, and strategized the rollout to minimize downtime.

• API versioning implementation: The plan outlined route changes, backward compatibility layers, deprecation notices, and client migration paths.

The strength of /deep-planning is that it enforces thoughtful architecture prior to implementation. It's like having a senior developer assess your approach before you write code, except that developer possesses complete knowledge of your entire codebase.

For simpler tasks that don't necessitate extensive planning, consider utilizing /newtask to establish focused tasks with context, or proceed directly into implementation if the path forward is evident.