deep-plan

Audit code architectures by resolving ambiguities and defining PBT invariants.

27|1|Updated Jan 9, 2026
One-click install
npx skills add https://github.com/Till-Crazy-Tears-Us-Apart/Claude-Code-Engineering-Suite --skill deep-plan-till-crazy-tears-us-apart
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: deep-plan
Source: https://github.com/Till-Crazy-Tears-Us-Apart/Claude-Code-Engineering-Suite/tree/main/skills/deep-plan
Command: npx skills add https://github.com/Till-Crazy-Tears-Us-Apart/Claude-Code-Engineering-Suite --skill deep-plan-till-crazy-tears-us-apart

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

This Skill prevents AI from writing code based on incomplete information or unaddressed ambiguities, ensuring architectural soundness and risk mitigation before implementation begins.

Core Features & Use Cases

  • Interactive Ambiguity Resolution: Forces AI to ask clarifying questions until all technical decisions are locked.
  • Invariant Definition: Establishes mathematical properties (like idempotency) that code must satisfy.
  • Logic & Risk Audit: Analyzes data flow, complexity, and potential system side effects.
  • Physical Change Simulation: Previews exact file modifications.
  • Use Case: Before refactoring a critical payment processing module, use Deep Plan to ensure all edge cases, error handling strategies, and data consistency requirements are explicitly defined and agreed upon.

Quick Start

Use the deep-plan skill to audit the proposed implementation plan for the new user authentication system.

Frequently Asked Questions about deep-plan

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
What is a zero-code architectural audit and when do I need one?

A zero-code architectural audit resolves technical ambiguities, defines invariants, and simulates physical file changes before implementation. You need this pre-implementation audit for complex refactoring, new feature development, and high-risk operations to mitigate architectural risks.

How do I ensure AI resolves all ambiguities before writing code?

To ensure AI resolves ambiguities before coding, use an interactive pre-implementation audit that forces clarifying questions until all technical decisions are locked. This decision-first methodology requires explicit user input to resolve gaps in the proposed plan.

How do I define property-based testing invariants for a refactoring plan?

Define property-based testing invariants during the architectural audit phase by establishing mathematical properties, such as idempotency, that the final code must satisfy. This ensures your refactoring plan maintains strict data consistency and logic integrity.

Can I preview exact file modifications before starting a high-risk refactoring?

Yes, you can preview exact file modifications through physical change simulation. This audit step analyzes data flow, complexity, and potential system side effects to show exactly how files will be altered before any actual coding begins.

Does this pre-implementation planning approach work for critical payment processing modules?

Yes, this pre-implementation planning approach works for critical payment processing modules. It explicitly defines edge cases, error handling strategies, and data consistency requirements, ensuring architectural soundness for high-risk operations before any code is written.

What are the limitations of using a decision-first methodology for software planning?

The limitation of a decision-first methodology is that it requires interactive user input for ambiguity resolution and strict adherence to predefined audit templates. It is not suited for rapid prototyping or scenarios where skipping pre-implementation risk assessment is acceptable.