concise-planning

Concise Planning - Quickly Generate Actionable Coding Task Plans

Skill Overview

When a user asks for a plan for a coding task, the Concise Planning skill can quickly produce clear, actionable, and atomic checklists to help developers break down complex requirements into concrete implementation steps.

Use Cases

New Feature Development Planning

- After receiving product requirements, quickly decompose the feature into 6–10 atomic development steps
- Automatically identify technical constraints (language, framework, testing requirements)
- Generate a complete action plan that includes verification and commit stages

Code Refactoring Tasks

- Break refactoring goals down into specific code change steps
- Ensure each step is an independently verifiable atomic operation
- Avoid risks associated with large-scale refactors

Rapid Response for Urgent Tasks

- When information is incomplete, quickly devise an action plan based on reasonable assumptions
- Confirm blockers with at most 1–2 key questions
- Prioritize generating an executable plan to reduce discussion time

Core Features

Intelligent Context Scanning

- Automatically read the project's README.md and related documentation
- Identify tech stack constraints (programming languages, frameworks, testing tools)
- Create task steps that conform to project conventions based on the existing code structure

Minimal Interaction Design

- Only ask questions when truly blocked, at most 1–2 questions
- Make reasonable assumptions for non-critical unknowns
- Quickly move to execution and avoid excessive discussion

Atomic Task Generation

- Each step is a single logical unit and can be completed independently
- Start with a verb (Add, Refactor, Verify); instructions are clear
- Explicitly specify the files or modules involved
- Include verification/testing steps to ensure quality

Frequently Asked Questions

When should the concise-planning skill be used?

Use it when the user explicitly requests a plan for a coding task, for example when the user says "Help me plan how to implement this feature," "Give me a refactoring plan," or "Create development steps." If the user is only asking for information or wants to start coding immediately, this skill is not necessary.

Why only ask 1–2 questions? What if information is insufficient?

The design philosophy of Concise Planning is to act quickly rather than create a perfect plan. For non-blocking unknowns, the skill will make reasonable assumptions based on development best practices. If assumptions are later found to be incorrect, they can be adjusted during execution. This approach is more efficient than excessive discussion.

Can the generated plan be modified?

Of course. The generated plan is a starting point, not a constraint. Developers can adjust the order of steps, add or remove tasks, or modify implementation details according to the actual situation. The atomic task structure ensures that changing one step won't affect the overall clarity of the plan.