ce:plan

Convert goals into executable plans with YAML frontmatter and repo-relative paths.

Updated Mar 14, 2026
One-click install
npx skills add https://github.com/Andreicr1/netz-analysis-engine --skill ce-plan-andreicr1
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ce:plan
Source: https://github.com/Andreicr1/netz-analysis-engine/tree/main/.gemini/skills/ce-plan
Command: npx skills add https://github.com/Andreicr1/netz-analysis-engine --skill ce-plan-andreicr1

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill empowers teams to convert vague goals into explicit, durable plans that define scope, decisions, and concrete implementation units, enabling traceability and repeatable execution.

Core Features & Use Cases

  • Plan from input: generate a complete plan from a brainstorm, requirements document, bug report, or user description.
  • Define execution units: outline implementation units, dependencies, file references, and verification criteria.
  • Deepen plans: enrich an existing plan with sub-agent findings, risk assessments, and policy implications.
  • Repo-friendly references: ensure all file paths are repo-relative and executable in a team setting.

Quick Start

Describe the task or input and I will generate a complete, implementation-ready plan with units and tests.

Frequently Asked Questions about ce:plan

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

FAQPage Schema
How do I generate an executable software engineering plan from vague requirements?

Plan generation converts vague goals into explicit, executable planning artifacts by integrating origin requirements, research findings, and risk analysis into concrete implementation units with traceable decisions.

What is requirements traceability in project management plans?

Requirements traceability in project management plans ensures that every generated implementation unit and decision explicitly links back to origin requirements and research findings for repeatable execution.

How do I structure implementation units for a multi-step software task?

Structuring implementation units for multi-step software tasks requires outlining dependencies, repo-relative file references, and verification criteria within a plan that enforces YAML frontmatter.

Can I deepen an existing project plan with risk analysis and research findings?

You can deepen an existing project plan by enriching it with sub-agent research findings, risk assessments, and policy implications while preserving the original repo-relative references.

Does the plan generation process support repo-relative file paths for team execution?

The plan generation process supports team execution by enforcing YAML frontmatter and strict repo-relative paths for all plan content, ensuring references remain executable across different environments.

What is the best way to convert a bug report into a structured implementation plan?

The best way to convert a bug report into a structured implementation plan is to use a plan generation process that outlines execution units, dependencies, and verification criteria.