home / skills / makfly / superpowers-symfony / executing-plans

executing-plans skill

safe

This skill helps you plan and execute Symfony architecture changes with controlled scope, checkpoints, and auditable decision logs.

npx playbooks add skill makfly/superpowers-symfony --skill executing-plans

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

Files (2)

SKILL.md

1.1 KB

---

name: symfony:executing-plans
allowed-tools:
  - Read
  - Write
  - Edit
  - Bash
  - Glob
  - Grep
description: Apply production-grade Symfony architecture and execution workflows with controlled scope and clear checkpoints. Use for executing plans tasks.
---

# Executing Plans (Symfony)

## Use when
- Refining architecture/workflows/context handling in Symfony projects.
- Planning and executing medium/complex changes safely.

## Default workflow
1. Establish current boundaries, constraints, and coupling points.
2. Propose smallest coherent architectural adjustment.
2. Execute in checkpoints with validation at each stage.
2. Summarize tradeoffs and follow-up backlog.

## Guardrails
- Use existing project patterns by default.
- Avoid broad refactors without explicit need.
- Keep decision log clear and auditable.

## Progressive disclosure
- Use this file for execution posture and risk controls.
- Open references when deep implementation details are needed.

## Output contract
- Architecture/workflow changes.
- Checkpoint validation outcomes.
- Residual risks and next steps.

## References
- `reference.md`
- `docs/complexity-tiers.md`

Overview

This skill applies production-grade Symfony architecture and execution workflows with controlled scope and clear checkpoints. It guides teams through small, validated architectural adjustments and tracks decisions for auditability. The goal is safe, incremental change with explicit validation and a clear backlog of follow-ups.

How this skill works

The skill inspects current boundaries, coupling points, and constraints in your Symfony codebase and proposals minimal coherent adjustments that fit existing patterns. Changes are executed in defined checkpoints; each checkpoint includes concrete validation steps and outcome recording. At the end it summarizes tradeoffs, residual risks, and proposed next steps for the backlog.

When to use it

Refining architecture, context handling, or workflow boundaries in a Symfony project
Introducing medium-complexity changes that must be reversible or auditable
When you need a staged execution plan with validation at each checkpoint
Avoiding broad, risky refactors while still evolving the system design

Best practices

Default to existing project patterns and conventions unless a clear benefit justifies deviation
Propose the smallest coherent change that addresses the problem and reduces risk
Break work into checkpoints with explicit validation criteria and automated tests where possible
Record a clear decision log for each checkpoint: intent, implementation, validation, and rollback plan
Limit scope per execution window and capture follow-ups in a prioritized backlog

Example use cases

Introduce a context object for request-scoped data and migrate consumers in staged checkpoints
Replace a tightly coupled service with a well-defined interface implemented progressively
Add an execution workflow that enforces new validation rules with rollout gates
Refactor event handling to decouple components while preserving backward compatibility
Implement a performance-focused change with phased validation and rollback criteria

FAQ

How granular should checkpoints be?

Checkpoints should be small enough to validate behavior and rollback if needed, but large enough to deliver coherent value—typically a single logical change plus its tests and validation steps.

What belongs in the decision log?

Record the change intent, chosen approach, alternatives considered, validated outcomes, residual risks, and the rollback or mitigation plan.