DDD Ecosystem with AI assistance included
Every Jardis package ships its own AI skill. One composer require, and your agent (Claude Code, Cursor, Continue, Aider) knows the rules, APIs and patterns of every installed package. No opt-in, no configuration, no separate downloads. Skill and code live in the same repository and travel together.
Installation
composer require --dev jardis/dev-skillsSource & issues: github.com/jardisTools/dev-skills
After installation, the plugin scans every Jardis package in vendor/, copies their skills into .claude/skills/ and aggregates each package's AGENTS.md into a project-wide AGENTS.md. Agent tools pick them up automatically when working in the project.
How it works
- Skill and code in the same package — every Jardis package contains its skill file at
<package>/.claude/skills/<name>/SKILL.md. Package maintainers keep API rules in a single place. - Plugin scans
vendor/jardis*/*on install/update and syncs to.claude/skills/in your project. Updates flow in automatically viacomposer update. AGENTS.mdgets aggregated — each package ships its agent hints; the plugin merges them into a managed block (<!-- BEGIN jardis/dev-skills ... -->/<!-- END -->) in your project'sAGENTS.md. Everything outside the block stays untouched.- Cross-agent standard — Cursor, Continue, Aider read
AGENTS.mdnatively; Claude Code additionally reads the.claude/skills/structure. One setup, every agent.
Detection by prefix
The plugin identifies skills by directory-name prefix only. These prefixes are reserved for Jardis, anything else the plugin leaves alone:
| Prefix | Source |
|---|---|
adapter-* | jardisadapter/* (HTTP, Cache, Messaging, Mailer, …) |
core-* | jardiscore/* (App, Kernel) |
support-* | jardissupport/* (Repository, Validation, Workflow, …) |
tools-* | jardistools/* (DbSchema) |
schema-* | Plugin-bundled (schema-authoring) |
platform-* | Plugin-bundled (platform-implementation, platform-usage, platform-versioning, platform-workflow, platform-cookbook) |
rules-* | Plugin-bundled (rules-architecture, rules-patterns, rules-testing) |
After install you will see a line in the Composer output like:
Jardis Skills installed: 14 skills, 3 AGENTS.md aggregated. See https://docs.jardis.io/skillsThe count varies: it tallies the vendor skills found in vendor/ plus the enabled methodology skills, not every project installs all of them.
Requirements: PHP ≥ 8.3, Composer ≥ 2.
Three zones — nine methodology skills
In addition to the 22 vendor skills, the plugin ships nine cross-package methodology skills, organised along the Jardis Designer workflow: Pre-Designer (idea → schema), Designer (visual model as the single source of truth: Board, Aggregate, Process), Post-Designer (code → business logic). On top sits the Crosscut layer with architecture and pattern rules that apply everywhere.
schema-authoring
- Board
- Aggregate
- Process
platform-implementationplatform-usageplatform-versioningplatform-workflowplatform-cookbook
rules-architecturerules-patternsrules-testing
Architecture & pattern rules that apply everywhere
Vendor skills — rolled out automatically
As soon as a Jardis package lands in your vendor/ directory, its skill is deployed to .claude/skills/ without any further configuration.
Adapter (8)
| Skill | Package | Description |
|---|---|---|
adapter-cache | jardisadapter/cache | PSR-16 multi-layer cache with write-through across L1→L2→L3. |
adapter-dbconnection | jardisadapter/dbConnection | PDO connection management with pool, read/write splitting and failover. |
adapter-eventdispatcher | jardisadapter/eventdispatcher | PSR-14 event dispatcher with priority, type hierarchy and deferred dispatch. |
adapter-filesystem | jardisadapter/filesystem | Filesystem abstraction for local and S3 with path traversal protection. |
adapter-http | jardisadapter/http | PSR-18 HTTP client on cURL with handler pipeline and retry. |
adapter-logger | jardisadapter/logger | PSR-3 logging pipeline with 20+ handlers, 7 formatters and 6 enrichers. |
adapter-mailer | jardisadapter/mailer | SMTP mailer with STARTTLS, attachments and batch keepalive. |
adapter-messaging | jardisadapter/messaging | Messaging API over Redis, Kafka, RabbitMQ, Database and InMemory. |
Core (2)
| Skill | Package | Description |
|---|---|---|
core-app | jardiscore/app | HTTP delivery: FastRoute router, PSR-15 pipeline, canonical DomainResponse → PSR-7 envelope. |
core-kernel | jardiscore/kernel | The Koffer: immutable DomainKernel + optional ENV packer BuildDomainKernelFromEnv. |
Tools (1)
| Skill | Package | Description |
|---|---|---|
tools-dbschema | jardistools/dbSchema | Schema analysis and DDL export for MySQL, PostgreSQL and SQLite over PDO. |
Support (11)
| Skill | Package | Description |
|---|---|---|
support-auth | jardissupport/auth | Session, password hashing and RBAC following the Closure-Orchestrator pattern. |
support-classversion | jardissupport/classVersion | Versioned classes via namespace injection and proxy registry. |
support-data | jardissupport/data | Entity hydration, change tracking, identity generation — reflection-based, no ORM. |
support-dbquery | jardissupport/dbQuery | Fluent SQL query builder for MySQL, MariaDB, PostgreSQL, SQLite with prepared statements. |
support-dotenv | jardissupport/dotenv | .env loader with public/private mode, cascading includes and cast chain. |
support-factory | jardissupport/factory | Minimal PSR-11 container with reflection fallback. |
support-repository | jardissupport/repository | Generic CRUD repository with read/write splitting and PK strategies. |
support-scheduling | jardissupport/scheduling | Pure-logic scheduling: cron parsing + task schedule, no execution. |
support-secret | jardissupport/secret | Secret resolution for .env via AES-256-GCM and Sodium as a DotEnv plugin. |
support-validation | jardissupport/validation | Object graph validation via reflection with 21 stateless validator singletons. |
support-workflow | jardissupport/workflow | Multi-step orchestration via named status routing (seven ON_* statuses) with a typed execution context. |
Methodology skills — opt-in
The nine methodology skills are not package-bound and only installed on request. Enable them via your project's composer.json:
{
"extra": {
"jardis/dev-skills": {
"bundled-skills": true
}
}
}Accepted values:
| Value | Effect |
|---|---|
Key absent or false | No methodology skills (default) |
true | All nine methodology skills |
["rules-*", "schema-authoring"] | Whitelist via shell globs (fnmatch()) |
{ "include": [...], "exclude": [...] } | Apply include first, then subtract exclude |
Examples:
"bundled-skills": ["rules-*"]Installs rules-architecture, rules-patterns, rules-testing.
"bundled-skills": { "include": ["rules-*"], "exclude": ["rules-patterns"] }Installs rules-architecture and rules-testing. rules-patterns is excluded.
Sync behavior: The composer.json is the source of truth. If you narrow bundled-skills (e.g. from true to ["rules-*"]), the next composer install removes the deselected methodology skills from .claude/skills/, even if you modified them locally. Vendor skills and skills without a Jardis prefix (my-*, internal-*) stay untouched.
Invalid values (e.g. bundled-skills: 42) print a warning to the Composer output and fall back to the "none" default, no abort.
Pre-Designer
| Skill | Description |
|---|---|
schema-authoring | From idea to Schema.yaml for the Designer import: derive tables, suggest indexes, hit the Designer format. Ships a companion examples/Schema.yaml (MeterDevice) as a complete reference. |
The former YAML vocabulary of the Designer output files (previously the
tools-definitionskill) is no longer part of the bundle. It now lives inside the Builder tooling itself.
Post-Designer — Active
| Skill | Description |
|---|---|
platform-implementation | Business logic on Designer-generated code in the Platform-Dir layout: generator output lives under {Agg}/Platform/ (rewritten on every build), developer code sits directly under {Agg}/ parallel to Platform/. V1–V12 prohibitions, decision tree, seven implementation stages, DomainResponse construction, package-toolbox cross-reference. ClassVersion → platform-versioning, Workflow engine → platform-workflow, recipes/troubleshooting → platform-cookbook. |
platform-usage | Call Designer-generated Commands/Queries from your own code: bootstrap, 4-hop Api-Registry call path, DomainResponse-to-transport mapping (HTTP status, CLI exit, queue ack/nack), error handling. Framework-agnostic — PSR-15, Symfony Console, queue workers. |
platform-versioning | ClassVersion resolution and the versioning model: 7-stage lookup via LoadClassFromExtensions with segmentNames: ['', 'Platform'], baseline vs. versioned overrides (v1, v2, …), ClassVersionConfig setup, five guiding principles (additive before version, a version never changes the API, a data break means a new aggregate, …). |
platform-workflow | Workflow-engine API for FlowDesigner-generated use-case orchestrators: six routing statuses (ON_SUCCESS/ON_FAIL/ON_TIMEOUT/ON_SKIP/ON_CANCEL/ON_EVENT), WorkflowBuilder graph construction, handlerFactory Closure conventions, three WorkflowContext slots, R5 routing-safety. |
platform-cookbook | Phase-3 recipes and troubleshooting for Designer code: event transport via <Agg>EventRouter.php (Kafka/RabbitMQ/Redis/HTTP webhook/in-process), six recipes (VO in Hydrate, Domain Service, new Command/Query, Event to Kafka, Flow-DTO input.extends, response shapes), troubleshooting table. |
Crosscut
| Skill | Description |
|---|---|
rules-architecture | Architectural pillars (SoC, SRP, Composition, Data-Behavior Separation, explicit dependencies), Hexagonal Architecture, Closure-Orchestrator pattern. |
rules-patterns | Pattern catalogue (Facade, Strategy, Adapter, Value Object, Factory, Repository, Decorator, Chain of Responsibility, Lazy Init, Priority Layers). |
rules-testing | Integration over unit tests, mock only at port boundaries, mandatory process for failing tests without weakening assertions. |
FAQ
Is this Claude-specific?
No. AGENTS.md is a cross-agent standard that Cursor, Continue and Aider read natively. The .claude/skills/ structure is optional for Claude Code users: if you don't use it, just ignore the folder.
What if I have my own skills?
Skills without a Jardis prefix (my-*, internal-*, …) stay untouched. On a name collision, the plugin moves the existing directory to a sibling at .claude/skills/<name>.backup/ and installs the new version on top, with a warning in the Composer output. The backup is never deleted automatically; you decide when you need it.
For AGENTS.md: if an AGENTS.md already exists without Jardis markers, the plugin renames it once to AGENTS.md.backup, carries your content into the new file and appends the managed Jardis block. On subsequent installs only the block between the markers is replaced. Everything outside, including its position, stays intact.
How do I uninstall?
composer remove jardis/dev-skills removes every directory with a Jardis prefix (adapter-*, core-*, support-*, tools-*, schema-*, platform-*, rules-*) and strips the managed block from AGENTS.md. If the AGENTS.md contains only the Jardis block, the file is deleted entirely. If it contains other content, the file stays and only the block vanishes. .backup directories and skills without a Jardis prefix are always preserved.
Are vendor skills installed automatically?
Yes. As soon as a jardisadapter/*, jardiscore/*, jardissupport/* or jardistools/* package is present in vendor/, its skill is rolled out to .claude/skills/ with no further configuration required.
And the nine methodology skills?
Opt-in. Enable them via extra."jardis/dev-skills"."bundled-skills" in your composer.json: true for all of them, a whitelist like ["rules-*"], or {"include": [...], "exclude": [...]} for fine-grained selection. Default is none, so you decide deliberately.
Are there upgrade notes?
Yes, the last overhaul retired the three plan-* skills (plan-requirements, plan-ddd-modeling, plan-data-discovery) in favour of the focused schema-authoring. tools-builder was merged into platform-implementation (the layout of the generated classes is now §1 of platform-implementation). The tools-definition skill was removed from the bundle. Its YAML vocabulary now lives inside the Builder tooling. And platform-implementation was split into five focused platform-* skills: implementation, usage, versioning, workflow, cookbook. Projects upgrading from older Jardis skills find any leftover plan-* and tools-definition directories untouched. They are now treated as custom skills.