# Turn Approved Specifications into Implementation Plans

Incomplete implementation plans leave developers guessing about interfaces, dependencies, and acceptance criteria. This skill structures approved specifications into traceable tasks with explicit tests and execution gates.

## Install

```bash
npx skillstore add atri10/executor-planning
```

## Metadata

- Status: approved
- Slug: atri10-executor-planning
- Skillstore revision: r1
- Version status: missing
- Tree hash: 495b7c8a460c49d25f609b12c8a79c67b3c4cfbe26e0b7be56c8072919ae312b
- Author: atri10
- GitHub username: atri10
- License: MIT
- Repository: https://github.com/atri10/executor/tree/39ddcfe1d9f3497102622b72aa235fb0770187fe/skills/executor-planning
- Ref: 6d0b11444384184b7ae743742a7e233a9a705cd9
- Supported tools: Claude, Codex, Claude Code
- Audit status: complete
- Agent install advisory: allowed
- Manual install advisory: allowed
- Artifact signature: available
- Audit attestation: unavailable
- Human verification: not\_verified
- Risk factors: external\_commands, filesystem
- Quality score: 68
- Public page: https://skillstore.pages.dev/skills/atri10-executor-planning
- Manifest: https://skillstore.pages.dev/api/skills/atri10-executor-planning/manifest

## Capabilities

- Structure plans with frontmatter, constraints, interfaces, file maps, dependency maps, and numbered task identifiers.
- Split specifications into independently testable plans with explicit ordering and predecessor assumptions.
- Map requirement identifiers to tasks and repeat relevant constraints inside each task brief.
- Specify test-driven task steps with exact commands, expected failures, passing results, and refactoring checks.
- Guide verification using companion tools for task extraction, plan linting, store checks, and secret scanning.
- Prepare regression review, document cross-links, and a human choice between subagent and inline execution.

## Use Cases

- Prepare a Reviewable Delivery Plan: Convert an approved feature specification into traceable tasks with explicit file ownership, interfaces, and acceptance tests.
- Create Self-Contained Agent Briefs: Prepare tasks that isolated coding agents can implement without access to the surrounding conversation or complete plan.
- Repair a Multi-Plan Handoff: Find missing requirement coverage, interface mismatches, dependency cycles, and incomplete test steps before implementation begins.

## Prompt Templates

### Create a First Plan

```
Create a draft implementation plan from [approved specification] and [interface document]. Check prerequisites and identify missing inputs before drafting tasks.
```

### Define Testable Tasks

```
Refine [draft plan] into self-contained tasks. Include requirement IDs, exact interfaces, file lists, failing tests, expected results, and refactoring steps.
```

### Split an Approved Specification

```
Use [decided decomposition session] to split [approved specification] into independently testable plans. Document coverage, predecessor assumptions, execution order, and dependency maps.
```

### Audit and Repair the Plan Set

```
Audit [plan set] against [specification] and [interface contracts]. Repair coverage gaps, dependency cycles, and extraction defects. Report unavailable validation tools without claiming success.
```

## Limitations

- Requires an approved specification, a decided decomposition session, and interface documents for work spanning components.
- Companion Executor skills, reference documents, and scripts are not included in this single-file package.
- Provides planning instructions rather than a standalone implementation engine or guaranteed validation results.
- Includes shared temporary-file and broad Git-staging examples that require safer handling before use.

## Best Practices

- Confirm specification approval, interface contracts, and the human-selected decomposition before drafting tasks.
- Make each task independently understandable with exact requirements, interfaces, tests, and dependency references.
- Verify companion tools, use private temporary files, and inspect explicitly staged changes before the execution handoff.

## Anti Patterns

- Inventing interfaces or architectural decisions inside an implementation plan.
- Using placeholders, implicit constraints, or references to another task instead of a complete acceptance contract.
- Starting implementation before regression clears and the human selects an execution mode.

## Security Audit

- Audited at: 2026-10-05T18:00:28.775\+00:00
- Summary: Most of the 221 static findings are Markdown formatting, legitimate companion references, or routine planning commands. Two temporary-file findings remain confirmed, and a semantic finding identifies overly broad Git staging. No evidence found of prompt injection or exfiltration; companion script implementations are outside the reviewed package.

## Stats

- Views: 1
- Downloads: 0
- Favorites: 0
- Popularity score: 0