home / skills / openai / skills / create-plan

create-plan skill

safe

/skills/.experimental/create-plan

This skill helps you turn a user coding task request into a concise, executable plan with clear scope, actions, and validation.

npx playbooks add skill openai/skills --skill create-plan

Review the files below or copy the command above to add this skill to your agents.

Files (2)

SKILL.md

2.4 KB

---
name: create-plan
description: Create a concise plan. Use when a user explicitly asks for a plan related to a coding task.
metadata:
  short-description: Create a plan
---

# Create Plan

## Goal

Turn a user prompt into a **single, actionable plan** delivered in the final assistant message.

## Minimal workflow

Throughout the entire workflow, operate in read-only mode. Do not write or update files.

1. **Scan context quickly**
   - Read `README.md` and any obvious docs (`docs/`, `CONTRIBUTING.md`, `ARCHITECTURE.md`).
   - Skim relevant files (the ones most likely touched).
   - Identify constraints (language, frameworks, CI/test commands, deployment shape).

2. **Ask follow-ups only if blocking**
   - Ask **at most 1–2 questions**.
   - Only ask if you cannot responsibly plan without the answer; prefer multiple-choice.
   - If unsure but not blocked, make a reasonable assumption and proceed.

3. **Create a plan using the template below**
   - Start with **1 short paragraph** describing the intent and approach.
   - Clearly call out what is **in scope** and what is **not in scope** in short.
   - Then provide a **small checklist** of action items (default 6–10 items).
      - Each checklist item should be a concrete action and, when helpful, mention files/commands.
      - **Make items atomic and ordered**: discovery → changes → tests → rollout.
      - **Verb-first**: “Add…”, “Refactor…”, “Verify…”, “Ship…”.
   - Include at least one item for **tests/validation** and one for **edge cases/risk** when applicable.
   - If there are unknowns, include a tiny **Open questions** section (max 3).

4. **Do not preface the plan with meta explanations; output only the plan as per template**

## Plan template (follow exactly)

```markdown
# Plan

<1–3 sentences: what we’re doing, why, and the high-level approach.>

## Scope
- In:
- Out:

## Action items
[ ] <Step 1>
[ ] <Step 2>
[ ] <Step 3>
[ ] <Step 4>
[ ] <Step 5>
[ ] <Step 6>

## Open questions
- <Question 1>
- <Question 2>
- <Question 3>
```

## Checklist item guidance
Good checklist items:
- Point to likely files/modules: src/..., app/..., services/...
- Name concrete validation: “Run npm test”, “Add unit tests for X”
- Include safe rollout when relevant: feature flag, migration plan, rollback note

Avoid:
- Vague steps (“handle backend”, “do auth”)
- Too many micro-steps
- Writing code snippets (keep the plan implementation-agnostic)

Overview

This skill generates a single, concise, actionable plan for a coding task when requested. It produces a structured checklist-style plan that clarifies scope, ordered steps, and any open questions to remove ambiguity. The output is implementation-agnostic and focused on immediate, testable actions.

How this skill works

The skill inspects the provided project context and constraints, then synthesizes a short intent statement, in-scope/out-of-scope boundaries, and a prioritized checklist of atomic tasks. It asks at most one or two targeted follow-up questions only if a missing fact blocks reasonable planning. The final plan includes validation steps and any open questions needed to proceed.

When to use it

When you explicitly ask for a step-by-step plan for a coding task or feature
When you need a quick, ordered checklist to coordinate implementation and testing
When preparing a scoped implementation for a PR or assignment
When you want clear in-scope vs out-of-scope boundaries before work begins
When you need to identify risks, tests, and rollout steps in advance

Best practices

Provide relevant project context and constraints up front to avoid follow-ups
Keep the requested task focused so the checklist stays small and atomic
Accept at most one short follow-up question to unblock critical unknowns
Ensure each action is verb-first and points to files, commands, or tests when helpful
Include explicit validation, edge-case handling, and a simple rollback or mitigation step

Example use cases

Plan for implementing a new API endpoint including tests and CI checks
Outline steps to refactor a module with migration, tests, and feature flag rollout
Create a bug-fix plan that identifies reproduction steps, fix, tests, and verification
Draft a plan to add logging/observability to a service with rollout and monitoring
Prepare a release task list: build, test, package, deploy, and smoke tests

FAQ

How many follow-up questions will the skill ask?

At most one or two concise questions, and only if a missing fact blocks a responsible plan.

Will the plan include tests and rollback guidance?

Yes. Every plan includes at least one validation/test step and a note on edge cases or rollback when applicable.