pelizzai-writing-plans

Generate structured implementation plans mapping requirements to tasks and acceptance criteria.

Updated Jun 26, 2026
One-click install
npx skills add https://github.com/rpelizza/PelizzAI --skill pelizzai-writing-plans
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: pelizzai-writing-plans
Source: https://github.com/rpelizza/PelizzAI/tree/main/.agents/skills/pelizzai-writing-plans
Command: npx skills add https://github.com/rpelizza/PelizzAI --skill pelizzai-writing-plans

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This skill solves the ambiguity and lack of structure in software development by transforming high-level requirements into concrete, stress-tested implementation plans that an executor can follow without needing further clarification.

Core Features & Use Cases

  • Vertical Slicing: Decomposes complex features into verifiable, end-to-end tasks that can be approved individually.
  • Technical Decision Tracking: Forces explicit ratification of material technical choices, preventing hidden assumptions and ensuring user alignment.
  • Risk-Based Planning: Adjusts the depth of the plan based on the project lane (bounded, standard, or exploratory) to balance speed with safety.
  • Use Case: When starting a new feature, use this skill to generate a plan that maps every requirement to a specific task, defines the validation strategy, and identifies potential technical risks before a single line of code is written.

Quick Start

Use the pelizzai-writing-plans skill to generate an implementation plan for the current requirements and verify all material technical decisions.

Frequently Asked Questions about pelizzai-writing-plans

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

FAQPage Schema
How do I turn product requirements into executable software development plans?

To turn product requirements into executable plans, you need to decompose complex features into verifiable, end-to-end tasks. This process maps every requirement to specific interfaces, acceptance criteria, and validation strategies for zero-context execution.

What is vertical slicing in task decomposition for software engineering?

Vertical slicing in task decomposition is the process of breaking complex features into verifiable, end-to-end implementation tasks. This technique ensures each task can be approved individually and mapped directly to a specific requirement and acceptance criteria.

How do I track technical decisions during workflow automation and feature planning?

To track technical decisions during feature planning, you must force explicit ratification of material technical choices. This prevents hidden assumptions, ensures user alignment, and maps decisions directly to the implementation plan before coding begins.

How does risk-based planning adjust implementation depth for software engineering tasks?

Risk-based planning adjusts implementation depth by evaluating project lanes: bounded, standard, or exploratory. This method balances development speed with safety by scaling the validation strategy and task decomposition rigor according to project uncertainty.

When do I need to define acceptance criteria and validation strategies for my requirements?

You need to define acceptance criteria and validation strategies when starting a new feature that requires zero-context execution. This ensures that potential technical risks are identified and every requirement is verifiable before any code is written.

Can I use this approach for exploratory software development workflows?

Yes, you can use this approach for exploratory workflows by applying risk-based planning. It adjusts the depth of the implementation plan to balance speed with safety, ensuring technical decisions are ratified even in highly uncertain project lanes.