home / skills / dmdorta1111 / jac-v1 / planning

planning skill

safe

This skill creates thorough, scalable, and secure technical plans from research, design, and documentation to guide maintainable implementations.

npx playbooks add skill dmdorta1111/jac-v1 --skill planning

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

Files (6)

SKILL.md

2.6 KB

---
name: planning
description: Use when you need to plan technical solutions that are scalable, secure, and maintainable.
license: MIT
---

# Planning

Create detailed technical implementation plans through research, codebase analysis, solution design, and comprehensive documentation.

## When to Use

Use this skill when:
- Planning new feature implementations
- Architecting system designs
- Evaluating technical approaches
- Creating implementation roadmaps
- Breaking down complex requirements
- Assessing technical trade-offs

## Core Responsibilities & Rules

Always honoring **YAGNI**, **KISS**, and **DRY** principles.
**Be honest, be brutal, straight to the point, and be concise.**

### 1. Research & Analysis
Load: `references/research-phase.md`
**Skip if:** Provided with researcher reports

### 2. Codebase Understanding
Load: `references/codebase-understanding.md`
**Skip if:** Provided with scout reports

### 3. Solution Design
Load: `references/solution-design.md`

### 4. Plan Creation & Organization
Load: `references/plan-organization.md`

### 5. Task Breakdown & Output Standards
Load: `references/output-standards.md`

## Workflow Process

1. **Initial Analysis** → Read codebase docs, understand context
2. **Research Phase** → Spawn researchers, investigate approaches
3. **Synthesis** → Analyze reports, identify optimal solution
4. **Design Phase** → Create architecture, implementation design
5. **Plan Documentation** → Write comprehensive plan
6. **Review & Refine** → Ensure completeness, clarity, actionability

## Output Requirements

- DO NOT implement code - only create plans
- Respond with plan file path and summary
- Ensure self-contained plans with necessary context
- Include code snippets/pseudocode when clarifying
- Provide multiple options with trade-offs when appropriate
- Fully respect the `./docs/development-rules.md` file.

**Plan Directory Structure**
```
plans/
└── YYYYMMDD-HHmm-plan-name/
    ├── research/
    │   ├── researcher-XX-report.md
    │   └── ...
    ├── reports/
    │   ├── XX-report.md
    │   └── ...
    ├── scout/
    │   ├── scout-XX-report.md
    │   └── ...
    ├── plan.md
    ├── phase-XX-phase-name-here.md
    └── ...
```

## Quality Standards

- Be thorough and specific
- Consider long-term maintainability
- Research thoroughly when uncertain
- Address security and performance concerns
- Make plans detailed enough for junior developers
- Validate against existing codebase patterns

**Remember:** Plan quality determines implementation success. Be comprehensive and consider all solution aspects.

Overview

This skill produces detailed technical implementation plans that prioritize scalability, security, and maintainability. It combines research, codebase analysis, solution design, and clear task breakdowns to produce actionable, self-contained plans. Plans follow YAGNI, KISS, and DRY and are written to be directly usable by engineers of varying experience.

How this skill works

The skill inspects project documentation and the codebase to establish context, spawns targeted research or scouting tasks when needed, synthesizes findings, and designs one or more implementation options with trade-offs. It then composes a structured plan directory with step-by-step phases, tasks, pseudocode, and verification criteria, and returns the plan file path plus a concise summary.

When to use it

Designing a new feature with non-trivial architecture implications
Re-architecting components for scalability or security
Evaluating multiple technical approaches and trade-offs
Creating a milestone-based implementation roadmap
Breaking down complex requirements for engineering teams

Best practices

Always start with codebase docs and existing patterns to avoid unnecessary work
Produce multiple solution options and state trade-offs clearly
Keep plans self-contained: include necessary context, pseudocode, and verification steps
Prioritize maintainability and long-term operational costs, not just short-term delivery
Follow YAGNI, KISS, and DRY—avoid over-engineering
Specify security and performance considerations for each option

Example use cases

Plan and document a scalable event-processing pipeline with alternatives (serverless vs. containerized)
Produce a migration plan for moving a monolith feature into microservices with rollback steps
Create an incremental implementation roadmap for a cross-team API integration
Assess options for adding real-time features and recommend the safest, maintainable path
Break down a complex compliance-related change into developer-ready phases and tasks

FAQ

Will this skill write production code?

No. It creates detailed implementation plans, pseudocode, and verification steps but does not implement code.

What output will I get?

A structured plan directory path (e.g., plans/YYYYMMDD-HHmm-plan-name/) plus a concise summary and the plan.md with phases, tasks, trade-offs, and examples.