ce:plan

Translate feature requirements into structured implementation plans with test scenarios.

Updated Sep 16, 2025
One-click install
npx skills add https://github.com/mukles/platejs-markdown-converter --skill ce-plan-mukles
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ce:plan
Source: https://github.com/mukles/platejs-markdown-converter/tree/main/.agents/skills/ce-plan
Command: npx skills add https://github.com/mukles/platejs-markdown-converter --skill ce-plan-mukles

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Transform feature descriptions or requirements into structured implementation plans grounded in repo patterns and research. Also deepen existing plans with interactive review of sub-agent findings. Use for plan creation when the user says 'plan this', 'create a plan', 'write a tech plan', 'plan the implementation', 'how should we build', 'what's the approach for', 'break this down', or when a brainstorm/requirements document is ready for technical planning. Use for plan deepening when the user says 'deepen the plan', 'deepen my plan', 'deepening pass', or uses 'deepen' in reference to a plan. Best when requirements are at least roughly defined; for exploratory or ambiguous requests, prefer ce:brainstorm first.

Core Features & Use Cases

  • Translate feature descriptions and requirements into structured, implementation-ready plans that reference repo patterns and research.
  • Support for plan deepening with interactive review of sub-agent findings.
  • Guidance for when to use ce:brainstorm vs ce:plan depending on clarity of requirements.

Quick Start

Provide a planning draft that translates the user's input into a structured, testable plan.

Frequently Asked Questions about ce:plan

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

FAQPage Schema
How do I turn feature requirements into an implementation plan?

To turn feature requirements into an implementation plan, you translate feature descriptions into a structured, implementation-ready plan anchored in repository standards. This ensures the output references repo-relative paths and includes explicit test scenarios.

What is the best way to structure a technical plan using repository patterns?

Structuring a technical plan using repository patterns involves mapping requirements to repo-relative paths and defining implementation units. This approach grounds the plan in existing code standards rather than generic architectures.

When should I use a planning skill versus brainstorming for software architecture?

Use a planning skill when requirements are at least roughly defined and you need structured implementation units. For exploratory or ambiguous requests where requirements are unclear, prefer brainstorming first to establish the scope.

How do I deepen an existing implementation plan with risk analysis?

Deepening an implementation plan involves an interactive review of sub-agent findings to add risk analysis and test scenarios. This process enriches the initial plan by validating repository patterns and refining implementation units.

Can I create test scenarios directly from feature descriptions?

Yes, creating test scenarios from feature descriptions is part of generating an implementation-ready plan. The planning process explicitly includes defining test scenarios alongside mapping implementation units to repository paths.

Does implementation planning work without defined repository standards?

Implementation planning is designed to anchor outputs in repository standards and patterns. While it can process minimal inputs, the resulting plan relies heavily on referencing repo-relative paths to be effective.