Skip to content
Skills Library
Programming · Planning

software-planner

/software-planner

Convert software feature requests, integrations, and change proposals into scoped implementation approaches, small development tasks, and measurable acceptance criteria. Use when a user asks for a technical plan, backlog, or implementation breakdown. Planning does not authorize coding, deploying, or creating CRM records.

Licence
MIT
Last repository change
11.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
2
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 11.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Convert software feature requests, integrations, and change proposals into scoped implementation approaches, small development tasks, and measurable acceptance criteria. Use when a user asks for a technical plan, backlog, or implementation breakdown. Planning does not authorize coding, deploying, or creating CRM records.

Original author description

Convert software feature requests, integrations, and change proposals into scoped implementation approaches, small development tasks, and measurable acceptance criteria. Use when a user asks for a technical plan, backlog, or implementation breakdown. Planning does not authorize coding, deploying, or creating CRM records.

How it works

  1. Purpose and use
  2. Process
  3. Output
  4. Relationship to other skills
  5. Examples
Original SKILL.md headings · 46 lines, 731 words
SKILL.md preview
---
name: software-planner
description: >-
  Convert software feature requests, integrations, and change proposals into
  scoped implementation approaches, small development tasks, and measurable
  acceptance criteria. Use when a user asks for a technical plan, backlog,
  or implementation breakdown. Planning does not authorize coding, deploying,
  or creating CRM records.
---

# Software Planner

## Purpose and use

Turn a software request into a **small, clear, verifiable** plan that an engineering team can execute. Use for new features, improving existing functionality, integrations, version transitions, or technical task breakdowns. Do not invent facts about technology, timelines, costs, existing product capabilities, or workflows without evidence.

This skill creates plans only. It does not change code, create real tasks, open PRs, or deploy unless those actions are separately requested and authorized.

## Process

1. **Understand the request and expected outcome.** Use the provided request, support ticket, product context, or available files to identify the intended user, their problem, and desired behavior. Do not ask for information already given. If the outcome is unclear, state the smallest workable assumption and ask only one question if the decision truly requires it.
2. **Separate facts from proposals.** If repository, schema, screen, or API access is available, inspect only the relevant areas in read-only mode and cite file paths and function names as evidence. Without access, do not fabricate the architecture, database tables, features, providers, or endpoints. Make any required technical discovery a separate first task.
3. **Constrain scope.** Describe the core user journey in one or two sentences. Identify what is **included**, **excluded**, and any **dependencies**. Do not add administration screens, broad redesign, or new technology merely because it is possible. Prefer the least disruptive solution compatible with the existing architecture.
4. **Describe the user flow.** Cover its trigger, expected action, success state, and important error or empty states. Where relevant, consider roles, permissions, concurrent users, and accessibility, without assuming these capabilities already exist.
5. **Choose a technical approach.** Prefer the smallest approach compatible with the known stack. If a real uncertainty changes the design decision, compare no more than two options with short tradeoffs. Mention data changes, migration, backward compatibility, security, privacy, error handling, or rollback only where relevant. Never assume that live data can be wiped.
6. **Break work into practical tasks.** Prefer three to six work packages rather than unnecessary subtasks. Each task should specify an action, component or area (if known), dependencies, and a verifiable **definition of done**. Resolve critical unknowns first, then sequence implementation, focused checks, and release preparation. Do not invent specific owners, dates, estimates, or costs.
7. **Write measurable acceptance criteria.** Use a **given / when / then** structure that describes observable normal behavior and an important failure scenario. Avoid untestable criteria such as "works well" or "is fast."
8. **Separate validation from deployment.** Suggest the smallest relevant unit, integration, or manual scenarios. Explicitly state that tests were **not run** unless executed. Do not guarantee unmeasured performance or security. Where applicable, identify production rollout, data migration, maintenance window, and rollback risks.
9. **Respect permissions and sensitive data.** Planning does not permit modifications to code, CRM, customer accounts, or live systems. Without authorization, do not commit, push, create tickets, deploy, write or delete data, expand access, or call real integrations. Do not include credentials or private customer data in reports or Git history.

## Output

Provide an **actionable, concise** plan at the user's requested level of detail. Combine headings for straightforward requests.

1. **Goal and evidence level:** What should change, for whom, what is verified versus assumed?
2. **Scope:** Included work, exclusions, and dependencies.
3. **Proposed approach:** Fit with the existing system, important technical decisions and relevant security/data risks.
4. **Development tasks:** Ordered, small executable work packages, each with a **definition of done**.
5. **Acceptance criteria:** At least one normal scenario and, when relevant, an error/permission/empty-state scenario.
6. **Open decisions and verification:** Only consequential unknowns, minimal tests, and rollout or rollback risks if relevant.

When code or scope is inaccessible, create a **short technical discovery task** instead of inventing a technology stack or file structure. If the user only wants a CRM task draft, produce one concise task—not an unnecessary full project plan.

## Relationship to other skills

- `support-assistant`: Classifies customer messages and drafts support/CRM communications; a verified product need can become input for `software-planner`.
- `technical-troubleshooter`: Investigates a failure in a running system; this skill plans a change.
- `code-reviewer`: Reviews actual PR/diff risks after implementation; a plan does not imply that code has been reviewed.

## Examples

`$software-planner Plan the smallest reusable-media selection feature with scope and acceptance criteria.`

`$software-planner Convert this feature request into four or five actionable engineering tasks; clearly state assumptions if code access is unavailable.`
Files in this package (2)
  • SKILL.md 5 KB
  • SKILL.tr.md 6 KB

Versions

RepositoryScoreLicence
This page · basamakcomtr/basamak-skills100MIT
cycleuser/Skills100GPL-3.0

Database snapshot: 13.11.2026 · package version dcae5cbd6bdd (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100spec-planning
    Spec-first planning: task breakdown, measurable acceptance criteria, dependency order, risk priority. crew-planner applies it; the plan goes to docs/PLAN.md. Use when the scope is unclear or the work spans more than one change.
  • 100task-planning
    Plan and organize software development tasks effectively. Use when breaking down features, creating user stories, or planning sprints. Handles task breakdown, user stories, acceptance criteria, and backlog management.
  • 100intent-driven-development
    Turn ambiguous or high-impact product and engineering changes into scoped, verifiable acceptance criteria before or alongside implementation. Use when a user asks to clarify a feature, define acceptance criteria, de-risk a security/data/migration/integration change, prepare…
  • 90test-per-ac-planner
    Maps acceptance criteria to specific verification actions. Use when acceptance criteria exist and coding or handoff has not started, above all when work spans several layers.
  • 100planning-and-task-breakdown
    Decompose specs into small, ordered tasks with acceptance criteria and verification steps. Use when you have requirements and need an implementable plan or task list. Triggers: "break down tasks", "implementation plan", "task breakdown", "plan mode".
  • 100planning-and-task-breakdown
    Decomposes a specification into small, ordered, verifiable tasks. Use when a spec exists and you need implementable units, dependency ordering, or a task list with acceptance criteria and clear ownership.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.