ss-sdd-implementing-plans

Execute committed SDD plan tasks sequentially with fresh subagents and final code-quality review.

Updated May 19, 2026
One-click install
npx skills add https://github.com/Emrebener/Sublime-Skills --skill ss-sdd-implementing-plans
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ss-sdd-implementing-plans
Source: https://github.com/Emrebener/Sublime-Skills/tree/main/skills/spec-driven-development/ss-sdd-implementing-plans
Command: npx skills add https://github.com/Emrebener/Sublime-Skills --skill ss-sdd-implementing-plans

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It coordinates the implementation stage of a spec-driven development (SDD) pipeline by turning a committed plan into sequential, isolated task execution plus a mandatory cross-cutting quality review.

Core Features & Use Cases

  • Task-by-task implementation loop: dispatches a fresh implementer subagent per plan task to avoid context pollution and preserve TDD discipline.
  • Stateful progress orchestration: initializes or syncs .sublime-skills/state.json task statuses idempotently, updates per-task completion, and creates a new per-task todo list.
  • Mandatory final branch-wide review: runs a single cross-cutting reviewer at the end of all tasks, then loops (up to a cap) to address issues before marking completion.
  • Safety guardrails (hard gates): prevents implementation on main/master, forbids committing state.json, and enforces sequential execution.

Quick Start

Use the ss-sdd-implementing-plans skill to execute the already-committed SDD plan task-by-task on the feature branch and produce a final approved branch-wide code-quality review.

Frequently Asked Questions about ss-sdd-implementing-plans

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

FAQPage Schema
How do I implement a spec-driven development plan task-by-task?

Sequential SDD implementation is orchestrated by dispatching a fresh implementer subagent per plan task, which prevents context pollution and maintains TDD discipline throughout the feature branch.

How does task dispatch work in an implementation orchestration workflow?

Task dispatch executes plan tasks sequentially using inline task text, maintaining idempotent stage state via a tasks map, and applying atomic state and todo updates to track per-task completion accurately.

Can I run implementation directly on the main or master git branch?

Running implementation on main or master branches is blocked by hard safety gates, which mandate branch selection safety, forbid committing state.json, and require a dedicated feature branch.

What is a cross-cutting code-quality review in a TDD workflow?

A cross-cutting code-quality review is a mandatory final stage analyzing the full branch diff, looping up to a capped limit to address issues and ensure overall code quality before marking completion.

Do I need a committed plan before starting state management for implementation?

A committed plan is required before starting state management for implementation, as the Skill initializes or syncs state.json task statuses idempotently and dispatches implementation tasks only after the plan is committed.

Why does sequential execution matter for implementation orchestration?

Sequential execution matters for implementation orchestration because it ensures isolated task processing with fresh subagents, enforces hard safety gates, and performs atomic state updates to maintain progress integrity.