Nm Archetypes Architecture Paradigm Event Driven

Apply event-driven async messaging to decouple producers and consumers. Use for real-time processing

Security Scan

This is an instruction-only guidance skill about event-driven architecture; its requirements and instructions are consistent with its stated purpose and it does not request credentials, install software, or perform I/O.

Purpose & Capability

The name and description match the SKILL.md content: guidance on event-driven async messaging and adoption steps. There are no unrelated env vars, binaries, or config paths requested.

Instruction Scope

SKILL.md contains architecture guidance and troubleshooting notes only. It does not instruct the agent to read files, access environment variables, call external endpoints, or transmit data. The troubleshooting lines are generic and expected for documentation.

Install Mechanism

No install specification and no code files — this is instruction-only, so nothing will be downloaded or written to disk as part of installation.

Credentials

The skill declares no required environment variables, credentials, or config paths. There is no disproportionate request for secrets or unrelated credentials.

Persistence & Privilege

always is false and the skill does not request persistent or elevated privileges. It does not modify other skills or system settings.

Assessment

This is essentially a documentation/architecture note — installing it is low-risk because it contains no code, no installs, and asks for no secrets. If you expect the skill to integrate with message brokers or perform automated actions, you will need additional plugins or credentials (e.g., Kafka/Redis brokers or CI integrations); verify those integrations separately before providing any secrets. If you only want conceptual guidance on event-driven design, this skill is appropriate.

Night Market Skill — ported from claude-night-market/archetypes. For the full experience with agents, hooks, and commands, install the Claude Code plugin.

The Event-Driven Architecture Paradigm

When To Use

• Building async, loosely-coupled systems
• Systems with complex event processing pipelines

When NOT To Use

• Simple request-response applications without async needs
• Systems requiring strong transactional consistency

When to Employ This Paradigm

• For real-time or bursty workloads (e.g., IoT, financial trading, logistics) where loose coupling and asynchronous processing are beneficial.
• When multiple, distinct subsystems must react to the same business or domain events.
• When system extensibility is a high priority, allowing new components to be added without modifying existing services.

Adoption Steps

1. Model the Events: Define canonical event schemas, establish a clear versioning strategy, and assign ownership for each event type.
2. Select the Right Topology: For each data flow, make a deliberate choice between choreography (e.g., a simple pub/sub model) and orchestration (e.g., a central controller or saga orchestrator).
3. Engineer the Event Platform: Choose the appropriate event brokers or message meshes. Configure critical parameters such as message ordering, topic partitions, and data retention policies.
4. Plan for Failure Handling: Implement production-grade mechanisms for handling message failures, including Dead-Letter Queues (DLQs), automated retry logic, idempotent consumers, and tools for replaying events.
5. Instrument for Observability: Implement detailed monitoring to track key metrics such as consumer lag, message throughput, schema validation failures, and the health of individual consumer applications.

Key Deliverables

• An Architecture Decision Record (ADR) that documents the event taxonomy, the chosen broker technology, and the governance policies (e.g., for naming, versioning, and retention).
• A centralized schema repository with automated CI validation and consumer-driven contract tests.
• Operational dashboards for monitoring system-wide throughput, consumer lag, and DLQ depth.

Risks & Mitigations

• Hidden Coupling through Events:
  • Mitigation: Consumers may implicitly depend on undocumented event semantics or data fields. Publish a formal event catalog or schema registry and use linting tools to enforce event structure.
• Operational Complexity and "Noise":
  • Mitigation: Without strong observability, diagnosing failed or "stuck" consumers is extremely difficult. Enforce the use of distributed tracing and standardized alerting across all event-driven components.
• "Event Storming" Analysis Paralysis:
  • Mitigation: While event storming workshops are valuable, they can become unproductive if not properly managed. Keep modeling sessions time-boxed and focused on high-value business contexts first.

Troubleshooting

Common Issues

Command not found Ensure all dependencies are installed and in PATH

Permission errors Check file permissions and run with appropriate privileges

Unexpected behavior Enable verbose logging with --verbose flag