Evolutionary Modular Architecture
tech-leads-club/agent-skills
Guides design of modular-monolith platforms with DDD, flat-by-aggregate modules, anti-corruption layers, outbox events and resilience, plus an architecture document with SVG diagrams.
Domain-Driven Design for Angular/TypeScript: functional patterns with type aliases, readonly fields, pure rule functions, immutable value types, branded IDs, and ports as abstract classes.
Install Angular Ddd
$ npx skills add fmflurry/settings-opencode --skill angular-ddd -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install fmflurry/settings-opencode angular-ddd --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/fmflurry/settings-opencode.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/angular-ddd .claude/skills/angular-ddd && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "angular-ddd" agent skill from https://github.com/fmflurry/settings-opencode/tree/master/skills/angular-ddd into .claude/skills/angular-ddd/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "angular-ddd", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/fmflurry/settings-opencode/tree/master/skills/angular-dddType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add fmflurry/settings-opencode --skill angular-ddd -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install fmflurry/settings-opencode angular-ddd --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/fmflurry/settings-opencode.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/angular-ddd .agents/skills/angular-ddd && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "angular-ddd" agent skill from https://github.com/fmflurry/settings-opencode/tree/master/skills/angular-ddd into .agents/skills/angular-ddd/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "angular-ddd", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add fmflurry/settings-opencode --skill angular-ddd -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install fmflurry/settings-opencode angular-ddd --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/fmflurry/settings-opencode.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/angular-ddd .cursor/skills/angular-ddd && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "angular-ddd" agent skill from https://github.com/fmflurry/settings-opencode/tree/master/skills/angular-ddd into .cursor/skills/angular-ddd/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "angular-ddd", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/fmflurry/settings-opencode.git --path skills/angular-ddd--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add fmflurry/settings-opencode --skill angular-ddd -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install fmflurry/settings-opencode angular-ddd --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/fmflurry/settings-opencode.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/angular-ddd .gemini/skills/angular-ddd && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "angular-ddd" agent skill from https://github.com/fmflurry/settings-opencode/tree/master/skills/angular-ddd into .gemini/skills/angular-ddd/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "angular-ddd", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install fmflurry/settings-opencode angular-dddInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add fmflurry/settings-opencode --skill angular-ddd -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/fmflurry/settings-opencode.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/angular-ddd .github/skills/angular-ddd && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "angular-ddd" agent skill from https://github.com/fmflurry/settings-opencode/tree/master/skills/angular-ddd into .github/skills/angular-ddd/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "angular-ddd", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add fmflurry/settings-opencode --skill angular-ddd -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install fmflurry/settings-opencode angular-ddd --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/fmflurry/settings-opencode.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/angular-ddd .opencode/skills/angular-ddd && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "angular-ddd" agent skill from https://github.com/fmflurry/settings-opencode/tree/master/skills/angular-ddd into .opencode/skills/angular-ddd/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "angular-ddd", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Facts
- Skill name
angular-ddd- GitHub stars
- 171
- Token cost
- ~2.5k tokens
- SKILL.md length
- 1,008 words
- Files
- 5
- Skills in repo
- 37
- Repo updated
- First seen
- Licence
- MIT
At a glance
Domain-Driven Design for Angular/TypeScript: functional patterns with type aliases, readonly fields, pure rule functions, immutable value types, branded IDs, and ports as abstract classes.
- Works in 6 steps: The domain model is the software.… → Ubiquitous Language. Code names match… → Bounded Contexts define boundaries. Each… → …
- Reviewing domain models
- SKILL.md covers When to Activate, Provenance, Core Principles and TypeScript Idioms, plus 7 more sections
- Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
What it does
Angular Ddd is an agent skill from fmflurry/settings-opencode. Domain-Driven Design for Angular/TypeScript: functional patterns with type aliases, readonly fields, pure rule functions, immutable value types, branded IDs, and ports as abstract classes. Use when creating or reviewing domain models, aggregates, rule functions, ports, bounded contexts, or domain events. Use when enforcing aggregate invariants, applying DDD tactical patterns, mapping bounded contexts, or integrating with event sourcing. Provides tactical-pattern guidance, strategic-design rules, an…
Its SKILL.md is about 2.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 4 other files (for example `event-sourcing-mapping.md`, `review-checklist.md` and `strategic-design.md`).
It sits in Development, covering Domain-driven design and Event-driven systems. It works with Angular and TypeScript. The repository describes itself as: Custom OpenCode settings. The licence is MIT.
When your agent uses it
- Reviewing domain models
- Bounded contexts
- Enforcing aggregate invariants
- Applying DDD tactical patterns
Example prompts
- “/angular-ddd”
Workflow steps
6 steps, taken from the first numbered list in SKILL.md.
- The domain model is the software. Business logic lives in domain objects and pure functions, not in services or components. (Evans, ch. 1)
- Ubiquitous Language. Code names match the domain expert's vocabulary. No translation layer between business and code. (Evans, ch. 2)
- Bounded Contexts define boundaries. Each context owns its model. Shared types across contexts are a design smell. (Evans, ch. 14)
- Aggregates enforce invariants. All mutations go through the aggregate root. External code never reaches inside. (Vernon, ch. 10)
- Value Objects are immutable and identity-free. They describe characteristics, not things. (Evans, ch. 5)
- Repositories return aggregates, not tables. Persistence is an infrastructure concern. (Vernon, ch. 12)
What it can do on your machine
Read from SKILL.md and the folder at commit f0dcb5a. It shows what the files ask for, not the result of running them.
Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
No scripts in the folder and no shell commands in SKILL.md.
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Context cost
Angular Ddd loads about 2.5k tokens when it runs. Until then it costs about 173 tokens; SKILL.md has 1,008 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
Safety
Auto-check passed
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
SKILL.md
The full file from fmflurry/settings-opencode at commit f0dcb5a, republished under its MIT licence (© fmflurry). 1,008 words, ~2,525 tokens.
Download SKILL.mdSave it as
.claude/skills/angular-ddd/SKILL.md (or your agent's skills folder). This skill also uses 4 other files; get the full folder from GitHub.- name
- angular-ddd
- description
- Domain-Driven Design for Angular/TypeScript: functional patterns with `type` aliases, `readonly` fields, pure rule functions, immutable value types, branded IDs, and ports as abstract classes. Use when creating or reviewing domain models, aggregates, rule functions, ports, bounded contexts, or domain events. Use when enforcing aggregate invariants, applying DDD tactical patterns, mapping bounded contexts, or integrating with event sourcing. Provides tactical-pattern guidance, strategic-design rules, an event-sourcing→flurryx mapping, and a file:line review checklist. Complements angular-clean-architecture (folder layout/layering/DI) and flurryx (store/replay mechanics).
angular-ddd
Domain-Driven Design guidance for Angular/TypeScript domain code. Makes DDD principles explicit and enforceable for the coder and code-reviewer agents.
When to Activate
- Creating or modifying domain models (entities, value objects, aggregates)
- Adding repositories, factories, or domain services
- Defining or refactoring bounded contexts
- Reviewing domain code for DDD compliance
- Refactoring anemic models toward rich behavior
- Enforcing aggregate invariants or encapsulation rules
Provenance
Content is synthesized from established DDD literature:
- Eric Evans, Domain-Driven Design: Tackling Complexity in the Heart of Software (2003) — "Blue Book"
- Vaughn Vernon, Implementing Domain-Driven Design (2013) — "Red Book"
- Martin Fowler, bliki articles on Anemic Domain Model, Domain Event, etc.
- TypeScript-specific idioms: branded types, discriminated unions,
readonly,Object.freeze
This is a practitioner synthesis, not a verbatim reproduction. Where sources disagree, the Red Book's pragmatic guidance takes precedence for implementation details.
Core Principles
- The domain model is the software. Business logic lives in domain objects and pure functions, not in services or components. (Evans, ch. 1)
- Ubiquitous Language. Code names match the domain expert's vocabulary. No translation layer between business and code. (Evans, ch. 2)
- Bounded Contexts define boundaries. Each context owns its model. Shared types across contexts are a design smell. (Evans, ch. 14)
- Aggregates enforce invariants. All mutations go through the aggregate root. External code never reaches inside. (Vernon, ch. 10)
- Value Objects are immutable and identity-free. They describe characteristics, not things. (Evans, ch. 5)
- Repositories return aggregates, not tables. Persistence is an infrastructure concern. (Vernon, ch. 12)
TypeScript Idioms
The Angular-specific delta vs. the .NET DDD skill:
| Concept | .NET idiom | TypeScript idiom |
|---|---|---|
| Identity | CustomerId record struct | Branded type: type CustomerId = string & { readonly __brand: 'CustomerId' } |
| Immutability | readonly record struct | readonly props + Object.freeze() for VOs; ReadonlyArray<T> for collections |
| Domain events | sealed record : IDomainEvent | Discriminated union with readonly kind discriminant |
| Domain model | sealed class with private setters | type alias with readonly props (per [[angular-clean-architecture]] convention) |
| Domain rules | Static methods on entity | Pure exported functions in core/rules/ |
| Ports | interface in Core | abstract class with abstract methods returning Observable<T> (per [[angular-clean-architecture]] convention) |
| Equality | Equals/GetHashCode override | Structural: compare all fields; identity: compare id field |
Tactical Patterns (summary)
| Pattern | One-liner | Reference |
|---|---|---|
| Entity | Has identity; equality by ID, not attributes | tactical-patterns.md § Entity |
| Value Object | No identity; immutable; equality by attributes | tactical-patterns.md § Value Object |
| Aggregate + Root | Consistency boundary; root is sole entry point | tactical-patterns.md § Aggregate |
| Repository | Collection-like abstraction over aggregates | tactical-patterns.md § Repository |
| Factory | Encapsulates complex creation logic | tactical-patterns.md § Factory |
| Specification | Reusable, composable query/predicate logic | tactical-patterns.md § Specification |
| Domain Service | Stateless logic that doesn't belong to an entity | tactical-patterns.md § Domain Service |
| Rich vs Anemic | Behavior lives with data, not in external services | tactical-patterns.md § Rich vs Anemic |
Full definitions, GOOD/BAD examples, and per-pattern checklist lines: tactical-patterns.md
Strategic Design (summary)
| Concept | One-liner | Reference |
|---|---|---|
| Bounded Context | Explicit boundary around a model + language | strategic-design.md § Bounded Context |
| Ubiquitous Language | Shared vocabulary within a context | strategic-design.md § Ubiquitous Language |
| Anti-Corruption Layer | Translation boundary shielding your model from external models | strategic-design.md § ACL |
| Context Mapping | Relationships between contexts (Shared Kernel, Customer/Supplier, etc.) | strategic-design.md § Context Mapping |
| Domain Events | Immutable record of something that happened in the domain | strategic-design.md § Domain Events |
| CQRS | Separate read/write models (deep enforcement defers to [[angular-cop]]/[[flurryx]]) | strategic-design.md § CQRS |
Full definitions, GOOD/BAD examples, and per-concept checklist lines: strategic-design.md
Event Sourcing & CQRS Mapping
flurryx provides event-sourced store mechanics (append-only message channels, replay, snapshots, dead letters). This skill maps DDD event-sourcing concepts to flurryx equivalents. Store API mechanics are owned by [[flurryx]] — this skill covers only the conceptual mapping.
| .NET Event Sourcing | flurryx equivalent |
|---|---|
| Append-only event log | StoreMessageChannel — every write is a persisted StoreMessage |
| Replay | store.replay(ids), replayDeadLetters(), undo()/redo() |
| Snapshots / time travel | restoreStoreAt(index), restoreResource(key, index) |
| Dead-letter / retry | getDeadLetters(), replayDeadLetterCommand(id, resolver) |
| Domain events (DDD) | Immutable TS records in core/events/; application layer turns them into store updates |
| CQRS read/write split | Write: use case → domain → port → adapter → syncToStore. Read: store.get(KEY) signal projections |
Full mapping with domain-event lifecycle and purity rules: event-sourcing-mapping.md
Show full SKILL.md (372 more words)Show less
Review Checklist
The code-reviewer agent applies review-checklist.md when reviewing domain code. It uses a 5-level severity taxonomy aligned with [[angular-cop]]: 🔴 bug (hard violations), 🟠 sec (security/access), 🟡 risk (architectural risk), 🟢 arch (pattern enforcement), 🔵 nit (style/naming). Load on demand during review.
Relationship to Other Skills
| Skill | Relationship |
|---|---|
| [[angular-clean-architecture]] | Provides folder layout, layering, DI wiring, lazy loading, and caching decorators. This skill provides the domain-modeling rules that live inside core/. |
| [[flurryx]] | Provides store/replay mechanics (StoreMessageChannel, replay, snapshots, dead letters). This skill maps DDD event-sourcing concepts to flurryx but does not restate its API. |
| [[angular-cop]] | Pre-merge review enforcement. Applies this skill's checklist during Angular PR review. |
Quick-Start Checklist (for coder)
When writing new domain code:
- Identify the bounded context this code belongs to
- Name types using the context's ubiquitous language
- Model entities with identity + behavior (not just data)
- Extract value objects for descriptive attributes (immutable, no ID)
- Group related entities into aggregates; designate one root
- Enforce invariants inside the aggregate root (factory + rule functions)
- Expose mutations only through the aggregate root's public methods
- Define repository ports in
core/ports/(return aggregates, not DTOs) - Use domain events for cross-aggregate or cross-context communication
- Keep domain services stateless; prefer entity methods when behavior fits one entity
Hard Rules
- No anemic models. If a type has only data fields and all logic lives in a separate service, that is a violation. Move behavior to the entity or a pure rule function. (Fowler, "Anemic Domain Model")
- Aggregate root is the only external entry point. No code outside the aggregate may hold a reference to an internal entity or mutate it directly. (Vernon, ch. 10)
- Value objects are immutable. Use
readonlyprops +Object.freeze(). No mutation after creation. (Evans, ch. 5) - Repositories return aggregates. Never return raw DTOs, API response types, or partial data from a domain port. (Vernon, ch. 12)
- Bounded-context boundaries are hard. No shared internal types across contexts. Use ACL adapters or domain events. (Evans, ch. 14)
core/(domain layer) has ZERO infra/framework imports. No flurryx, noHttpClient, no Angular imports. Domain events are pure TS records; the event store is an application/infrastructure concern realized by [[flurryx]]. RxJS is allowed at port boundaries only.- Never use
any. Useunknownif the type is truly unknown.
© fmflurry, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Files
SKILL.md and 4 other files in skills/angular-ddd of fmflurry/settings-opencode.
- SKILL.md
- event-sourcing-mapping.md
- review-checklist.md
- strategic-design.md
- tactical-patterns.md
Open the folder on GitHubat commit f0dcb5a
Compare with similar skills
Angular Ddd next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Angular Ddd this skillfmflurry/settings-opencode | 171 | — | ~2.5k | Automated safety check: Pass | MIT | |
| Evolutionary Modular Architecturetech-leads-club/agent-skills | 7k | — | ~3.7k | Automated safety check: Pass | CC-BY-4.0 | |
| Event Sourcingcitypaul/.dotfiles | 739 | — | ~7.8k | Automated safety check: Pass | Custom licence | |
| Dddswamp-club/swamp | 642 | — | ~1.4k | Automated safety check: Pass | Custom licence | |
| Migration PathAxonIQ/AxonFramework | 3.6k | — | ~594 | Automated safety check: Pass | Apache-2.0 | |
| Igniteui Angular LintingIgniteUI/igniteui-angular | 599 | — | ~614 | Automated safety check: Pass | Custom licence |
Similar skills
Event Sourcing
citypaul/.dotfiles
Event sourcing patterns for functional TypeScript — persist state as an append-only log of past events and rebuild it by folding them.
Ddd
swamp-club/swamp
Domain Driven Design guidance for TypeScript/Deno codebases.
Migration Path
AxonIQ/AxonFramework
Create a new Axon Framework 4→5 migration path documentation page.
Igniteui Angular Linting
IgniteUI/igniteui-angular
Quick-reference for linting the core Ignite UI for Angular library.
Ng Forge Dynamic Forms
ng-forge/ng-forge
Write and validate @ng-forge/dynamic-forms FormConfig objects for Angular.
More from fmflurry/settings-opencode
All 37 skills in this repoShow Your Work
fmflurry/settings-opencode
Keep a reviewable decision trail for long-running or unattended work: a TSV log with one row per decision (what, why, evidence, result).
Playwright E2E Authoring
fmflurry/settings-opencode
Scaffold and extend Playwright E2E tests for the gc.platform suite (tests/playwright), wiring every artifact to the real frontend (localhost:4200) + real .NET backend — never mocks.
Why
fmflurry/settings-opencode
A skill your agent uses for 'why does X work this way', 'why we picked Y', design rationale, regressions, postmortems, or data-backed thresholds.
Angular Accessibility
fmflurry/settings-opencode
Audit and fix common accessibility issues in Angular templates and Angular Material components.
Angular Clean Architecture
fmflurry/settings-opencode
Scaffolds and extends Angular standalone feature MODULES under src/app/modules/{name} using Clean Architecture layering (presentation/application/core/infrastructure), a self-registering module…
Angular Cop
fmflurry/settings-opencode
Pre-merge code review for Angular + TypeScript pull requests.
Related
Works with
Categories
Questions about Angular Ddd
What does Angular Ddd do?
Domain-Driven Design for Angular/TypeScript: functional patterns with type aliases, readonly fields, pure rule functions, immutable value types, branded IDs, and ports as abstract classes. Angular Ddd is an agent skill from fmflurry/settings-opencode. Domain-Driven Design for Angular/TypeScript: functional patterns with type aliases, readonly fields, pure rule functions, immutable value types, branded IDs, and ports as abstract classes.
When should I use Angular Ddd?
Angular Ddd fits situations like: reviewing domain models; bounded contexts; enforcing aggregate invariants; applying DDD tactical patterns.
How do I install Angular Ddd in Claude Code?
Run `npx skills add fmflurry/settings-opencode --skill angular-ddd -a claude-code`. Or copy the skill folder (skills/angular-ddd in fmflurry/settings-opencode) into .claude/skills/angular-ddd in your project. Claude Code loads it when a task matches its description.
How do I install Angular Ddd in Codex?
Run `npx skills add fmflurry/settings-opencode --skill angular-ddd -a codex`. Or copy the skill folder (skills/angular-ddd in fmflurry/settings-opencode) into .agents/skills/angular-ddd in your project. Codex loads it when a task matches its description.
Can I use Angular Ddd in Cursor, Gemini CLI or GitHub Copilot?
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add fmflurry/settings-opencode --skill angular-ddd -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/angular-ddd, .gemini/skills/angular-ddd, .github/skills/angular-ddd and .opencode/skills/angular-ddd in your project.
What does Angular Ddd need to run?
SKILL.md names no scripts, command-line tools or credentials: Angular Ddd is instructions for the agent only.
Does Angular Ddd access the network?
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Is Angular Ddd safe to install?
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
What licence does Angular Ddd use?
Angular Ddd is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
How many tokens does Angular Ddd use?
About 2.5k tokens (SKILL.md is roughly 10k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.
What are the alternatives to Angular Ddd?
Skills that share tags, products or a category with Angular Ddd: Evolutionary Modular Architecture (tech-leads-club/agent-skills, 7k stars), Event Sourcing (citypaul/.dotfiles, 739 stars), Ddd (swamp-club/swamp, 642 stars) and Migration Path (AxonIQ/AxonFramework, 3.6k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Angular Ddd?
fmflurry (a GitHub user) maintains it in fmflurry/settings-opencode, which has 171 GitHub stars. The repository holds 37 skills in this directory. The repository was last updated on October 5, 2026.
Source: fmflurry/settings-opencode on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.