home / skills / makfly / superpowers-symfony / using-symfony-superpowers

using-symfony-superpowers skill

safe

This skill helps you apply production-grade Symfony architecture and workflows with controlled checkpoints to safely execute complex changes.

npx playbooks add skill makfly/superpowers-symfony --skill using-symfony-superpowers

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

Files (1)

SKILL.md

1.1 KB

---

name: symfony:using-symfony-superpowers
allowed-tools:
  - Read
  - Glob
  - Grep
description: Apply production-grade Symfony architecture and execution workflows with controlled scope and clear checkpoints. Use for using symfony superpowers tasks.
---

# Using Symfony Superpowers (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
- `docs/complexity-tiers.md`

Overview

This skill guides applying production-grade Symfony architecture and execution workflows with a controlled scope and clear checkpoints. It helps teams propose minimal, safe architectural adjustments and execute them incrementally. The result is validated changes, a documented decision trail, and a short follow-up backlog.

How this skill works

It starts by mapping current boundaries, constraints, and coupling points in your Symfony project. Then it proposes the smallest coherent architectural change, breaks that change into checkpoints, and executes each checkpoint with validation steps. At completion it summarizes tradeoffs, residual risks, and recommended next tasks.

When to use it

Refining service boundaries, context handling, or module coupling in a Symfony app.
Planning medium-to-large changes that must be rolled out safely in production.
Introducing new execution workflows, command pipelines, or job orchestration.
When you need an auditable decision log and measurable validation at each step.
Before starting any broad refactor to determine risk and minimal scope.

Best practices

Default to existing project patterns; only deviate when the benefit clearly outweighs cost.
Propose the smallest coherent change that delivers the required outcome.
Split work into clear checkpoints with concrete validation criteria for each.
Keep a concise, auditable decision log describing tradeoffs and owners.
Avoid blanket refactors—address coupling points incrementally and measure impact.

Example use cases

Introduce a new bounded context and safely migrate a subset of related services.
Replace a monolithic event dispatcher with scoped message buses and validate handlers incrementally.
Migrate long-running tasks from controllers to Symfony Messenger with checkpointed rollouts.
Harden request context handling for multi-tenant routing with staged validation.
Implement a new execution workflow for background jobs while preserving current behavior until cutover.

FAQ

How granular should checkpoints be?

Make checkpoints small enough to test and revert independently, but large enough to keep momentum—typically one deployable change with clear validation steps.

What belongs in the decision log?

Record chosen alternatives, rationale, risk assessment, owner, and any follow-up work required to complete or revert the change.