deep-executor

Execute complex multi-file workflows with exploration, planning, and verification.

Updated Feb 20, 2026
One-click install
npx skills add https://github.com/ssccio/cc-on-web-base --skill deep-executor-ssccio
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: deep-executor
Source: https://github.com/ssccio/cc-on-web-base/tree/main/skills/deep-executor
Command: npx skills add https://github.com/ssccio/cc-on-web-base --skill deep-executor-ssccio

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Deep executor mode helps you complete complex, goal-oriented work when the path is unclear and you need thorough exploration, execution, and verification rather than partial progress.

Core Features & Use Cases

  • Explores first to deeply understand the problem using search and code-aware reading.
  • Plans strategically to turn exploration findings into an actionable execution approach.
  • Executes directly and verifies everything by running builds, tests, and diagnostics before claiming completion.
  • Use case: Refactoring a large multi-file codebase where requirements are ambiguous, implementations vary, and you need evidence that changes compile and tests pass.

Quick Start

Activate deep-executor to implement, test, and verify your complex task from exploration through completion.

Frequently Asked Questions about deep-executor

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

FAQPage Schema
How do I execute multi-file code refactoring when the implementation path is unclear?

Complex code refactoring requires deep exploration and strategic planning before execution. A deep executor approach explores the codebase first, performs direct edits, and verifies results with builds and tests to guarantee completion with evidence.

What is deep work execution for complex software engineering tasks?

Deep work execution is an agentic workflow that completes complex software goals end-to-end. It explores problems using code-aware reading, plans an actionable approach, executes edits, and verifies correctness through diagnostics before claiming completion.

How do I verify code changes with automated testing during complex refactoring?

To verify code changes during complex refactoring, execute builds, run tests, and apply diagnostics after performing direct edits. This verification phase ensures correctness and confirms the implementation compiles and tests pass before completion.

Can I use an agentic execution workflow for ambiguous implementation paths?

Yes, agentic execution is designed for situations requiring deep work when the path is unclear. It turns exploration findings into an actionable approach, performs direct edits, and verifies everything to handle ambiguous multi-file codebase requirements.

What is the best way to guarantee completion of complex multi-file refactoring?

Guaranteeing completion of complex multi-file refactoring requires an end-to-end workflow that explores the problem, plans strategically, executes directly, and verifies results with builds, tests, and diagnostics to provide evidence of correctness.