home / skills / makfly / superpowers-symfony / effective-context

effective-context skill

safe

This skill helps refine Symfony architecture and execution workflows with controlled checkpoints and auditable decisions to safely manage medium complexity

npx playbooks add skill makfly/superpowers-symfony --skill effective-context

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:effective-context
allowed-tools:
  - Read
  - Glob
  - Grep
description: Apply production-grade Symfony architecture and execution workflows with controlled scope and clear checkpoints. Use for effective context tasks.
---

# Effective Context (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 apply production-grade Symfony architecture and execution workflows with controlled scope and clear checkpoints. It guides teams to propose minimal, coherent architectural changes and execute them in validated stages. The outcome is auditable decisions, reduced risk, and a clear follow-up backlog.

How this skill works

It inspects the current boundaries, constraints, and coupling points of a Symfony project to define a safe execution posture. It proposes the smallest coherent adjustment that meets the goal, then directs execution through discrete checkpoints with validation criteria. Each checkpoint produces a brief validation outcome, a record of tradeoffs, and recommended next steps.

When to use it

Planning medium to complex architecture or workflow changes in Symfony
Refining how context and execution flows are handled across bundles and services
Rolling out changes that must be reversible and auditable
When you need to limit blast radius and validate increments before broad refactors

Best practices

Favor existing project patterns; only deviate when benefits clearly outweigh costs
Define explicit, measurable validation criteria for each checkpoint
Keep change scope minimal — ship the smallest coherent increment that solves the problem
Log decisions and tradeoffs in an auditable format and link to follow-up backlog items
Avoid large, simultaneous refactors; prefer progressive disclosure of changes

Example use cases

Introduce a new context object to decouple request handling from domain services with a two-step rollout
Migrate a shared service to a more explicit interface and replace callers in validated batches
Refactor authentication flow to support multi-tenancy while keeping legacy behavior behind feature flags
Add async processing for a high-load endpoint with staged consumer rollouts and metrics checks

FAQ

How granular should checkpoints be?

Checkpoints should be as small as needed to validate a single assumption or risk while allowing safe rollback; typically each checkpoint maps to a single behavioral change and its verification.

When is a broad refactor acceptable?

Only when you can demonstrate that incremental changes cannot achieve the goal and you have mitigation plans, automated tests, and an explicit audit trail for decisions and rollbacks.