command-sub-agent

Generate and validate Command Side CQRS designs from specification directories.

2|Updated Dec 24, 2025
One-click install
npx skills add https://github.com/knowlet/skills --skill command-sub-agent
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: command-sub-agent
Source: https://github.com/knowlet/skills/tree/main/skills/command-sub-agent
Command: npx skills add https://github.com/knowlet/skills --skill command-sub-agent

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill focuses on the Command-Based Frame (CBF) paths, designing and validating Command Side (Use Cases, Aggregates, Domain Events) for consistent, testable writes.

Core Features & Use Cases

  • YAML-driven design: parse specs and model UseCase/Command/Handler.
  • Aggregate & Domain Event design: ensure invariants and event publishing.
  • Code skeleton generation: produce Application/Domain skeletons per spec.

Quick Start

Provide a docs/specs/create-order.yaml to generate the CreateOrderUseCase skeleton and align with coding-standards and enforce-contract.

Frequently Asked Questions about command-sub-agent

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

FAQPage Schema
How do I design the Command Side for CQRS architecture?

Command Side design in CQRS focuses on handling writes through Use Cases, Aggregates, and Domain Events. This Skill generates and validates Command Side implementations from YAML specifications, ensuring invariants are enforced, events are published correctly, and transaction boundaries respect idempotency constraints across Java, TypeScript, and Go.

What is event sourcing and how does it work with aggregates?

Event sourcing captures state changes as Domain Events rather than storing current state directly. Aggregates enforce invariants and publish events when commands execute. This Skill validates aggregate designs and event mappings to ensure commands produce consistent, reproducible event sequences aligned with your specification.

How do I generate aggregate and use case code skeletons from specifications?

Provide a YAML specification file defining your commands, handlers, and domain logic. This Skill parses the spec and generates application and domain layer skeletons, enforcing coding standards and contract compliance while mapping frame concerns to implementation details.

Can I validate Command Side designs before implementing them?

Yes. This Skill validates Command Side designs against frame concerns, aggregate invariants, transaction boundaries, and idempotency settings. It surfaces violations early so you can adjust your specification before writing production code.

Does this work with cross-context integrations and Anti-Corruption Layers?

Yes. This Skill handles cross-context Anti-Corruption Layer (ACL) integrations as part of Command Side validation. It ensures commands that depend on external contexts maintain proper boundaries and event contracts across domain boundaries.

What languages and frameworks does Command Side design support?

This Skill generates Command Side code skeletons and implementations for Java, TypeScript, and Go. It adapts patterns and idioms to each language while maintaining consistent CQRS design principles and domain-driven design conventions.