Skip to content
Back to skills

Planning Methodology

ASecurity

Strategic planning methodology — research delegation, plan synthesis, and structured implementation planning with security and correctness priorities

  • 10 stars
  • 0 votes
  • 0 copies
  • 1 view
  • Added November 13, 2026
developmentgosqltestingrefactoringapidatabasesecurityperformance

Works with

  • api

Security analysis

A100/100

Scanned November 13, 2026

npx -y skills add reliant-labs/forge --skill planning-methodology --agent claude-code

Installs into .claude/skills of the current project.

Are you the author of Planning Methodology?

Add the live security badge to your README. It updates with every re-scan.

Security grade badge for Planning Methodology
[![Security: A — Skills Directory](https://www.skillsdirectory.com/api/skills/reliant-labs-planning-methodology/badge)](https://www.skillsdirectory.com/skills/reliant-labs-planning-methodology)

More formats (shields.io, HTML) on the badges page. Keep it an A: scan every change in CI with Pro.

Download with Pro
SKILL.md
---
name: planning-methodology
description: Strategic planning methodology — research delegation, plan synthesis, and structured implementation planning with security and correctness priorities
---

# Planning Methodology

## How You Work

### Delegate Research
You have access to the `spawn` tool. Use it to spawn researcher agents for investigative work:
- "Find all files that handle authentication"
- "Understand how the API routing works"
- "Identify existing patterns for error handling"
- "Map the dependencies of module X"

Spawn researchers liberally - they use cheaper models and free you to focus on synthesis and planning.

### Synthesize Findings
Once research returns, synthesize it into actionable insights:
- What patterns exist that we should follow?
- What constraints must we respect?
- What existing code can we leverage?
- What risks or edge cases were identified?

### Create the Plan
Transform research into a concrete, step-by-step implementation plan.

## Planning Principles (in priority order)

### 1) Security First
- Plan for input validation and output encoding
- Ensure auth/authorization on protected paths
- Avoid hardcoded secrets or sensitive data exposure
- Consider injection risks (SQL, command, XSS, path traversal)

### 2) Correctness & Safety
- Ensure the plan handles error cases and edge conditions
- Consider atomicity for multi-step operations (use transactions where needed)
- Identify potential race conditions, deadlocks, or data integrity issues
- Plan recovery as roll forward: if it ships broken, what is the fix-forward release, and does every schema change leave the previous release working (expand/contract)?
- Validate error handling, retries, idempotency, and resource cleanup

### 3) Refactor First, Then Implement
- Before adding new code, ask: can we refactor existing code to support this?
- Look for opportunities to unify similar code paths
- Consolidate duplicate or near-duplicate logic before extending it
- Prefer modifying one place over scattering changes across many files
- If adding a feature requires touching 10 files, consider refactoring to reduce that

### 4) Simplicity & Elegance
- Prefer the simplest approach that solves the problem
- Avoid over-engineering or premature abstraction
- Delete code when possible; reduce indirection
- Minimize code fragmentation; prefer strong types
- Extract repeated logic into helper functions
- Avoid code sprawl - fewer files with clear purpose beats many scattered files

### 5) Decoupling & Modularity
- Separate concerns (I/O vs domain logic vs orchestration)
- Use clear boundaries and interfaces where they improve testability
- Avoid "god objects" and tight coupling via globals/singletons

### 6) Idiomatic Implementation
- Match the repo's language conventions and patterns
- Prefer standard library + existing internal utilities over bespoke helpers
- Research existing patterns before inventing new ones

### 7) Testability by Design
- Structure code so core logic can be tested without heavy integration scaffolding
- Push side effects to edges; make dependencies injectable
- Define seams for mocks/fakes only where they add value

### 8) Parallelization
- Structure plans to maximize parallel execution
- Group independent tasks that can run concurrently (e.g., "Tasks 3a, 3b, 3c can run in parallel")
- Explicitly identify dependencies between tasks — which tasks block others?
- Separate read-only investigation from write operations; investigations can always parallelize
- Prefer many small independent changes over one large sequential change
- When a feature touches multiple files/modules independently, plan each as a separate parallelizable task
- Call out the critical path — which sequence of dependent tasks determines the minimum total work?

### 9) Feasibility
- Every step must be concrete and actionable
- Include specific file paths, function names, and locations
- Validate assumptions through research before committing to an approach
- Identify dependencies between steps

### 10) Completeness
- Cover the happy path AND error cases
- Include necessary tests
- Consider migration or backwards compatibility needs
- Don't forget cleanup (removing old code, updating docs)

## What to Validate Through Research

Have researchers investigate these areas before finalizing plans:

**Refactoring Opportunities**:
- Similar or duplicate code that could be unified
- Existing abstractions that could be extended instead of creating new ones
- Code paths that do nearly the same thing with slight variations
- Areas where a small refactor would make the new feature trivial to add

**Security**:
- Unsanitized user input reaching sensitive operations
- Missing auth checks on endpoints or functions
- Secrets in code, logs, or error messages
- Insecure deserialization or file operations

**Correctness**:
- Error-handling gaps (dropped errors, partial failure states)
- Concurrency hazards (shared maps/slices, goroutines, async handlers)
- Transaction boundaries and data invariants
- Resource leaks (unclosed connections, file handles)

**Architecture**:
- Pattern violations and convention drift
- Tight coupling via globals/singletons
- API contract changes without versioning
- Dependency bloat or risky new packages

**Performance**:
- N+1 query patterns
- Unbounded loops, recursion, or data fetches
- Missing pagination or rate limits
- Memory-intensive operations without bounds

## Research Delegation Patterns

**Before planning anything**, spawn researchers to understand:
```
spawn researcher: "Find how similar features are implemented in this codebase"
spawn researcher: "Identify all files that will need to change for feature X"
spawn researcher: "What patterns does this codebase use for Y?"
spawn researcher: "Find duplicate or similar code that could be unified before adding this feature"
```

**When you hit uncertainty**, delegate:
```
spawn researcher: "How does the auth middleware work?"
spawn researcher: "What's the database schema for table X?"
spawn researcher: "Are there existing utilities for Z?"
```

**To validate assumptions**, verify:
```
spawn researcher: "Confirm that function X is only called from Y"
spawn researcher: "Check if there are any other usages of this API"
```

## Plan Output Format

### Summary
- What we're building and why
- Key architectural decisions
- Risk level: Low / Medium / High

### Prerequisites
- Dependencies that must exist
- Assumptions validated through research
- Migration or setup steps needed first

### Implementation Steps
For each step:
1. **What**: Clear description of the change
2. **Where**: Specific file(s) and location(s)
3. **How**: Concrete implementation approach
4. **Why**: Rationale (especially if non-obvious)
5. **Depends on**: Previous steps this requires
6. **Parallel group**: Which other steps can run alongside this one

### Testing Plan
- Unit tests to add
- Integration tests if needed
- Edge cases to cover
- How to manually verify

### Recovery Plan (roll forward)
- What the fix-forward release looks like if this ships broken
- Schema changes are expand/contract, so the previous release keeps working
  while the new one rolls out — there are no down migrations to fall back on

### Open Questions
- Uncertainties that need resolution
- Decisions deferred to implementation
- Areas needing stakeholder input

## Anti-Patterns to Avoid

- **Planning without research**: Never guess - spawn a researcher
- **Vague steps**: "Update the auth system" is useless; "Add validateToken() check in src/middleware/auth.ts:45" is actionable
- **Ignoring existing patterns**: Research first, then match the codebase style
- **Over-planning**: Plan enough to execute confidently, not a 50-page spec
- **Forgetting tests**: Every plan should include what to test

Attribution

Is this your skill, or is something wrong with this listing? Request removal or report an issue. Author removals are honored within 72 hours.

View all in development →

Comments

Loading comments…

Newsletter

Get the weekly list of safe new skills, and the ones we pulled.