event-sourcing-architect

Design event-sourced systems with CQRS, projections, and sagas.

10|Updated May 20, 2026
One-click install
npx skills add https://github.com/AI-Safeter/antigravity-cli-plugin --skill event-sourcing-architect-ai-safeter
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: event-sourcing-architect
Source: https://github.com/AI-Safeter/antigravity-cli-plugin/tree/main/plugins/event-sourcing-architect
Command: npx skills add https://github.com/AI-Safeter/antigravity-cli-plugin --skill event-sourcing-architect-ai-safeter

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Event-sourced architectures provide complete auditability and scalable domain logic by persisting state as a sequence of immutable events, enabling temporal queries and reliable recovery.

Core Features & Use Cases

  • Event store design and implementation
  • CQRS (Command Query Responsibility Segregation) patterns
  • Projection building and read model optimization
  • Saga and process manager orchestration
  • Event versioning and schema evolution
  • Snapshotting strategies for long-lived systems
  • Handling eventual consistency across services

Use case examples include building audit trails for critical domains, supporting time-travel debugging, and orchestrating complex cross-aggregate workflows.

Quick Start

Define the domain aggregates, identify event streams, and bootstrap the initial read models and sagas to start an event-sourced system.

Frequently Asked Questions about event-sourcing-architect

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I design an event-sourced system with CQRS and projections?

To design an event-sourced system, define domain aggregates, identify immutable event streams, and bootstrap read models using CQRS to separate command execution from query projections. This establishes complete auditability and scalable domain logic.

What is the best way to handle event versioning and schema evolution in an event store?

Handling event versioning requires applying schema evolution techniques to immutable event streams. This ensures long-lived systems can adapt to structural changes while maintaining reliable recovery and accurate temporal queries across historical data.

When do I need snapshotting for long-lived event-sourced aggregates?

Snapshotting is needed for long-lived event-sourced systems when rebuilding aggregate state from immutable event streams becomes too slow. It periodically saves the current state to optimize recovery performance without losing historical audit trails.

How do sagas and process managers orchestrate complex workflows in event-sourced architectures?

Sagas and process managers orchestrate complex cross-aggregate workflows in event-sourced architectures by coordinating commands across services. They handle eventual consistency and ensure reliable domain logic execution across distributed system boundaries.

Does event sourcing work with domain-driven design for building audit trails?

Event sourcing works effectively with domain-driven design by persisting state as a sequence of immutable events within aggregate boundaries. This approach provides complete auditability, supports time-travel debugging, and enables temporal queries for critical domains.

How do I optimize read models for temporal queries in a CQRS architecture?

Optimizing read models in a CQRS architecture involves building dedicated projections from immutable event streams. This separates query execution from command processing, enabling efficient temporal queries and scalable retrieval without impacting domain logic.