skills.rest
vuminhieu
vuminhieuCOMMUNITY
Explore all skills by this author →
GitHub

planning

Create structured technical plans with architectural designs and implementation roadmaps.

Updated Feb 2, 2026
Search Tags:#planning#architecture#documentation#requirements#roadmap#trade-offs
One-click install
npx skills add https://github.com/vuminhieu/spexor-client --skill planning-vuminhieu
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: planning
Source: https://github.com/vuminhieu/spexor-client/tree/main/.agent/skills/skills/planning
Command: npx skills add https://github.com/vuminhieu/spexor-client --skill planning-vuminhieu

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Planning is essential for turning vague requirements into concrete, maintainable roadmaps. This skill helps teams define architectural approaches, timelines, and milestones before implementation begins.

Core Features & Use Cases

  • Structured planning: Build repeatable, evidence-based plans that guide design and delivery.
  • Architectural & roadmap design: Create scalable designs and implementation roadmaps aligned with business goals.
  • Documentation & governance: Produce comprehensive plan artifacts that enable future maintenance and audits.

Quick Start

Start a new plan by outlining goals, constraints, and success criteria, then break down the work into phases with explicit deliverables.

Frequently Asked Questions about planning

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

FAQPage Schema
How do I create an architectural roadmap from vague software requirements?▼

Architectural roadmap design translates vague requirements into concrete phases with explicit deliverables. You outline goals, constraints, and success criteria to build a structured, evidence-based plan that guides scalable design and delivery.

What is the best way to document scalable and secure technical solutions?▼

The best way to document technical solutions is by producing comprehensive, self-contained plan artifacts. These enforce YAGNI, KISS, and DRY principles while enabling future maintenance, governance, and audits across complex codebases.

When do I need to enforce YAGNI and KISS principles during software architecture planning?▼

You should enforce YAGNI and KISS principles during software architecture planning when designing risk-aware implementation plans for complex codebases. This ensures your technical solutions remain scalable, secure, and maintainable without over-engineering.

Can I use this approach to plan features for a complex codebase?▼

Yes, you can use this planning approach for a complex codebase. It applies directly to architectural design, feature roadmaps, and risk-aware implementation plans, producing self-contained, actionable artifacts that guide design and delivery.

How to evaluate trade-offs when designing a technical implementation roadmap?▼

To evaluate trade-offs when designing an implementation roadmap, define your architectural approaches and constraints upfront. Structured planning helps translate vague requirements into maintainable, evidence-based milestones aligned with business goals.

Related Skills

Explore More Software Engineering Skills→
soeiroosoeiroo

design-brief

Create structured design briefs with problem statements, audience, constraints, and success criteria.

Community
Intermediate
samhvw8samhvw8
14

planning-methodology

Produce detailed technical implementation plans with phased documents and actionable outputs.

Community
Basic
huuhiep0303huuhiep0303

documentation-and-adrs

Document architectural decisions and design records for codebases.

Community
Advanced
v1bh0rv1bh0r

nw-roadmap

Scaffold feature roadmaps as JSON artifacts with milestones and acceptance criteria.

Community
Advanced