zeszyt-write-layer
Assists in developing and testing write-layer application services and domain-driven features.
Install
mkdir -p .claude/skills/zeszyt-write-layer && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/13663" && unzip -o skill.zip -d .claude/skills/zeszyt-write-layer && rm skill.zipInstalls to .claude/skills/zeszyt-write-layer
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Work on write-layer behavior in the zeszyt-trenera repository. Use when Codex needs to add, change, review, or test commands, application requests, use cases, write-side app services, service-bag mocks, or domain behavior reached through write operations in src/write or adjacent application-layer code.Key capabilities
- →Add write-side commands
- →Implement application use cases
- →Expose new use cases through app services
- →Update service-bag tests or mocks
- →Test state-changing domain behavior
How it works
This skill guides the implementation of write-side application work by inspecting existing patterns, following DDD principles, and exposing new use cases through app services.
Inputs & outputs
When to use zeszyt-write-layer
- →Implement new application use cases
- →Add write-side command logic
- →Test state-changing domain behavior
About this skill
Zeszyt Write Layer
Overview
Use this skill for write-side application work in this repository: commands, use cases, application request types, service exposure, mocks, and tests around state-changing behavior.
The app is PWA, local-first, and mobile-first. Preserve that model: writes must go through the application layer, and domain rules must stay in domain code.
Workflow
- Inspect the nearest existing write-side command, use case, application request, service, and test that match the requested behavior. Keep discovery narrow and ask when broader context is needed.
- Follow DDD and hexagonal architecture boundaries. Put business decisions in the domain; keep application use cases focused on orchestration, persistence, and ports.
- When creating a use case, add the command or request type under the feature's
application/requestsarea. - Expose new use cases through
src/appServices.ts. - Update service-bag tests or mocks that implement
AppUseCaseswhen the use-case surface changes. - Check similar use cases before inventing structure, naming, return types, or test helpers.
- Write tests as a story. Use helpers when they make the scenario read like user or domain behavior instead of setup plumbing.
- Run the narrowest useful validation commands for the touched behavior.
- Follow repo-level version handling after completing the task: bump
package.jsononly when required by the current branch rules.
Testing Rules
- When using the
Moneyvalue object in tests, separate cents with an underscore: write200_00, not20_000. - Prefer test names and helper names that describe the business scenario.
- Keep assertions focused on observable application behavior and domain outcomes.
Boundary Checks
Before editing, identify which layer owns the behavior:
- Domain invariant or calculation: implement it in domain.
- Command orchestration or persistence transaction: implement it in the application use case.
- Port or storage concern: implement it behind the existing adapter boundary.
- UI trigger for a write: call the app service or use case; do not duplicate write logic in Vue.
If the ownership is unclear, ask before editing.
When not to use it
- →The task involves read-side operations
- →The task duplicates write logic in the UI layer
Limitations
- →The skill is for write-side application work
- →The skill requires domain rules to stay in domain code
- →The skill requires application use cases to focus on orchestration, persistence, and ports
How it compares
This skill ensures new write-layer features adhere to DDD and hexagonal architecture by guiding the placement of business logic and application use cases, unlike direct implementation.
Compared to similar skills
zeszyt-write-layer side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| zeszyt-write-layer (this skill) | 0 | 1mo | No flags | Advanced |
| nodejs-best-practices | 28 | 6mo | No flags | Advanced |
| nestjs-expert | 37 | 6mo | Review | Advanced |
| add-setting-env | 4 | 2mo | Review | Intermediate |
Try saying
Example prompts that trigger this skill in your AI assistant.
You might also like
nodejs-best-practices
davila7
Node.js development principles and decision-making. Framework selection, async patterns, security, and architecture. Teaches thinking, not copying.
nestjs-expert
davila7
Nest.js framework expert specializing in module architecture, dependency injection, middleware, guards, interceptors, testing with Jest/Supertest, TypeORM/Mongoose integration, and Passport.js authentication. Use PROACTIVELY for any Nest.js application issues including architecture decisions, testing strategies, performance optimization, or debugging complex dependency injection problems. If a specialized expert is a better fit, I will recommend switching and stop.
add-setting-env
lobehub
Guide for adding environment variables to configure user settings. Use when implementing server-side environment variables that control default values for user settings. Triggers on env var configuration or setting default value tasks.
nodejs-backend-patterns
wshobson
Build production-ready Node.js backend services with Express/Fastify, implementing middleware patterns, error handling, authentication, database integration, and API design best practices. Use when creating Node.js servers, REST APIs, GraphQL backends, or microservices architectures.
backend-patterns
affaan-m
后端架构模式、API设计、数据库优化以及针对Node.js、Express和Next.js API路由的服务器端最佳实践。
app-specific-patterns
growilabs
GROWI main application (apps/app) specific patterns for Next.js, Jotai, SWR, and testing. Auto-invoked when working in apps/app.