home / skills / makfly / superpowers-symfony / quality-checks

quality-checks skill

safe

This skill helps enforce production-grade Symfony architecture and checkpoints, guiding safe, incremental quality checks and auditable decision logs.

npx playbooks add skill makfly/superpowers-symfony --skill quality-checks

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:quality-checks
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 quality checks tasks.
---

# Quality Checks (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 helps teams plan, validate, and deliver medium-to-complex changes safely while preserving existing project patterns. The goal is pragmatic adjustments, auditable decisions, and minimized risk during rollout.

How this skill works

The skill inspects current boundaries, constraints, and coupling points in your Symfony codebase and runtime workflows. It proposes the smallest coherent architectural adjustment, then breaks execution into checkpoints with validation criteria for each stage. At completion it summarizes tradeoffs, residual risks, and a prioritized follow-up backlog.

When to use it

Refactoring or extending critical systems in a Symfony application
Introducing new execution workflows, middleware, or context propagation
Planning multi-step changes where rollback and validation are required
When you need auditable decisions and clear checkpoints for reviewers
During architecture reviews before rolling major deployment changes

Best practices

Default to existing project patterns; introduce deviations only when necessary
Define small, verifiable checkpoints with automated or manual validation steps
Log decisions, rationales, and tradeoffs in a concise, auditable format
Avoid broad, undifferentiated refactors—prefer incremental improvements
Classify changes by complexity tier to align testing and rollout plans

Example use cases

Add a request-scoped context service while preserving legacy service contracts
Introduce an event-driven workflow step with stepwise validation and rollback
Refine domain boundaries and coupling points before a horizontal scaling change
Replace a core middleware component by migrating consumers in controlled stages
Plan a multi-release feature introduction with clear checkpoint gates

FAQ

What counts as a checkpoint?

A checkpoint is a small, testable change with defined validation criteria and a rollback path. It should be atomic and reviewable.

How do you measure residual risk?

Residual risk is assessed by remaining unknowns, potential impact, and likelihood. Document them and attach mitigations and monitoring steps.