Brainstorming for Symfony Projects

Use this skill to explore ideas, requirements, and architecture decisions for your Symfony project.

Brainstorming Framework

Phase 1: Problem Definition

Before coding, clearly define:

1. What problem are we solving?

   • User need or business requirement
   • Current pain points
   • Expected outcomes

2. Who are the users?

   • Primary users
   • Secondary stakeholders
   • System integrations

3. What are the constraints?

   • Time/budget limitations
   • Technical constraints
   • Existing system dependencies

Phase 2: Solution Exploration

Symfony Component Analysis

Architecture Patterns

Consider which pattern fits:

• CRUD API: API Platform with standard resources
• Complex domain: Hexagonal/Ports & Adapters
• Event-driven: Messenger with domain events
• Read-heavy: CQRS with separate read models

Phase 3: Entity Design

Sketch entities before implementation:

User
├── id: uuid
├── email: string (unique)
├── password: hashed
├── roles: json
├── createdAt: datetime
└── Relations:
    └── posts: OneToMany -> Post

Post
├── id: uuid
├── title: string
├── content: text
├── status: enum (draft, published)
├── publishedAt: datetime?
└── Relations:
    ├── author: ManyToOne -> User
    └── tags: ManyToMany -> Tag

Phase 4: API Design

Define endpoints before coding:

POST   /api/users              # Create user
GET    /api/users/{id}         # Get user
PUT    /api/users/{id}         # Update user
DELETE /api/users/{id}         # Delete user

GET    /api/posts              # List posts (paginated)
POST   /api/posts              # Create post
GET    /api/posts/{id}         # Get post
PUT    /api/posts/{id}         # Update post
DELETE /api/posts/{id}         # Delete post
POST   /api/posts/{id}/publish # Publish post

Phase 5: Test Strategy

Plan tests early:

1. Unit tests: Services, validators, value objects
2. Integration tests: Repository, message handlers
3. Functional tests: Controllers, API endpoints
4. E2E tests: Critical user flows

Brainstorming Questions

For New Features

• What existing code can we reuse?
• How does this integrate with current entities?
• What new services/handlers are needed?
• What events should be dispatched?
• How do we handle failures?

For Refactoring

• What's the current pain point?
• What pattern would improve this?
• Can we do this incrementally?
• What tests exist/need updating?
• How do we ensure backwards compatibility?

For Performance

• Where are the bottlenecks?
• Can we add caching?
• Should this be async?
• Do we need a read model?
• Is the database schema optimal?

Output Template

After brainstorming, summarize:

## Feature: [Name]

### Problem
[What we're solving]

### Solution
[High-level approach]

### Components
- Entity: [List entities]
- Services: [List services]
- Handlers: [List message handlers]
- API: [List endpoints]

### Open Questions
- [Questions to resolve]

### Next Steps
1. [First step]
2. [Second step]