playbooks

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

writing-plans skill

/skills/writing-plans

This skill helps you design production-grade Symfony architectures with bounded tasks, checkpoints, and auditable decision logs.

npx playbooks add skill makfly/superpowers-symfony --skill writing-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:writing-plans
allowed-tools:
  - Read
  - Glob
  - Grep
description: Apply production-grade Symfony architecture and execution workflows with controlled scope and clear checkpoints. Use for writing plans tasks.
---

# Writing 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 helps produce focused, production-grade Symfony architecture and execution plans with controlled scope and clear checkpoints. It is designed for teams that need safe, incremental changes to architecture or workflows while keeping risk auditable and reversible. The outputs are concrete adjustments, validation checkpoints, and a follow-up backlog.

How this skill works

I inspect the current boundaries, constraints, and coupling points in your Symfony project and propose the smallest coherent architectural adjustment that meets your goal. Plans are broken into checkpoints with explicit validation criteria and rollback paths. Each checkpoint includes tradeoff notes, residual risks, and next steps to keep decisions auditable.

When to use it

  • Refining execution workflows or context handling in a Symfony application
  • Planning medium-to-complex changes that must be delivered safely
  • Introducing a new service boundary, integration, or data flow
  • When you need checkpointed delivery with built-in validation and rollback
  • Auditing or documenting architectural decisions for compliance or onboarding

Best practices

  • Default to existing project patterns and conventions to minimize risk
  • Propose the smallest coherent change that accomplishes the goal
  • Break work into checkpoints with clear validation and rollback criteria
  • Keep a concise decision log recording tradeoffs and reasons
  • Avoid broad refactors unless explicitly justified by metrics or risk

Example use cases

  • Add a new bounded context façade to decouple a legacy domain service
  • Introduce a background worker and messaging flow with staged rollout
  • Migrate a portion of authentication to a token-based gateway with tests
  • Refine request context propagation across middleware and event listeners
  • Plan a database migration with backward-compatible schema and checkpoints

FAQ

How granular are the checkpoints?

Checkpoints are as granular as needed to validate assumptions safely — typically feature- or integration-level steps with automated and manual checks.

Will this recommend large-scale refactors?

No. Recommendations favor minimal, coherent changes. Large refactors are only suggested when justified by clear risk reduction or measurable benefits.