engineering-foundations
- Repo stars 0
- Author updated Live
- Author repo skills-registry
- Domain
- Writing
- Compatible agents
-
- Claude Code
- Cursor
- Cline
- Codex
- Windsurf
- Gemini CLI
- +20
- Trust score
- 88 / 100 · community maintained
- Author / version / license
- @tomevault-io · no license declared
- Token usage
- Lean
- Setup complexity
- Plug-and-play
- External API key
- Not required
- Operating systems
- Unspecified (assume cross-platform)
- Runtime requirements
- No special requirements
- Permissions
-
- Read-only
- Write / modify
- Network behavior
- Local-only
- Install commands
- 26 variants
Profile is derived at build time from SKILL.md and install vectors. Subject to drift from author intent.
Heads up: 未限定 allowed-tools,默认拥有全部工具权限。
---
name: engineering-foundations
description: Language-agnostic engineering methodology — DDD, Hexagonal Architecture, TDD, architecture plann…
category: writing
runtime: no special runtime
---
# engineering-foundations output preview
## PART A: Task fit
- Use case: Language-agnostic engineering methodology — DDD, Hexagonal Architecture, TDD, architecture planning, requirements gathering, code review, and ADR writing. Use when the user asks HOW to approach something at the pattern/theory level, regardless of framework. This is the source of truth for DDD concepts (aggregates, domain events, rich models), architecture layers (presentation, application, domain, infrastructure), and testing methodology. Framework-specific implementations live in separate plugins (nestjs-toolkit, django-toolkit, nextjs-toolkit). Triggers for 'how should I test this', 'what is DDD', 'explain domain modeling', 'write an ADR', 'plan this feature', 'what are aggregates', 'hexagonal architecture'. DO NOT use for executing development work (use ai-dlc) or framework-specific questions (use the relevant framework plugin). Use when this capability is needed..
- Inputs: target material, constraints, expected output, and acceptance criteria.
- Evidence boundary: follow “Topics / Gotchas / General Principles” and do not present inference as author intent.
## PART B: Execution result
- **01** The card summarizes the use case; runtime output centers on “Language-agnostic engineering methodology — DDD, Hexagonal Architecture, TDD, architecture planning, requirements gathering, code review, and ADR writing. Use when the user asks HOW to approach something at the pattern/theory level, regardless of framework. This is the source of truth for DDD concepts (aggregates, domain events, rich models), architecture layers (presentation, application, domain, infrastructure), and testing methodology. Framework-specific implementations live in separate plugins (nestjs-toolkit, django-toolkit, nextjs-toolkit). Triggers for 'how should I test this', 'what is DDD', 'explain domain modeling', 'write an ADR', 'plan this feature', 'what are aggregates', 'hexagonal architecture'. DO NOT use for executing development work (use ai-dlc) or framework-specific questions (use the relevant framework plugin). Use when this capability is needed.”.
- **02** When the source has headings, the agent prioritizes “Topics / Gotchas / General Principles” so the result follows the author’s structure.
- **03** Typical output includes task judgment, concrete steps, required commands or file edits, validation, and follow-up options.
- **04** Risk context follows the fingerprint: read files, write/modify files; mostly runs locally; usually needs no extra API key.
## Running Rules
- read files, write/modify files; mostly runs locally; usually needs no extra API key.
- Validate with a small sample before expanding scope.
- Return the result, validation criteria, and next iteration options. The source does not require a stable slash command. After installation, invoke the skill by name and describe the task.
Name target files or source material, expected output, forbidden changes, and whether network or shell access is allowed. Permission fingerprint: read files, write/modify files.
Start with a small task and check whether the result follows “Topics / Gotchas / General Principles”. Inspect diffs, logs, previews, or tests before expanding scope.
Confirm the final output includes a concrete result, evidence, and next action. If it stays generic, tighten inputs, boundaries, and acceptance criteria.
---
name: engineering-foundations
description: Language-agnostic engineering methodology — DDD, Hexagonal Architecture, TDD, architecture plann…
category: writing
source: tomevault-io/skills-registry
---
# engineering-foundations
## When to use
- Language-agnostic engineering methodology — DDD, Hexagonal Architecture, TDD, architecture planning, requirements gath…
- Use it when the task has clear inputs, repeatable steps, and validation criteria.
## What to provide
- Target material, scope, expected result, and forbidden changes.
- Whether network, commands, file writes, or external services are allowed.
## Execution rules
- Organize steps around “Topics / Gotchas / General Principles” and keep inference separate from source facts.
- read files, write/modify files; mostly runs locally; usually needs no extra API key.
- Validate with a small sample before expanding the task.
## Output requirements
- Return the deliverable, key evidence, validation method, and next action.
- Mark missing information as unknown; do not invent commands, platforms, or dependencies. The author source anchors workflow facts; repository files anchor sources and commands; Fluxly only adds fit, limitations, and quality judgment.
skill "engineering-foundations" {
input -> user goal + target files + boundaries + acceptance criteria
context -> Topics / Gotchas / General Principles
rules -> SKILL.md triggers / order / output contract
runtime -> no special runtime | read files, write/modify files | mostly runs locally
guardrails -> usually needs no extra API key + small-sample validation + diff/log review
output -> copyable result + checklist + next iteration
} Recommended model: Opus — This skill involves deep reasoning, architecture decisions, or code review.
Opinionated, language-agnostic engineering methodology. Before applying any topic, read its reference file in reference/.
Topics
| Topic | When to Use | Reference |
|---|---|---|
| TDD | Writing unit tests, e2e tests, fixing failing tests | reference/tdd.md |
| Domain Modeling | Implementing rich domain models with business rules, state transitions | reference/domain-model.md |
| Code Review | Reviewing PRs, validating code quality, self-review | reference/code-review.md |
| Requirements | Gathering requirements, clarifying business logic, defining scope | reference/requirements.md |
| Architecture Planning | Planning features, making architectural decisions, designing solutions | reference/architecture.md |
| Deep Modules | Judging interface-vs-implementation ratio, choosing where to draw module boundaries, classifying dependencies | reference/deep-modules.md |
| ADR Writing | Documenting significant architectural decisions | reference/adr.md |
Gotchas
Claude-specific failure modes in engineering methodology:
- Hardcoding dates in tests — Claude's most persistent bad habit. Always use dynamic date generation (
new Date(), relative offsets). Never'2024-01-15'. - Modifying existing tests to make them pass — When a test fails, Claude's instinct is to "fix" the test. Fix the application code instead. Only modify tests if the requirements changed.
- Mocking internal modules in e2e tests — Claude mocks everything for convenience. In e2e tests, only mock external services (payment APIs, auth providers). Internal services, handlers, guards, and repositories must be real.
- One giant PR with no intermediate commits — Claude builds everything then commits once. Commit after each TDD Green phase.
- Designing from scratch when patterns exist — Claude invents new architectures instead of finding the closest existing implementation in the codebase. Always search for similar code first.
- Presenting only one option — Architecture planning requires 2-3 options with trade-offs. Claude tends to present its preferred approach as the only option.
- ADRs with no "Rejected Alternatives" — Claude writes ADRs that only describe the chosen approach. The rejected alternatives section is the most valuable part.
- Skipping the "what's out of scope" section — Requirements must explicitly define what is NOT being built. Claude omits this, leading to scope creep.
General Principles
| Principle | What to Do |
|---|---|
| Clarify Constraints | Scale? Budget? Existing systems? Timeline? MVP or production? |
| Prioritize Simplicity | Simplest solution that works. "The best code is no code." |
| Security by Design | Least privilege, encryption, input validation, parameterized queries |
| Present Options | 2-3 options with trade-offs. Then recommend one. |
Quick Decision Guide
Need to write/fix tests?
-> Read reference/tdd.md
Need to design a domain model?
-> Read reference/domain-model.md
Need to review code?
-> Read reference/code-review.md
Need to gather or clarify requirements?
-> Read reference/requirements.md
Need to plan a feature or make architecture decisions?
-> Read reference/architecture.md
Need to judge a module boundary, or decide if something is "too shallow"?
-> Read reference/deep-modules.md
Need to document a significant decision?
-> Read reference/adr.md
Source: anpham1925/claude-marketplace — distributed by TomeVault.
Decide Fit First
Design Intent
How To Use It
Boundaries And Review