deepen-plan_skill

Overview

This skill enhances an existing engineering plan by spawning parallel research and review agents for each major section. It enriches sections with best practices, performance tips, UI/UX improvements, concrete implementation guidance, and relevant institutional learnings. The result is a production-ready, deeply grounded plan with prioritized, actionable changes.

How this skill works

The skill reads a specified plan file, builds a section manifest, and discovers all available skills, agents, and project learnings. It launches parallel sub-agents per matched skill, relevant learning, and per-section research reviewers, collects their outputs, deduplicates and prioritizes findings, then injects concrete recommendations back into each original section. It preserves original content while appending research insights, code patterns, anti-pattern warnings, and references.

When to use it

• You have a draft or existing plan that needs production hardening and implementation detail.
• You want parallelized research across architecture, implementation, performance, security, and UX for each plan section.
• You need to apply past project learnings and institutional fixes to avoid repeating mistakes.
• You want a prioritized list of concrete tasks, code examples, and acceptance criteria for engineers.
• You need to surface edge cases, performance trade-offs, and measurable targets before development.

Best practices

• Always provide a valid plan file path; the skill will prompt if none is given.
• Keep plans sectioned (overview, solution, architecture, phases, acceptance criteria) to improve research granularity.
• Accept and review prioritized findings—conflicting recommendations are flagged for human decision.
• Limit injection to enhancements only; the original text is preserved for traceability.
• Run this early in planning to catch architectural and cross-cutting concerns before implementation.

Example use cases

• Deepen a Rails feature plan with DB query, caching, and deployment learnings to avoid N+1s and cache stampedes.
• Enhance a frontend+API plan with per-section UX research, accessibility checks, and performance budgets.
• Apply institutional learnings to a migration or refactor plan to reuse proven fixes and avoid regressions.
• Turn a high-level proposal into a developer-ready spec with code examples, tests, and acceptance criteria.
• Run a security- and performance-focused pass before a major release to prioritize mitigations and benchmarks.