home / skills / robzolkos / zolkos-agent-skills / plan2json

plan2json skill

safe

/skills/plan2json

This skill converts a project specification into a JSON feature list with detailed end-to-end test cases.

npx playbooks add skill robzolkos/zolkos-agent-skills --skill plan2json

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

Files (1)

SKILL.md

1.7 KB

---
name: plan2json
description: Convert feature requirements into structured end-to-end test cases as JSON.
argument-hint: <spec-file>
disable-model-invocation: true
allowed-tools: Read, Write
---

# Plan to JSON

You are creating the foundation for an autonomous development process. Your job is to convert a project specification into a comprehensive feature list that serves as the single source of truth for what needs to be built.

## Input

Read the file at `$1` to get the complete project specification. Read it carefully before proceeding.

## Output: feature_list.json

Based on the spec file, create `feature_list.json` with detailed end-to-end test cases.

### Format

```json
[
  {
    "category": "functional",
    "description": "Brief description of the feature and what this test verifies",
    "steps": [
      "Step 1: Navigate to relevant page",
      "Step 2: Perform action",
      "Step 3: Verify expected result"
    ],
    "passes": false
  },
  {
    "category": "style",
    "description": "Brief description of UI/UX requirement",
    "steps": [
      "Step 1: Navigate to page",
      "Step 2: Take screenshot",
      "Step 3: Verify visual requirements"
    ],
    "passes": false
  }
]
```

### Requirements

- **Minimum 200 features total** with testing steps for each
- Both `"functional"` and `"style"` categories
- Mix of narrow tests (2-5 steps) and comprehensive tests (10+ steps)
- **At least 25 tests MUST have 10+ steps each**
- Order features by priority: fundamental features first
- **ALL tests start with `"passes": false`**
- Cover every feature in the spec exhaustively

Write the JSON array to `feature_list.json` in the current working directory.

Overview

This skill converts feature requirements and project specifications into a comprehensive list of end-to-end test cases encoded as JSON. It produces a prioritized, structured feature_list.json that serves as a single source of truth for testable scope and verification. The output is designed for automated agents, QA teams, and CI pipelines to consume directly.

How this skill works

The skill reads a project specification and extracts all functional and style requirements, then generates individual test case objects. Each test includes a category, concise description, ordered steps, and an initial passes flag set to false. The skill enforces priorities, coverage rules, and format constraints so the result is ready for downstream automation.

When to use it

When you need a machine-readable, testable decomposition of a product spec
When preparing handoff artifacts for QA or test automation teams
When integrating feature planning into autonomous agent development pipelines
When you need a single source of truth for acceptance criteria and verification
When converting high-level requirements into executable end-to-end scenarios

Best practices

Provide a complete, clear specification file so extraction is accurate
Prioritize core functionality first to order features by importance
Include both narrow and comprehensive scenarios to balance speed and depth
Ensure visual and accessibility requirements are explicitly stated for style tests
Review generated steps for environment-specific setup before automation

Example use cases

Generate a prioritized JSON test plan from a product requirements document for sprint planning
Create an exhaustive set of end-to-end checks for an autonomous agent to execute during CI
Produce UI style verification cases for visual regression and accessibility audits
Translate stakeholder acceptance criteria into reproducible QA test steps
Seed test automation frameworks with structured test definitions for execution

FAQ

What output format does the skill produce?

It generates a JSON array saved as feature_list.json containing objects with category, description, steps, and passes fields.

How are priorities handled?

Features are ordered by priority with fundamental and blocker features listed first to guide implementation and testing.

Does the skill enforce any coverage rules?

Yes. It enforces mixed granularity, includes both functional and style categories, and sets initial passes to false for all tests.