symphony-plan

Draft implementation plans for Symphony issues aligned with the spec and architectural layers.

11|Updated Mar 5, 2026
One-click install
npx skills add https://github.com/sociotechnica-org/symphony-ts --skill symphony-plan
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: symphony-plan
Source: https://github.com/sociotechnica-org/symphony-ts/tree/main/skills/symphony-plan
Command: npx skills add https://github.com/sociotechnica-org/symphony-ts --skill symphony-plan

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Refine and formalize implementation plans for Symphony issues to stay aligned with the Symphony spec, preserve architectural layers, and reduce review churn.

Core Features & Use Cases

  • Aligns planning with SPEC and harness principles to ensure consistent architecture boundaries.
  • Defines goal, scope, non-goals, and runtime-state considerations to enable a single, reviewable PR slice.
  • Provides guidance for sources of truth, plan outputs, tests, and acceptance criteria to minimize back-and-forth.

Quick Start

Provide an issue summary and relevant files to generate a concise, one-slice plan.

Frequently Asked Questions about symphony-plan

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

FAQPage Schema
How do I create an implementation plan for a Symphony issue that stays aligned with the spec?

Draft an implementation plan by mapping work to abstraction layers like Policy, Configuration, and Execution, ensuring spec alignment. Define runtime state transitions, failure modes, and clear PR seams to produce a single, reviewable slice.

What is slice decomposition in software architecture planning?

Slice decomposition breaks substantial implementation work into a single, reviewable PR slice with explicit state and failure modes. It preserves architectural layers and maps goals to abstraction boundaries to minimize review churn.

How do I reduce review churn when planning substantial code changes?

Reduce review churn by defining explicit goal, scope, non-goals, and runtime-state considerations in the plan. Aligning with SPEC and harness principles ensures consistent architecture boundaries and minimizes back-and-forth during code review.

How do I map implementation tasks to abstraction layers like Policy, Configuration, and Execution?

Map tasks to abstraction layers by analyzing sources like AGENTS.md, SPEC.md, and docs to assign work across Policy, Configuration, Coordination, Execution, Integration, and Observability. This preserves architectural boundaries and clarifies runtime state transitions.

What sources do I need to generate a spec-aligned implementation plan?

Generate a spec-aligned plan using sources of truth like AGENTS.md, README.md, docs, SPEC.md, and Harness principles. Provide an issue summary and relevant files to produce a concise, one-slice plan with tests and acceptance criteria.

When should I formalize an implementation plan before starting substantial Symphony work?

Formalize an implementation plan for substantial implementation work and tests to ensure a single, reviewable PR slice. Defining exit criteria, acceptance criteria, and runtime state transitions early prevents architectural misalignment and scope creep.