home / skills / xfstudio / skills / concise-planning

concise-planning skill

safe

/concise-planning

This skill converts a user coding task request into a single, actionable, atomic plan with clear steps and validation.

npx playbooks add skill xfstudio/skills --skill concise-planning

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

Files (1)

SKILL.md

1.3 KB

---
name: concise-planning
description: Use when a user asks for a plan for a coding task, to generate a clear, actionable, and atomic checklist.
---

# Concise Planning

## Goal

Turn a user request into a **single, actionable plan** with atomic steps.

## Workflow

### 1. Scan Context

- Read `README.md`, docs, and relevant code files.
- Identify constraints (language, frameworks, tests).

### 2. Minimal Interaction

- Ask **at most 1–2 questions** and only if truly blocking.
- Make reasonable assumptions for non-blocking unknowns.

### 3. Generate Plan

Use the following structure:

- **Approach**: 1-3 sentences on what and why.
- **Scope**: Bullet points for "In" and "Out".
- **Action Items**: A list of 6-10 atomic, ordered tasks (Verb-first).
- **Validation**: At least one item for testing.

## Plan Template

```markdown
# Plan

<High-level approach>

## Scope

- In:
- Out:

## Action Items

[ ] <Step 1: Discovery>
[ ] <Step 2: Implementation>
[ ] <Step 3: Implementation>
[ ] <Step 4: Validation/Testing>
[ ] <Step 5: Rollout/Commit>

## Open Questions

- <Question 1 (max 3)>
```

## Checklist Guidelines

- **Atomic**: Each step should be a single logical unit of work.
- **Verb-first**: "Add...", "Refactor...", "Verify...".
- **Concrete**: Name specific files or modules when possible.

Overview

This skill generates a single, actionable plan that breaks a coding request into atomic, ordered steps. It produces a compact checklist with scope, approach, and validation so work can be executed or handed off immediately. The plan minimizes questions, making reasonable assumptions when details are non-blocking.

How this skill works

The skill scans available context such as README, docs, and code to detect constraints like language, frameworks, and tests. It asks at most one or two blocking questions; otherwise it assumes sensible defaults. It outputs an Approach, Scope (In/Out), 6–10 verb-first Action Items, a Validation step, and any open questions.

When to use it

When a user asks for a clear implementation plan for a coding task
When converting feature requests or bug reports into an executable checklist
When preparing a small project or pull request with explicit, testable steps
When you need an onboarding-friendly set of tasks for another engineer or automation
When you want a minimal-interaction plan that avoids large ambiguous answers

Best practices

Keep steps atomic: one logical action per checkbox
Start each action with a verb (Add, Refactor, Implement, Verify)
Name files, modules, or tests when known to remove ambiguity
Limit open questions to 1–2 and only include blocking items
Include at least one Validation step that runs tests or verifies behavior
Scope the plan explicitly with In and Out lists to set expectations

Example use cases

Add a new API endpoint with input validation and unit tests
Refactor a module into smaller functions and update integration tests
Implement a CI job for running linters and test suites before merge
Fix a failing test by diagnosing root cause and adding regression coverage
Prepare a small library for release: bump version, update changelog, and add publish step

FAQ

How many questions will the skill ask before producing a plan?

At most one or two questions, and only if lacking critical blocking details; otherwise it assumes reasonable defaults.

How long are action lists and what format are they in?

Action lists contain 6–10 atomic, ordered tasks formatted as verb-first checklist items, including at least one validation step.