home / skills / makfly / superpowers-symfony / daily-workflow

daily-workflow skill

safe

This skill applies production-grade Symfony architecture and guarded daily workflows with checkpoints, ensuring safe, auditable changes and clear next steps.

npx playbooks add skill makfly/superpowers-symfony --skill daily-workflow

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

# Daily Workflow (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 to day-to-day engineering tasks with controlled scope and clear checkpoints. It focuses on making small, high-confidence architectural adjustments and executing them in validated stages. The goal is safe, auditable change delivery that preserves existing patterns and reduces risk.

How this skill works

The skill inspects project boundaries, coupling points, and existing patterns to determine safe change pathways. It proposes the smallest coherent architectural adjustment, then breaks execution into checkpoints with explicit validation criteria. After each checkpoint it records outcomes, tradeoffs, and residual risks, producing a concise follow-up backlog.

When to use it

Planning medium-complexity features that touch multiple layers of a Symfony app.
Refining context handling, service boundaries, or request lifecycle behaviors.
Introducing new cross-cutting concerns (caching, security, observability) safely.
Preparing changes that must be auditable and reversible.
When you need a repeatable, low-risk daily workflow for architecture work.

Best practices

Default to existing project patterns and conventions unless there’s a compelling reason to change.
Propose minimal, coherent adjustments that can be validated independently.
Break work into checkpoints with pass/fail validation criteria before proceeding.
Keep a clear decision log detailing reasons, alternatives considered, and rollback plans.
Limit broad refactors; schedule them only after explicit stakeholder alignment.

Example use cases

Add a scoped service for request-level context with checkpoints for behavior and performance.
Migrate a single controller to a new handler pattern and validate compatibility before sweeping changes.
Introduce an application-level cache with staged rollout and metrics validation at each step.
Adjust dependency wiring for a domain feature while preserving existing public interfaces.
Document and implement a fix for a recurring race condition with tests and observability checks.

FAQ

What does a checkpoint look like?

A checkpoint is a small, testable change with clear validation steps, expected outcomes, and rollback instructions.

How do I decide scope?

Start from coupling points and opt for the smallest change that achieves the goal; expand scope only after checkpoint validation fails or new requirements emerge.