cqrs-implementation

Implement Command Query Responsibility Segregation for scalable architectures. Use when separating read and write models, optimizing query performance, or building event-sourced systems.

Quality

53%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./skills/cqrs-implementation/SKILL.md

The canonical home for this skill is cqrs-implementation in rmyndharis/antigravity-skills

Quality

Content

28%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

This skill is essentially a table of contents with no actionable content. It lists when to use CQRS and provides five extremely vague bullet points as instructions, then defers everything to a referenced playbook that doesn't exist in the bundle. Without concrete code examples, specific patterns, or executable guidance, this skill provides almost no value to Claude beyond what it already knows about CQRS.

Suggestions

Add concrete, executable code examples for at least the core CQRS pattern — e.g., a command handler, a query handler, and a read model projection with specific language/framework code.

Replace the vague instruction bullets with specific, sequenced steps that include concrete actions (e.g., 'Create a command class inheriting from BaseCommand with validate() method') and validation checkpoints.

Include at least one complete worked example showing input (a domain scenario) and output (the resulting command/query separation with code).

Either provide the referenced `resources/implementation-playbook.md` bundle file or inline the essential patterns directly in the SKILL.md so the skill is self-contained enough to be useful.

Dimension	Reasoning	Score
Conciseness	The 'Use this skill when' and 'Do not use this skill when' sections add some value but are somewhat padded. The instructions section is lean but the overall content includes some unnecessary framing (e.g., 'Comprehensive guide to implementing CQRS') that Claude doesn't need.	3 / 5
Actionability	The instructions are entirely vague and abstract — 'Identify read/write workloads,' 'Define command and query models,' 'Implement read model projections' — with zero concrete code, commands, examples, or specific implementation details. This is purely descriptive, not instructive.	1 / 5
Workflow Clarity	There is a rough sequence of steps (identify, define, implement, validate) but they are extremely high-level with no concrete substeps, no validation checkpoints, and no feedback loops. The 'validate performance, recovery, and failure modes' step is vague and unactionable.	2 / 5
Progressive Disclosure	The skill references `resources/implementation-playbook.md` for detailed patterns, which is a reasonable one-level-deep reference. However, no bundle files are provided, so we cannot verify the reference exists or is well-structured. The SKILL.md itself is too thin to serve as a useful overview — it defers almost everything to the playbook without providing any substantive quick-start content.	3 / 5
	Total	9 / 20 Passed

Description

78%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

This is a competent description that clearly communicates the pattern (CQRS) and provides explicit trigger conditions. Its main weakness is the lack of concrete implementation actions—it stays at the architectural concept level rather than describing specific deliverables like command handlers, event stores, or read model projections. The trigger terms are good but could include more natural variations.

Suggestions

Add specific concrete actions like 'creates command handlers, query handlers, event stores, and read model projections' to improve specificity

Include additional trigger terms users might naturally use such as 'command handler', 'query handler', 'event store', 'separate read/write databases', or 'eventual consistency'

Dimension	Reasoning	Score
Specificity	Names the domain (CQRS) and mentions a few actions like 'separating read and write models' and 'optimizing query performance', but doesn't list concrete implementation actions like creating command handlers, query handlers, event stores, or projections.	3 / 5
Completeness	Clearly answers both 'what' (implement CQRS for scalable architectures) and 'when' (separating read and write models, optimizing query performance, building event-sourced systems) with explicit trigger phrases in a 'Use when' clause.	5 / 5
Trigger Term Quality	Includes good keywords like 'CQRS', 'read and write models', 'query performance', 'event-sourced systems'. Missing some natural variations users might say like 'command handler', 'query handler', 'event store', 'projections', or 'separate read/write databases'.	4 / 5
Distinctiveness Conflict Risk	CQRS is a fairly specific architectural pattern, making it distinct from general architecture skills. However, there's some overlap risk with event sourcing skills or general scalability/architecture patterns.	4 / 5
	Total	16 / 20 Passed

Validation

90%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 10 / 11 Passed

Validation for skill structure

Criteria	Description	Result
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	10 / 11 Passed

Repository: administrakt0r/AI-Agents-Safe-Coding-Skills
Path: skills/cqrs-implementation/SKILL.md
Commit: 57c135b

Reviewed: 3 days ago

Table of Contents

Discovery Implementation Validation

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.