plan

Generate structured implementation plans with requirement traceability and QA gate configuration.

437|45|Updated Jan 27, 2026
One-click install
npx skills add https://github.com/ZaxbyHub/opencode-swarm --skill plan-zaxbyhub
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: plan
Source: https://github.com/ZaxbyHub/opencode-swarm/tree/main/.opencode/skills/plan
Command: npx skills add https://github.com/ZaxbyHub/opencode-swarm --skill plan-zaxbyhub

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill eliminates the risk of incomplete, non-compliant implementation plans that skip critical checks like spec alignment, requirement traceability, and QA gate configuration, which lead to rework, missed requirements, and failed implementations in AI coding workflows.

Core Features & Use Cases

  • Spec Alignment & Stale Spec Detection: Automatically checks for existing specs, detects stale spec content, and offers options to archive, update, or skip specs to ensure plans match current requirements.
  • Structured Clarification Funnel: Uses a 4-stage process with critic sounding board consultation to resolve planning uncertainties (scope, security, compatibility, etc.) before escalating to the user, reducing unnecessary interruptions.
  • Obligation Traceability Checks: Maps all spec requirements (FR-###) and MUST/SHALL obligations (SC-###) to plan tasks to flag coverage gaps and gold-plating risks before implementation starts.
  • Automated QA Gate & Execution Profile Configuration: Guides users through selecting quality gates (reviewer, test engineer, security scans, etc.) and parallel execution settings, persisting these configurations before any tasks are dispatched.
  • Use Case: For example, when planning a new user authentication feature, this skill ensures all spec requirements are mapped to tasks, security and backward compatibility questions are surfaced to the user, and QA gates like code review and test verification are configured before any code is written.

Quick Start

Use the plan skill to generate a compliant, gated implementation plan for your current project, aligned with your spec and pre-configured with all required quality controls.

Frequently Asked Questions about plan

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

FAQPage Schema
How do I create a compliant implementation plan for AI coding workflows?

To create a compliant implementation plan, you must map all spec requirements to tasks, resolve uncertainties through a clarification funnel, and configure QA gates before code generation. This eliminates coverage gaps and ensures traceability throughout the workflow.

What is requirement traceability and how does it prevent missed specifications?

Requirement traceability maps all functional requirements and MUST/SHALL obligations directly to planned tasks. This mechanism flags coverage gaps and gold-plating risks before implementation starts, ensuring no specification is missed during coding.

How do I configure QA gates for automated code generation projects?

Configuring QA gates involves selecting quality controls like reviewer checks, test engineer verification, and security scans before dispatching tasks. This process persists execution profiles to enforce quality standards during parallel task execution.

Can I use an external implementation plan and still align it with my current spec?

Yes, external plan ingestion supports spec alignment by automatically checking existing specs and detecting stale content. It offers options to archive, update, or skip specs so your ingested plan matches current software requirements.

What is the best way to resolve planning uncertainties before escalating to the user?

The best way to resolve planning uncertainties is using a structured 4-stage clarification funnel with a critic sounding board. This mechanism evaluates scope, security, and compatibility internally to reduce unnecessary user interruptions.

When do I need to detect stale specs during software planning?

You need stale spec detection when generating new implementation plans or ingesting external ones. It ensures your current plan does not rely on outdated requirements by offering options to archive or update the spec content.