acc-create-mediator
Generates Mediator pattern for PHP 8.5. Creates coordination layer for complex component interactions with event dispatching, request/response handling, and colleague classes. Reduces coupling between interacting objects. Includes unit tests.
Best use case
acc-create-mediator is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Generates Mediator pattern for PHP 8.5. Creates coordination layer for complex component interactions with event dispatching, request/response handling, and colleague classes. Reduces coupling between interacting objects. Includes unit tests.
Teams using acc-create-mediator should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/acc-create-mediator/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How acc-create-mediator Compares
| Feature / Agent | acc-create-mediator | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Generates Mediator pattern for PHP 8.5. Creates coordination layer for complex component interactions with event dispatching, request/response handling, and colleague classes. Reduces coupling between interacting objects. Includes unit tests.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Mediator Pattern Generator
## Overview
Generates Mediator pattern components for PHP 8.5 to coordinate complex interactions between multiple objects without them referencing each other directly.
## When to Use
- Complex communication between multiple objects
- Reducing coupling in event-driven systems
- Coordinating UI components or form elements
- Command bus / Query bus implementation
- Chat room / notification hub scenarios
- Workflow coordination
## Generated Components
| Component | Location | Purpose |
|-----------|----------|---------|
| MediatorInterface | `src/Application/{Context}/Mediator/` | Defines mediation contract |
| ConcreteMediator | `src/Application/{Context}/Mediator/` | Implements coordination logic |
| ColleagueInterface | `src/Application/{Context}/Mediator/Colleague/` | Participant contract |
| AbstractColleague | `src/Application/{Context}/Mediator/Colleague/` | Base with mediator access |
| ConcreteColleagues | `src/Application/{Context}/Mediator/Colleague/` | Participating components |
| Tests | `tests/{Context}/Application/Mediator/` | Unit tests |
## Input Requirements
1. **Name** - Mediator name (e.g., "OrderWorkflow", "ChatRoom")
2. **Context** - Bounded context (e.g., "Order", "Notification")
3. **Colleagues** - List of participating components
4. **Events** - Events to coordinate (optional)
## Template: Mediator Interface
```php
<?php
declare(strict_types=1);
namespace App\{Context}\Application\Mediator;
use App\{Context}\Application\Mediator\Colleague\ColleagueInterface;
interface {Name}Mediator
{
public function notify(ColleagueInterface $sender, string $event, mixed $data = null): void;
public function register(ColleagueInterface $colleague): void;
public function send(string $request, mixed $data = null): mixed;
}
```
## Template: Colleague Interface
```php
<?php
declare(strict_types=1);
namespace App\{Context}\Application\Mediator\Colleague;
use App\{Context}\Application\Mediator\{Name}Mediator;
interface ColleagueInterface
{
public function getName(): string;
public function setMediator({Name}Mediator $mediator): void;
public function handle(mixed $data): mixed;
}
```
## Template: Abstract Colleague
```php
<?php
declare(strict_types=1);
namespace App\{Context}\Application\Mediator\Colleague;
use App\{Context}\Application\Mediator\{Name}Mediator;
abstract class AbstractColleague implements ColleagueInterface
{
protected ?{Name}Mediator $mediator = null;
public function setMediator({Name}Mediator $mediator): void
{
$this->mediator = $mediator;
}
protected function notify(string $event, mixed $data = null): void
{
if ($this->mediator === null) {
throw new MediatorNotSetException();
}
$this->mediator->notify($this, $event, $data);
}
protected function send(string $request, mixed $data = null): mixed
{
if ($this->mediator === null) {
throw new MediatorNotSetException();
}
return $this->mediator->send($request, $data);
}
}
```
## File Placement
```
src/
└── {Context}/
└── Application/
└── Mediator/
├── {Name}Mediator.php # Interface
├── {Name}MediatorImpl.php # Implementation
└── Colleague/
├── ColleagueInterface.php # Base interface
├── AbstractColleague.php # Base class
└── {Colleague}.php # Participants
tests/
└── {Context}/
└── Application/
└── Mediator/
└── {Name}MediatorTest.php # Tests
```
## GRASP Compliance
| Principle | Implementation |
|-----------|----------------|
| Low Coupling | Colleagues don't know each other |
| Indirection | Mediator provides indirection layer |
| Controller | Mediator coordinates use case flow |
| Pure Fabrication | Mediator is artificial coordinating class |
## References
See `references/` for detailed documentation:
- `templates.md` - Full Mediator, Colleague, Command Bus, Event Mediator, Chat Room templates
- `examples.md` - Real-world examplesRelated Skills
mcp-create-declarative-agent
Skill converted from mcp-create-declarative-agent.prompt.md
kitt-create-slash-commands
Expert guidance for creating slash commands. Use when working with slash commands, creating custom commands, understanding command structure, or learning YAML configuration.
kitt-create-plans
Create hierarchical project plans optimized for solo agentic development. Use when planning projects, phases, or tasks that the AI agent will execute. Produces agent-executable plans with verification criteria, not enterprise documentation. Handles briefs, roadmaps, phase plans, and context handoffs.
create-workflow
Create Jazz workflow automation files (WORKFLOW.md). Use this for scheduling Jazz agents to run recurring tasks. For OS-level scripts/commands, use create-system-routine.
create-rule
Create persistent AI agent rules and instructions. Use when you want to create a rule, add coding standards, set up project conventions, configure file-specific patterns, or create AGENTS.md/GEMINI.md rule files across Cursor, Gemini CLI, or Codex.
create-prompt
Expert prompt engineering for creating effective prompts for Claude, GPT, and other LLMs. Use when writing system prompts, user prompts, few-shot examples, or optimizing existing prompts for better performance.
create-expert-skill
Create production-ready skills from expert knowledge. Extracts domain expertise and system ontologies, uses scripts for deterministic work, loads knowledge progressively. Use when building skills that must work reliably in production.
create-event-handlers
Sets up RabbitMQ event publishers and consumers following ModuleImplementationGuide.md Section 9. RabbitMQ only (no Azure Service Bus). Creates publishers with DomainEvent (tenantId preferred), consumers with handlers, naming {domain}.{entity}.{action}, required fields (id, type, version, timestamp, tenantId, source, data). Use when adding event-driven communication, async workflows, or integrating via events.
create-custom-prompt
Prompt for creating custom prompt files
create-assistant
Create and configure Vapi voice AI assistants with models, voices, transcribers, tools, hooks, and advanced settings. Use when building voice agents, phone bots, customer support assistants, or any conversational AI that handles phone or web calls.
create-agents-md
Create or rewrite AGENTS.md files for Open Mercato packages and modules. Use this skill when adding a new package, creating a new module, or when an existing AGENTS.md needs to be created or refactored. Ensures prescriptive tone, MUST rules, checklists, and consistent structure across all agent guidelines.
create-agent-with-sanity-context
Build AI agents with structured access to Sanity content via Context MCP. Covers Studio setup, agent implementation, and advanced patterns like client-side tools and custom rendering.