Deep Strategy Generation

VerifiedSafe

Generate comprehensive multi-approach strategies with domain knowledge extraction, alternative approaches, failure mode analysis, and risk-aware plans.

Sby Skills Guide Bot
ProductivityIntermediate
7/25/2026
Claude CodeCursorCodex
#strategic-planning#risk-assessment#codebase-analysis#decision-making#architecture

Recommended for

Automated summary

This skill produces a structured strategic analysis before execution: it surfaces domain knowledge, proposes several alternative approaches, maps failure modes, and assesses risk.

Strengths

  • Always generates 2-3 distinct approaches (conventional, advanced, minimal-change) with steps, costs, and risk level
  • Includes failure-mode analysis with prevention and rollback strategies
  • Explores the existing codebase through Read, Grep, and Glob so the strategy is grounded in real context
  • Emits a structured output format (domain analysis, approaches, prerequisites, validation) that is directly actionable

Limitations

  • The skill stays purely advisory: it does not modify files or execute any of the proposed plans
  • Analysis quality depends entirely on the model's internal knowledge, with no external documentation lookup
  • On simple tasks the output can be unnecessarily long and slow down getting started
When to use it

Use it before starting a complex or ambiguous task where several approaches are viable and a wrong decision would be costly.

When not to use it

Avoid it for trivial or urgent fixes, or when you have already chosen and validated an approach.

Security analysis

Safe
Quality score84/100

This skill is purely a planning/reasoning prompt that instructs the agent to analyze a problem, enumerate approaches, and assess risks. Its declared tool surface (Read, Grep, Glob) is entirely read-only, and the body contains no shell commands, network calls, file mutations, credential handling, or attempts to bypass safety controls. The only theoretical consideration is that it may encourage broader codebase reading via Grep/Glob, but this is standard, non-sensitive exploration.

No concerns found

How this analysis is made

Examples

Plan a database migration
Use deep-strategy to plan migrating our PostgreSQL 12 database to 16 in production. Give me at least three approaches with steps, risks, and rollback plans.
Choose an authentication approach
Before writing any code, run a deep strategic analysis on adding SSO to our Express app: alternative approaches, failure modes, and prerequisites.
Evaluate a refactor
Apply deep-strategy to our monolithic billing module: explore the codebase, then propose conservative vs. aggressive refactoring strategies with risk and validation plans.

name: deep-strategy description: Generate comprehensive multi-approach strategies before execution. Extract domain knowledge, create alternative approaches, identify failure modes, and develop risk-aware plans. Use proactively for complex tasks requiring strategic thinking or when multiple approaches might succeed. allowed-tools: Read, Grep, Glob

Deep Strategy Generation

Apex2's strategy generation phase implemented as a Claude Code skill. Focuses on extracting everything the LLM knows about a problem domain before execution.

Instructions

When invoked, perform deep strategic analysis focusing on knowledge extraction and strategic planning:

1. Domain Knowledge Extraction

Surface all relevant knowledge about the task domain:

  • What frameworks, libraries, or tools are commonly used?
  • What patterns and best practices apply?
  • What are typical approaches for this type of problem?
  • What common pitfalls should be avoided?
  • What are the key decision points?

2. Alternative Approach Generation

Develop 2-3 distinct strategic approaches:

  • Approach A: Most straightforward, conventional solution
  • Approach B: More sophisticated, potentially better performance
  • Approach C: Conservative, minimal change approach
  • Each approach should have:
    • Step-by-step execution sequence
    • Required tools/dependencies
    • Expected outcomes
    • Risk assessment

3. Failure Mode Analysis

Identify common failure scenarios and remediation strategies:

  • Installation/dependency issues
  • Configuration problems
  • Runtime errors
  • Performance bottlenecks
  • Security considerations
  • Data corruption risks

4. Risk Assessment and Mitigation

For each approach, evaluate:

  • Implementation risk (complexity, unfamiliar tech)
  • Operational risk (system impact, data loss potential)
  • Maintenance risk (long-term support, technical debt)
  • Success probability and confidence levels

5. Validation Strategy Planning

Define how success will be verified:

  • Test scenarios and expected results
  • Performance benchmarks if relevant
  • Security validation steps
  • Rollback procedures if things go wrong

6. Prerequisites and Dependencies

List everything needed before starting:

  • Software versions required
  • Configuration files to prepare
  • Data sources needed
  • Permissions or access requirements
  • Environmental setup steps

Category-Specific Strategic Patterns

Software Development Tasks

Consider:

  • Testing strategy (unit, integration, e2e)
  • Code review requirements
  • Documentation needs
  • Rollback capability
  • Performance implications

Data/ML Tasks

Consider:

  • Data validation and quality checks
  • Training parameter selection
  • Model evaluation metrics
  • Resource requirements (CPU/GPU/memory)
  • Result interpretability

System Administration Tasks

Consider:

  • Backup requirements before changes
  • Service maintenance windows
  • Monitoring and alerting setup
  • Rollback procedures
  • Impact on dependent services

Security Operations

Consider:

  • Principle of least privilege
  • Immutable infrastructure practices
  • Audit trail requirements
  • Emergency access procedures
  • Compliance implications

Strategic Analysis Process

  1. Use Grep to search for related patterns in existing codebase
  2. Use Read to examine relevant configuration files, documentation
  3. Use Glob to discover similar tasks or examples
  4. Synthesize findings into comprehensive strategic options
  5. Prioritize approaches based on context and constraints

Output Format

Provide structured strategy output:

Domain Analysis:
  - Key patterns: [list]
  - Common tools: [list]
  - Best practices: [list]
  - Critical considerations: [list]

Strategic Approaches:

Approach A: [Brief name]
  Description: [what it does]
  Steps: [numbered list]
  Pros: [advantages]
  Cons: [disadvantages]
  Risk: [level - Low/Medium/High]
  Success Rate: [estimated]

Approach B: [Brief name]
  [same structure]

Failure Mode Prevention:
  - [issue]: [prevention strategy]
  - [issue]: [prevention strategy]

Recommended Strategy:
  Primary: Approach [A/B/C] - [reasoning]
  Backup: Approach [A/B/C] - [reasoning]
  Validation: [how to verify success]
  Rollback: [how to undo if needed]

Prerequisites:
  Required: [list of must-haves]
  Recommended: [list of should-haves]

When to Use

This skill excels when:

  • Complex, multi-step problems need solving
  • Multiple valid approaches exist
  • High-level strategic planning is needed
  • Domain expertise needs to be extracted
  • Risk assessment is critical
  • Best practices should guide the solution

The goal is to think deeply about the problem space before diving into implementation, ensuring the chosen approach is well-considered and positioned for success.

From the file to a first result

The download contains exactly the content displayed on this page. This copy may differ from the latest version in the source repository.

View the source and supporting files

This download contains SKILL.md only. Any scripts, references, templates and dependencies are not included. Get the required files from the source, preserving their directory structure, before continuing.

1. Download the file

Download SKILL.md

From the root of a test project, save the file as .skill-downloads/deep-strategy-generation-mrzxuqy0/SKILL.md, or use the command below. This folder is for inspecting the skill before installation.

Command for macOS/Linux or WSL: requires a POSIX shell and curl. On Windows without WSL, use the download button and create the folder manually.

mkdir -p '.skill-downloads/deep-strategy-generation-mrzxuqy0' && curl --fail --show-error --location 'https://skills-guides.com/api/skills/deep-strategy-generation-mrzxuqy0/download' --output '.skill-downloads/deep-strategy-generation-mrzxuqy0/SKILL.md.part' && mv '.skill-downloads/deep-strategy-generation-mrzxuqy0/SKILL.md.part' '.skill-downloads/deep-strategy-generation-mrzxuqy0/SKILL.md'

2. Check prerequisites

Read SKILL.md before using it. If it references scripts or external services, inspect them and prepare the required access in your test environment.

Tools declared by the author (check availability in your agent): Read, Grep, Glob

No recognized prerequisites section in this file. This does not mean it is self-contained: libraries, tools and access requirements may be mentioned elsewhere in the content or source repository.

The platforms on this page are catalog indications. The paths below follow tool documentation; they do not prove this skill has been run in those tools. No minimum tool version is confirmed for this listing.

3. Load the skill

After inspection, copy the complete folder into your project using one of the commands below, then open a new tool session. The command stops if a folder with the same name already exists: compare the files before replacing it.

Claude Code
test -f '.skill-downloads/deep-strategy-generation-mrzxuqy0/SKILL.md' && test -s '.skill-downloads/deep-strategy-generation-mrzxuqy0/SKILL.md' && mkdir -p '.claude/skills' && test ! -e '.claude/skills/deep-strategy' && cp -R '.skill-downloads/deep-strategy-generation-mrzxuqy0' '.claude/skills/deep-strategy'

Cursor
test -f '.skill-downloads/deep-strategy-generation-mrzxuqy0/SKILL.md' && test -s '.skill-downloads/deep-strategy-generation-mrzxuqy0/SKILL.md' && mkdir -p '.cursor/skills' && test ! -e '.cursor/skills/deep-strategy' && cp -R '.skill-downloads/deep-strategy-generation-mrzxuqy0' '.cursor/skills/deep-strategy'

Codex
test -f '.skill-downloads/deep-strategy-generation-mrzxuqy0/SKILL.md' && test -s '.skill-downloads/deep-strategy-generation-mrzxuqy0/SKILL.md' && mkdir -p '.agents/skills' && test ! -e '.agents/skills/deep-strategy' && cp -R '.skill-downloads/deep-strategy-generation-mrzxuqy0' '.agents/skills/deep-strategy'

OpenSkills

OpenSkills must already be installed. The local install/read procedure is checked with OpenSkills 1.5.0, which requires Node.js ≥ 20.6.0. Catalog slugs are not resolved automatically.

Official OpenSkills installation
openskills install './.skill-downloads/deep-strategy-generation-mrzxuqy0'

openskills read 'deep-strategy-generation-mrzxuqy0'

Reading should display the installed file content and its base directory. It does not run the skill or install its dependencies.

For an agent that reads AGENTS.md, then sync the index. This command changes AGENTS.md: review the diff before using it.

openskills sync

Manual method or another tool: attach SKILL.md to a conversation, or open it in an agent that can read files. Include any required supporting resources. No universal folder is recognized by every tool.

4. Try a first task

Use a short, synthetic input: an API endpoint, a small document or an interface brief. In a new conversation, attach the file or give the agent its path, then adapt this request:

Read .skill-downloads/deep-strategy-generation-mrzxuqy0/SKILL.md and apply its instructions to this example: [describe a test input]. Identify any missing files, dependencies or access. Produce the result requested by the skill without inventing data or running unreviewed scripts.

Expected result: output matching the skill instructions, or a precise list of missing prerequisites. A read confirmation alone does not validate a first use. If an external resource is unavailable, that path remains untested.

Related skills