@pratikpsl/agent-skills 1.2.0 → 1.4.0

package/README.md

@@ -18,7 +18,7 @@ Running with an **agent name** or `shared` automatically installs shared skills
 # Install shared skills + specific IDE / Agent entry point
 npx @pratikpsl/agent-skills antigravity # → .agents/rules/GEMINI.md + AgentSkills/
 npx @pratikpsl/agent-skills cursor      # → .cursor/rules/instructions.md + AgentSkills/
-npx @pratikpsl/agent-skills claude      # → CLAUDE.md + AgentSkills/
+npx @pratikpsl/agent-skills claude      # → AGENTS.md + AgentSkills/
 npx @pratikpsl/agent-skills code        # → AGENTS.md + AgentSkills/
 npx @pratikpsl/agent-skills codex       # → AGENTS.md + AgentSkills/
 npx @pratikpsl/agent-skills copilot     # → .github/copilot-instructions.md + AgentSkills/
@@ -59,6 +59,28 @@ npx @pratikpsl/agent-skills react --agent cursor
 npx @pratikpsl/agent-skills react --agent claude
 ```
 
+### Python Template
+
+```bash
+# Install Python agent skills + all IDE entry points
+npx @pratikpsl/agent-skills python
+
+# Install Python agent skills + specific agent entry point only
+npx @pratikpsl/agent-skills python --agent cursor
+npx @pratikpsl/agent-skills python --agent claude
+```
+
+### Rust Template
+
+```bash
+# Install Rust agent skills + all IDE entry points
+npx @pratikpsl/agent-skills rust
+
+# Install Rust agent skills + specific agent entry point only
+npx @pratikpsl/agent-skills rust --agent cursor
+npx @pratikpsl/agent-skills rust --agent claude
+```
+
 *(You can also use `bunx @pratikpsl/agent-skills` in Bun environments).*
 
 ---
@@ -69,7 +91,7 @@ npx @pratikpsl/agent-skills react --agent claude
 Usage: agent-skills [options] [template]
 
 Arguments:
-  template              Template: default, dotnet, react, shared; agent names install shared guidance
+  template              Template: default, dotnet, python, react, rust, shared; agent names install shared guidance
 
 Options:
   -V, --version         output the version number
@@ -89,7 +111,9 @@ Options:
 | --- | --- | --- |
 | `shared` | `templates/shared/` | Base operating contract, core skills (principles, standards, security, review), review & architecture agents (`architect.md`, `reviewer.md`) |
 | `dotnet` | `templates/dotnet/` | .NET/C# skills, architecture & developer agents (`architect.md`, `developer.md`), memory |
+| `python` | `templates/python/` | Python skills (PEP 8, uv, typing, testing, performance), architecture & developer agents (`architect.md`, `developer.md`) |
 | `react` | `templates/react/` | React & TypeScript skills, frontend testing, developer agent (`developer.md`) |
+| `rust` | `templates/rust/` | Rust skills (standards, ownership, testing, performance), architecture & developer agents (`architect.md`, `developer.md`) |
 | `default` | `templates/default/` | Compact single-file agent instructions without AgentSkills folder |
 
 ---
@@ -108,7 +132,9 @@ coding-skills-ai/
 ├── templates/
 │   ├── default/                # Single-file instructions
 │   ├── dotnet/                 # .NET template
+│   ├── python/                 # Python template
 │   ├── react/                  # React template
+│   ├── rust/                   # Rust template
 │   └── shared/                 # Shared operating contract & memory
 ├── tests/                      # Vitest test suite
 ├── bun.lock                    # Reproducible lockfile

package/dist/core/ide-map.js

@@ -1,6 +1,6 @@
 export const IDE_ENTRY_POINTS = {
     antigravity: ".agents/rules/GEMINI.md",
-    claude: "CLAUDE.md",
+    claude: "AGENTS.md",
     cline: ".clinerules",
     code: "AGENTS.md",
     codex: "AGENTS.md",

package/dist/core/resolve-template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-template.d.ts","sourceRoot":"","sources":["../../src/core/resolve-template.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,cAAc,UAA2C,CAAC;AAMvE,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAWpD"}
+{"version":3,"file":"resolve-template.d.ts","sourceRoot":"","sources":["../../src/core/resolve-template.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,cAAc,UAA6D,CAAC;AAMzF,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAWpD"}

package/dist/core/resolve-template.js

@@ -2,7 +2,7 @@ import { existsSync } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-export const TEMPLATE_NAMES = ["default", "dotnet", "react", "shared"];
+export const TEMPLATE_NAMES = ["default", "dotnet", "python", "react", "rust", "shared"];
 function templatesRoot() {
     return path.resolve(__dirname, "..", "..", "templates");
 }

package/dist/core/resolve-template.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-template.js","sourceRoot":"","sources":["../../src/core/resolve-template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AAChC,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAC;AAEpC,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAE/D,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;AAEvE,SAAS,aAAa;IACpB,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;AAC1D,CAAC;AAED,MAAM,UAAU,qBAAqB;IACnC,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE,QAAQ,CAAC,CAAC;AAC9C,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CAAC,qBAAqB,IAAI,cAAc,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACvF,CAAC;IAED,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE,IAAI,CAAC,CAAC;IACrD,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CAAC,aAAa,IAAI,qCAAqC,CAAC,CAAC;IAC1E,CAAC;IAED,OAAO,WAAW,CAAC;AACrB,CAAC"}
+{"version":3,"file":"resolve-template.js","sourceRoot":"","sources":["../../src/core/resolve-template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AAChC,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAC;AAEpC,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAE/D,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;AAEzF,SAAS,aAAa;IACpB,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC;AAC1D,CAAC;AAED,MAAM,UAAU,qBAAqB;IACnC,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE,QAAQ,CAAC,CAAC;AAC9C,CAAC;AAED,MAAM,UAAU,eAAe,CAAC,IAAY;IAC1C,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CAAC,qBAAqB,IAAI,cAAc,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACvF,CAAC;IAED,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE,IAAI,CAAC,CAAC;IACrD,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CAAC,aAAa,IAAI,qCAAqC,CAAC,CAAC;IAC1E,CAAC;IAED,OAAO,WAAW,CAAC;AACrB,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pratikpsl/agent-skills",
   "type": "module",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "CLI to scaffold and manage AI agent skills across projects — like shadcn/ui, but for Cursor, Claude, Codex, Copilot, Antigravity, and more",
   "bin": {
     "agent-skills": "dist/bin/agent-skills.js"
@@ -26,6 +26,8 @@
     "copilot",
     "codex",
     "dotnet",
+    "python",
+    "rust",
     "agents",
     "antigravity",
     "typescript"

package/templates/default/instructions.md

@@ -18,7 +18,8 @@ minimizing the diff, following the project's own architecture and conventions.
 - Keep functions under 50 lines, nesting depth at most 2 levels (prefer early returns), and signatures under 4 parameters.
 - Use meaningful names and named constants/enums (no magic numbers or strings).
 - Design self-describing APIs, structured schemas, and human-/machine-readable contracts.
-- Comment only where non-obvious rationale is required, not what the code already says.
+- Comment only where non-obvious rationale is required, not what the code already says. Comments should explain "why" not "what". CODE SHOULD BE SELF-DESCRIBING.
+
 
 ### Reliability & Security
 - Never hardcode, commit, or log secrets, credentials, tokens, or sensitive user data.
@@ -30,11 +31,13 @@ minimizing the diff, following the project's own architecture and conventions.
 - Review code against five core dimensions: correctness (boundaries, errors, race conditions), readability (depth <= 2, functions <= 50 lines), architecture (SOLID, KISS), security, and performance.
 - Review tests first; address root causes over symptoms (fix shared logic once).
 - Categorize findings clearly (Critical, Important, Suggestion) and provide concrete, actionable fixes.
+- Maximum 2 levels of nesting; prefer early returns to flatten control flow.
 
 ## Definition of Done
-- Builds cleanly and all tests pass without errors or warnings.
+- Lint, types, and the framework build are clean.
+- Tests are added or run only when the user asks, and they pass when run.
 - No debug code, dead code, unused imports, or temporary files left behind.
-- Changes are minimal, focused, covered by tests, and easy to review.
+- Changes are minimal, focused, and easy to review.
 
 ## Agent Memory
 - Read `AgentSkills/memory/index.md` at the start of every task (create if missing); load only relevant domain lessons.

package/templates/dotnet/AgentSkills/skills/dotnet-standards/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: dotnet-standards
+description: >
+  Load on every C# or .NET change. AI agents use this when writing, reviewing,
+  refactoring, or optimizing C# for standards and implementation: project
+  conventions, CQRS, EF Core, DI lifetimes, async, logging, validation, and maintainability.
+compatibility: Requires the .NET SDK declared by the repository (Directory.Build.props, default net10.0). Build with dotnet build.
+---
+
+# C# and .NET Standards
+
+AI agents load this file on every C# or .NET edit, with shared principles and standards. Apply these rules while writing.
+
+## Repository Defaults & Structure
+- Follow target framework and language versions in `Directory.Build.props` (default `net10.0`, `LangVersion` `latest`).
+- Add XML documentation comments for public and shared API surfaces.
+- Organize code by feature or domain slices. Place controllers, handlers, validators, repositories, and DTOs in that slice.
+- Prefer clear, direct code over speculative patterns (YAGNI).
+
+## CQRS & Architecture
+- **Commands**: Mutate state. Return void, an identifier, or a minimal result.
+- **Queries**: Read state only.
+- **Thin endpoints**: Validate transport concerns and dispatch to a handler.
+- **Domain logic**: Keep rules in domain entities or domain services.
+- **Immutability**: Use `record` for commands, queries, and DTOs. Mark classes `sealed` unless inheritance is designed.
+- **Interfaces**: Define an interface for a boundary that needs a test double, more than one implementation, or an out-of-process call.
+
+## Dependency Injection & Lifetimes
+- Use constructor injection or a primary constructor for required dependencies.
+- Register the narrowest lifetime: `Singleton` for stateless thread-safe services, `Scoped` for a request and for `DbContext`, `Transient` for a lightweight stateless operation.
+- Do not resolve services from `IServiceProvider`, and do not add static global state.
+
+## Async & I/O
+- Use `async`/`await` for I/O, database, network, and file work.
+- Do not block with `.Result`, `.Wait()`, or `.GetAwaiter().GetResult()`.
+- Accept and pass `CancellationToken` through handlers, EF Core, and outbound HTTP.
+- `async void` only for a top-level event handler.
+
+## EF Core & Data Access
+- Avoid N+1 queries with a projection, `.Include()`, or a separate query.
+- Use `.AsNoTracking()` for a read-only query.
+- Select the columns the caller needs. Do not load a full tracked entity for a DTO.
+- Paginate, filter, and sort on the server.
+- Prefer `AnyAsync()` to test existence. Use `ExecuteUpdateAsync` and `ExecuteDeleteAsync` for bulk changes.
+
+## Logging, HTTP, validation
+- Log with a message template and named properties. Do not log secrets, passwords, connection strings, or PII.
+- Propagate the correlation id. Do not log inside a tight loop.
+- Use `IHttpClientFactory`, an explicit timeout, and the caller's `CancellationToken`. Retry transient failures with a bounded backoff.
+- Validate inbound payloads with FluentValidation or data annotations. Do not concatenate user input into SQL, a shell command, or a file path.
+
+## Review Checklist
+- [ ] Read-only EF Core queries use `.AsNoTracking()`. No N+1 queries.
+- [ ] Callers receive a DTO projection, not a tracked entity graph.
+- [ ] Async methods take a `CancellationToken` and do not block.
+- [ ] `DbContext` is `Scoped`.
+- [ ] Logs are structured and contain no secrets.
+- [ ] Input is validated at the boundary.
+- [ ] `dotnet build` is clean.
+
+## Verify
+After C# edits, run the framework build and fix what it reports:
+
+```bash
+dotnet build
+```
+
+Add or run tests only when the user asks. Then load `csharp-xunit` and run `dotnet test`.

package/templates/dotnet/AgentSkills/skills/index.md

@@ -0,0 +1,14 @@
+# Skills Index
+
+Consult this index to load only the skills relevant to the current task.
+
+| Skill | Path | Description / When to Load |
+| --- | --- | --- |
+| principles | AgentSkills/skills/principles/SKILL.md | Foundational simplicity ladder, KISS, YAGNI, surgical changes |
+| standards | AgentSkills/skills/standards/SKILL.md | Code quality, 50-line limits, shallow nesting, clean signatures |
+| security | AgentSkills/skills/security/SKILL.md | Input validation, secrets handling, safe queries, least privilege |
+| review | AgentSkills/skills/review/SKILL.md | Code review framework, five review dimensions, verification rules |
+| dotnet-standards | AgentSkills/skills/dotnet-standards/SKILL.md | Load on every C# or .NET change. CQRS, EF Core, DI, async, logging |
+| dotnet-api | AgentSkills/skills/dotnet-api/SKILL.md | RESTful API design, HTTP methods, pagination, OpenAPI/Swagger |
+| csharp-xunit | AgentSkills/skills/csharp-xunit/SKILL.md | xUnit testing, AAA pattern, Facts vs Theories, mocking, assertions |
+| performance | AgentSkills/skills/performance/SKILL.md | Span/ReadOnlySpan, ValueTask, EF Core query tuning, memory pooling |

package/templates/python/AgentSkills/agents/architect.md

@@ -0,0 +1,13 @@
+---
+name: architect
+description: Python architectural design, Clean Architecture, module boundaries, and pyproject.toml packaging.
+---
+
+# Python Architect
+
+## Architectural Principles
+- **Layered Separation**: Enforce clean boundaries across `domain` (entities, value objects), `application` (use cases, services), `infrastructure` (DB, HTTP, queue adapters), and `api` (FastAPI/Flask routes or CLI entry points).
+- **Dependency Direction**: Outer layers depend on inner layers; never let `domain` import from `infrastructure`.
+- **Contract-First Design**: Define `pydantic` schemas and typed interfaces before implementation. Treat data shapes as the primary design artifact.
+- **Packaging**: Structure projects with `pyproject.toml` (`[project]`, `[build-system]`, `[tool.mypy]`, `[tool.ruff]`). Use namespace packages only when cross-team sharing genuinely requires it.
+- **Genuine Reusability**: Extract shared utilities only when the same logic is needed across at least two distinct domains. Avoid premature abstraction (YAGNI).

package/templates/python/AgentSkills/agents/developer.md

@@ -0,0 +1,23 @@
+---
+name: developer
+description: Python feature implementation, async I/O, strict static typing, and uv project management.
+---
+
+# Python Developer
+
+## Implementation Principles
+- **PEP Naming**: `snake_case` for functions, variables, and modules; `PascalCase` for classes; `UPPER_SNAKE_CASE` for constants; `_prefixed` for private members.
+- **Static Typing**: Annotate every function signature and class attribute. Enable `from __future__ import annotations` at the top of every module.
+- **Pydantic Models**: Use `pydantic.BaseModel` for all data contracts, API request/response bodies, and configuration objects. Never use untyped dicts as data boundaries.
+- **Complexity Limits**: Keep functions under 50 lines; maximum 2 levels of nesting; prefer early returns to flatten control flow.
+- **No Magic Literals**: Replace all magic numbers and strings with named constants or `enum.Enum` members.
+
+## Project & Dependency Management
+- Use `uv` for all project operations: `uv init`, `uv add`, `uv run`, `uv sync`.
+- Declare all dependencies in `pyproject.toml`; never mutate the global environment with bare `pip install`.
+- Pin direct dependencies; let `uv.lock` track the full resolved set.
+
+## Async & I/O
+- Use `async`/`await` for all I/O, network, and database operations.
+- Propagate cancellation via `asyncio.CancelledError`; never swallow it silently.
+- Use `asyncio.gather` or task groups (`asyncio.TaskGroup`) for concurrent work; avoid blocking calls on the event loop.

package/templates/python/AgentSkills/skills/index.md

@@ -0,0 +1,13 @@
+# Skills Index
+
+Consult this index to load only the skills relevant to the current task.
+
+| Skill | Path | Description / When to Load |
+| --- | --- | --- |
+| principles | AgentSkills/skills/principles/SKILL.md | Foundational simplicity ladder, KISS, YAGNI, surgical changes |
+| standards | AgentSkills/skills/standards/SKILL.md | Code quality, 50-line limits, shallow nesting, clean signatures |
+| security | AgentSkills/skills/security/SKILL.md | Input validation, secrets handling, safe queries, least privilege |
+| review | AgentSkills/skills/review/SKILL.md | Code review framework, five review dimensions, verification rules |
+| python-standards | AgentSkills/skills/python-standards/SKILL.md | Load on every Python change. PEP 8, typing, uv, ruff, async, logging |
+| testing | AgentSkills/skills/testing/SKILL.md | pytest, pytest-asyncio, hypothesis property testing, fixtures, mocks |
+| performance | AgentSkills/skills/performance/SKILL.md | cProfile/memray, generators, asyncio concurrency, connection pooling |

package/templates/python/AgentSkills/skills/performance/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: performance
+description: Python profiling, generator patterns, async concurrency, and memory optimization.
+---
+
+# Python Performance
+
+## Profiling First
+- Measure before optimizing: use `cProfile`/`profile` for CPU and `memray` or `tracemalloc` for memory.
+- Profile realistic workloads, not microbenchmarks, to find true hot paths.
+
+## Memory Efficiency
+- Prefer generators and iterators (`yield`) over materializing full lists in memory for large data sets.
+- Use `__slots__` on classes with many instances to eliminate per-instance `__dict__` overhead.
+- Use `functools.lru_cache` or `functools.cache` for pure, referentially transparent functions called repeatedly with the same arguments.
+
+## Async Concurrency
+- Use `asyncio.gather(*tasks)` or `asyncio.TaskGroup` for I/O-bound fan-out; avoid sequential `await` in a loop when tasks are independent.
+- Use connection pools (e.g. `asyncpg` pool, `httpx.AsyncClient`) — never create a new connection per request.
+- Offload CPU-bound work to a `ProcessPoolExecutor` via `loop.run_in_executor`; do not block the event loop.
+
+## Data & Algorithm Choices
+- Use built-in types (`list`, `dict`, `set`) over third-party equivalents for simple cases; they are implemented in C.
+- Use `collections.deque` for queue workloads; avoid `list.pop(0)` (O(n)).
+- Avoid repeated string concatenation in loops; use `"".join(parts)` instead.
+- Prefer comprehensions over `map`/`filter` with lambdas for readability and slight speed advantages.

package/templates/python/AgentSkills/skills/python-standards/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: python-standards
+description: >
+  Load on every Python change. AI agents use this when writing, reviewing,
+  refactoring, or optimizing Python for standards, typing, and implementation:
+  PEP 8, uv, ruff, mypy or pyright, pydantic, Protocol, TypeVar, Literal,
+  TypedDict, async I/O, errors, logging, and maintainability.
+compatibility: Requires Python 3.11+ and uv. Lint and types use ruff and mypy, or pyright when the project already uses it. pydantic for models that cross a boundary.
+---
+
+# Python Standards
+
+AI agents load this file on every Python edit, with shared principles and standards. Apply these rules while writing.
+
+## Naming (PEP 8)
+- Modules, packages, functions, variables: `snake_case`
+- Classes: `PascalCase`. Constants: `UPPER_SNAKE_CASE`. Non-public: `_prefix`
+- Use dunder names only for language protocols
+
+## Project
+- Manage the project with `uv` (`uv add`, `uv sync`, `uv run`). Do not `pip install` into the global environment.
+- Put project metadata and tool config in `pyproject.toml`. Commit `uv.lock`.
+
+## Types
+- First statement of every module: `from __future__ import annotations`
+- Annotate every parameter, return, and class attribute. Write `-> None` when a function returns nothing.
+- Do not use `Any`. Use `object`, a bounded `TypeVar`, or `Literal` for a closed set of values.
+- Prefer `Protocol` for injectable behavior. Use `type` aliases on 3.12+, otherwise `TypeAlias`.
+- `TypedDict` for an external dict shape. `pydantic.BaseModel` for data that crosses a layer. `ConfigDict(frozen=True)` for value objects.
+- Validate at the outer boundary (API, CLI, queue), then pass models inward.
+- Enable strict checking. Minimum ruff selection is `E`, `F`, `I`, `UP`, `ANN`.
+
+```toml
+[tool.mypy]
+strict = true
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "ANN"]
+```
+
+If the repository already uses pyright, keep pyright on strict mode instead of adding mypy.
+
+## Async, errors, logging
+- Use `async`/`await` for I/O. Inside `async def`, do not call `time.sleep`, sync `open`, or a sync client.
+- Run independent tasks in `asyncio.TaskGroup`. Re-raise `asyncio.CancelledError`.
+- Domain errors subclass one project base. Catch the narrowest type. Do not use a bare `except`.
+- Use `contextlib.suppress` only for an error the caller intends to ignore.
+- Log with `structlog` or JSON `logging`. No `print` on a production path.
+- Bind request and user ids on the request logger. Never log secrets, tokens, or PII.
+
+## Review Checklist
+- [ ] Names follow PEP 8.
+- [ ] `uv` manages dependencies. `pyproject.toml` and `uv.lock` are current.
+- [ ] Every signature is annotated. No unexplained `Any`.
+- [ ] Boundary data is a pydantic model. External dicts use `TypedDict`.
+- [ ] Async functions do no blocking I/O. `CancelledError` is re-raised.
+- [ ] Exceptions are narrow. Logs are structured and contain no secrets.
+- [ ] `ruff` and the type checker are clean.
+
+## Verify
+After Python edits, run lint, types, and the framework build. Fix what they report:
+
+```bash
+uv run ruff check
+uv run ruff format --check
+uv run mypy
+uv build
+```
+
+Use `uv run pyright` instead of mypy when that is the repository checker. When `pyproject.toml` has no build backend, run `uv run python -m compileall` on the source tree instead of `uv build`.
+
+Add or run tests only when the user asks. Then load the `testing` skill and run `uv run pytest`.

package/templates/python/AgentSkills/skills/testing/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: testing
+description: Python unit, async, and property-based testing with pytest, pytest-asyncio, and hypothesis.
+---
+
+# Python Testing
+
+## Testing Principles
+- Test observable behavior and public interfaces, not internal implementation details.
+- Follow the **Arrange-Act-Assert (AAA)** pattern in every test.
+- Keep tests isolated, deterministic, and independent of execution order or external state.
+
+## Project Setup
+- Use `pytest` as the sole test runner; install via `uv add --dev pytest pytest-asyncio pytest-mock hypothesis`.
+- Configure in `pyproject.toml`:
+  ```toml
+  [tool.pytest.ini_options]
+  asyncio_mode = "auto"
+  ```
+- Run tests with `uv run pytest`.
+
+## Test Naming & Structure
+- Name test files `test_<module>.py` and place them under a top-level `tests/` directory mirroring the `src/` layout.
+- Name test functions: `test_<function>_<scenario>_<expected>` (e.g., `test_create_user_duplicate_email_raises_conflict`).
+- Match test class names to the class under test: `TestUserService` for `UserService`.
+
+## Fixtures & Parametrize
+- Use `@pytest.fixture` for shared setup; prefer function-scoped fixtures unless sharing is explicitly required.
+- Use `@pytest.mark.parametrize` for data-driven cases covering multiple inputs and edge cases.
+- Mock external I/O boundaries (HTTP, DB, file system) using `pytest-mock` (`mocker.patch`) — never hit real services in unit tests.
+
+## Async Testing
+- Annotate async test functions with `async def`; `asyncio_mode = "auto"` removes the need for `@pytest.mark.asyncio`.
+- Use `AsyncMock` from `unittest.mock` to mock async callables and coroutines.
+
+## Property-Based Testing
+- Use `hypothesis` for algorithmic and data-parsing logic where exhaustive edge-case enumeration is impractical.
+- Define `@given(st.text(), st.integers())` strategies; always run with a fixed `settings(max_examples=200)` in CI.
+
+## Coverage & Quality
+- Target 100% coverage on domain and application layers; exclude infrastructure adapters only with justification.
+- Run `uv run pytest --cov=src --cov-report=term-missing` in CI.

package/templates/react/AgentSkills/skills/index.md

@@ -0,0 +1,13 @@
+# Skills Index
+
+Consult this index to load only the skills relevant to the current task.
+
+| Skill | Path | Description / When to Load |
+| --- | --- | --- |
+| principles | AgentSkills/skills/principles/SKILL.md | Foundational simplicity ladder, KISS, YAGNI, surgical changes |
+| standards | AgentSkills/skills/standards/SKILL.md | Code quality, 50-line limits, shallow nesting, clean signatures |
+| security | AgentSkills/skills/security/SKILL.md | Input validation, secrets handling, safe queries, least privilege |
+| review | AgentSkills/skills/review/SKILL.md | Code review framework, five review dimensions, verification rules |
+| react-typescript | AgentSkills/skills/react-typescript/SKILL.md | Load on every React, TypeScript, or JavaScript change. Strict types, props, hooks |
+| testing | AgentSkills/skills/testing/SKILL.md | Vitest & React Testing Library, user-event, test coverage |
+| performance | AgentSkills/skills/performance/SKILL.md | Render optimization, lazy loading, state colocation, memoization |

package/templates/react/AgentSkills/skills/react-typescript/SKILL.md

@@ -1,22 +1,44 @@
 ---
 name: react-typescript
-description: React & TypeScript component typing, custom hook design, and type-safe state modeling.
+description: >
+  Load on every React, TypeScript, or JavaScript change. AI agents use this
+  when writing, reviewing, or refactoring React, TypeScript, and JavaScript:
+  strict types, component props, discriminated unions, custom hooks, and forms.
+compatibility: Requires TypeScript with strict enabled and React 18 or newer. Typecheck with tsc --noEmit and lint with the project's ESLint.
 ---
 
-# React & TypeScript Guidance
+# React and TypeScript Standards
 
-## Type Design & Component Contracts
-- Define strict prop interfaces; avoid `any` or loose `Record<string, unknown>`.
-- Use discriminated unions for distinct component states (e.g., `{ status: 'loading' } | { status: 'success'; data: T } | { status: 'error'; error: Error }`).
-- Explicitly type event handlers and custom hook return values (use `as const` for tuple returns).
+AI agents load this file on every React, TypeScript, or JavaScript edit, with shared principles and standards. Apply these rules while writing.
 
-## Custom Hook Guidelines
-- Encapsulate reusable stateful logic into focused custom hooks prefixed with `use`.
-- Keep hook parameter signatures clean (maximum 4 arguments; use options objects for complex configurations).
-- Pass `AbortSignal` to asynchronous functions initiated inside hooks for safe cancellation.
-- Return only stable handlers, derived state, and minimal state setters required by callers.
+## TypeScript
+- Keep `strict` enabled. Do not use `any`. Use `unknown` and narrow it.
+- Export the props type and the return type of every public component and hook.
 
-## Form & Input Patterns
-- Prefer controlled inputs for dynamic form validation; use native form actions where appropriate.
-- Bind labels to inputs using `htmlFor` and `id` generated via `useId` for SSR safety.
-- Handle disabled, aria-invalid, and error message associations (`aria-describedby`) for robust UX.
+## Component Contracts
+- Type props with an interface or type alias. Avoid a loose `Record<string, unknown>`.
+- Model states that differ in shape as a discriminated union (`{ status: "loading" } | { status: "success"; data: T } | { status: "error"; error: Error }`).
+- Type event handlers. For a hook tuple return, use `as const`.
+
+## Custom Hooks
+- Put reusable state in a hook named `useSomething`.
+- Keep the parameter list to four. Pass an options object past that.
+- Pass an `AbortSignal` into async work started by the hook.
+- Return stable handlers, derived state, and only the setters the caller needs.
+
+## Forms
+- Use a controlled input when validation is dynamic. Use a native form action when the platform covers it.
+- Bind each label with `htmlFor` and an `id` from `useId`.
+- Wire `aria-invalid` and `aria-describedby` to the error message.
+
+## Review Checklist
+- [ ] `strict` is on. New code has no `any`.
+- [ ] States with different shapes use a discriminated union.
+- [ ] Hooks start with `use`, stay within four parameters, and return stable values.
+- [ ] Async work in a hook accepts an `AbortSignal`.
+- [ ] Inputs have labels, and errors are referenced with `aria-describedby`.
+
+## Verify
+After TypeScript, JavaScript, or React edits, run the project's typecheck, ESLint, and framework build. Fix what they report.
+
+Add or run tests only when the user asks. Then load the `testing` skill and run the project's test script.

package/templates/rust/AgentSkills/agents/architect.md

@@ -0,0 +1,14 @@
+---
+name: architect
+description: Rust workspace design, crate boundaries, trait-based API design, and visibility rules.
+---
+
+# Rust Architect
+
+## Architectural Principles
+- **Workspace Layout**: Use a Cargo workspace (`[workspace]` in root `Cargo.toml`) to separate concerns: e.g. `crates/domain`, `crates/api`, `crates/infra`, `crates/cli`. Each crate has one responsibility.
+- **Visibility Minimization**: Default to `pub(crate)` for intra-workspace sharing; expose items as `pub` only when they form the deliberate public API of the crate.
+- **Trait-Based Design**: Define behavior through traits; depend on trait abstractions (not concrete types) at crate boundaries to enable testing and future substitution without coupling.
+- **Contract-First**: Define data types (`struct`, `enum`) and trait interfaces before implementing business logic. Types are the primary design artifact.
+- **Dependency Direction**: Application crates depend on domain crates; infrastructure crates depend on application traits; no domain crate imports from infrastructure.
+- **Genuine Reusability**: Extract shared code into a library crate only when two or more crates genuinely share the same logic. Avoid premature abstraction (YAGNI).

package/templates/rust/AgentSkills/agents/developer.md

@@ -0,0 +1,24 @@
+---
+name: developer
+description: Rust feature implementation, ownership, async with tokio, and idiomatic error propagation.
+---
+
+# Rust Developer
+
+## Implementation Principles
+- **Ownership First**: Design types and function signatures to express ownership intent clearly. Prefer borrowing (`&T`, `&mut T`) over cloning in hot paths; clone only when ownership transfer is genuinely required.
+- **Idiomatic Error Handling**: Use `Result<T, E>` and propagate errors with `?`. Never `unwrap()` or `expect()` in production code paths — reserve them for tests and infallible cases with a comment explaining why.
+- **Zero-Cost Abstractions**: Prefer traits over dynamic dispatch (`Box<dyn Trait>`) unless runtime polymorphism is a firm requirement. Use generics for static dispatch.
+- **Complexity Limits**: Keep functions under 50 lines; maximum 2 levels of nesting; use early `return` or `?` to flatten control flow.
+- **No Magic Literals**: Replace all magic numbers and strings with named constants (`const`) or `enum` variants.
+
+## Tooling Discipline
+- Format every file with `rustfmt` before committing (`cargo fmt`).
+- Fix all `clippy` warnings before committing (`cargo clippy -- -D warnings`).
+- Use `cargo check` as the fast feedback loop during development.
+
+## Async & Concurrency
+- Use `tokio` as the async runtime for all I/O-bound work.
+- Annotate async entry points and test functions with `#[tokio::main]` and `#[tokio::test]`.
+- Use `tokio::spawn` for independent concurrent tasks; use `tokio::join!` or `tokio::try_join!` to await multiple tasks.
+- Protect shared mutable state with `Arc<Mutex<T>>` or `Arc<RwLock<T>>`; prefer message-passing (`tokio::sync::mpsc`) over shared state where possible.

package/templates/rust/AgentSkills/skills/index.md

@@ -0,0 +1,13 @@
+# Skills Index
+
+Consult this index to load only the skills relevant to the current task.
+
+| Skill | Path | Description / When to Load |
+| --- | --- | --- |
+| principles | AgentSkills/skills/principles/SKILL.md | Foundational simplicity ladder, KISS, YAGNI, surgical changes |
+| standards | AgentSkills/skills/standards/SKILL.md | Code quality, 50-line limits, shallow nesting, clean signatures |
+| security | AgentSkills/skills/security/SKILL.md | Input validation, secrets handling, safe queries, least privilege |
+| review | AgentSkills/skills/review/SKILL.md | Code review framework, five review dimensions, verification rules |
+| rust-standards | AgentSkills/skills/rust-standards/SKILL.md | Load on every Rust change. Ownership, clippy, thiserror, tracing |
+| testing | AgentSkills/skills/testing/SKILL.md | cargo test, tokio::test, proptest property testing, mockall |
+| performance | AgentSkills/skills/performance/SKILL.md | criterion benchmarking, zero-copy parsing, allocation reduction |

package/templates/rust/AgentSkills/skills/performance/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: performance
+description: Rust benchmarking with criterion, zero-copy design, allocation reduction, and async task efficiency.
+---
+
+# Rust Performance
+
+## Measure First
+- Profile before optimizing: use `criterion` for micro-benchmarks and `cargo flamegraph` (or `perf`) for real workload profiling.
+- Compile with `--release` for all performance measurements; debug builds have no optimizations.
+
+## Allocation & Copy Reduction
+- Prefer borrowing (`&str`, `&[T]`) over owned types (`String`, `Vec<T>`) in hot paths; clone only when ownership transfer is necessary.
+- Use `Cow<'_, str>` to defer allocation until a mutation is actually needed.
+- Use `SmallVec` or fixed-size arrays for collections that are almost always small.
+- Avoid boxing (`Box<T>`) in hot paths; prefer stack allocation for small, fixed-size types.
+
+## Zero-Copy Parsing
+- Use `bytes::Bytes` and slicing for zero-copy network data parsing.
+- Avoid intermediate `String` allocations when parsing structured data; work with `&[u8]` slices directly where possible.
+
+## Async Task Efficiency
+- Minimize the number of `tokio::spawn` calls; spawning is cheap but not free — batch work where possible.
+- Avoid holding `Mutex` guards across `.await` points; release before yielding.
+- Use `tokio::sync::watch` or `tokio::sync::broadcast` for fan-out notifications instead of multiple `Mutex`-protected `Vec` callbacks.
+
+## Iterator Pipelines
+- Use lazy iterator adapters (`map`, `filter`, `flat_map`) over imperative loops; the compiler optimizes chains to a single pass.
+- Prefer `collect::<Vec<_>>()` once at the end of a pipeline rather than intermediate materialization.
+- Use `par_iter()` from `rayon` for CPU-bound parallel data processing — only after profiling confirms a bottleneck.
+
+## Benchmarking
+```rust
+use criterion::{criterion_group, criterion_main, Criterion};
+
+fn bench_parse(c: &mut Criterion) {
+    c.bench_function("parse_record", |b| b.iter(|| parse(INPUT)));
+}
+
+criterion_group!(benches, bench_parse);
+criterion_main!(benches);
+```
+Run with `cargo bench`.

package/templates/rust/AgentSkills/skills/rust-standards/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: rust-standards
+description: >
+  Load on every Rust change. AI agents use this when writing, reviewing,
+  refactoring, or optimizing Rust for standards, ownership, and implementation:
+  API naming, rustfmt, clippy, thiserror, anyhow, tracing, Cargo layout,
+  borrowing, lifetimes, Arc/Mutex, and Send + Sync.
+compatibility: Requires a stable Rust toolchain and Cargo. Format and lint use rustfmt and clippy. thiserror for library errors, anyhow for applications, tracing for logs.
+---
+
+# Rust Standards
+
+AI agents load this file on every Rust edit, with shared principles and standards. Apply these rules while writing.
+
+## Naming
+- Types and traits: `PascalCase`. Functions, methods, variables, modules: `snake_case`.
+- Constants and statics: `UPPER_SNAKE_CASE`. Lifetimes: a short lowercase name (`'a`).
+- Library crate names: `snake_case`. Package names in `Cargo.toml`: `kebab-case`.
+- Document public items with `///`.
+
+## Ownership
+- One owner at a time. Many shared borrows (`&T`) or one mutable borrow (`&mut T`), never both.
+- Add a lifetime only when elision cannot see it. Prefer owned `String` and `Vec` in public APIs.
+- `Arc<Mutex<T>>` for shared mutable state. `Arc<RwLock<T>>` when reads dominate. Drop the guard before `.await`.
+- Prefer a channel when the work is producer and consumer. No `Rc` or `Cell` across threads.
+- Do not `clone()` to silence the borrow checker. Restructure the ownership.
+
+## Errors, logging, dependencies
+- Libraries: `thiserror`. Applications: `anyhow` with `context`.
+- No `unwrap()` or `expect()` on a production path. Return `Result` and use `?`. Reserve `panic!` for a programmer bug.
+- Log with `tracing`. Attach fields with `#[tracing::instrument]`. No `println!` in production. Never log secrets.
+- Add a crate only when the standard library does not cover the job. Dev-only crates go in `[dev-dependencies]`.
+- Set `default-features = false` when the crate supports it.
+
+## Review Checklist
+- [ ] `cargo fmt --check` and `cargo clippy -- -D warnings` are clean.
+- [ ] No `unwrap()`, `expect()`, or borrow-checker `clone()` in production code.
+- [ ] Lifetimes appear only where elision fails. Guards drop before `.await`.
+- [ ] Library errors use `thiserror`. Application errors use `anyhow`.
+- [ ] `tracing` is used. Logs contain no secrets. Public items have `///` docs.
+- [ ] `cargo audit` reports no known vulnerabilities.
+
+## Verify
+After Rust edits, run format, clippy, and the framework build. Fix what they report:
+
+```bash
+cargo fmt --check
+cargo clippy -- -D warnings
+cargo build
+```
+
+Add or run tests only when the user asks. Then load the `testing` skill and run `cargo test`.

package/templates/rust/AgentSkills/skills/testing/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: testing
+description: Rust unit, async, integration, and property-based testing with cargo test, tokio::test, and proptest.
+---
+
+# Rust Testing
+
+## Testing Principles
+- Test observable behavior through public interfaces, not internal implementation details.
+- Follow the **Arrange-Act-Assert (AAA)** pattern in every test.
+- Keep tests isolated, deterministic, and independent of execution order or external state.
+
+## Unit Tests
+- Place unit tests in the same file as the code under test inside a `#[cfg(test)]` module:
+  ```rust
+  #[cfg(test)]
+  mod tests {
+      use super::*;
+
+      #[test]
+      fn create_user_valid_input_returns_ok() {
+          // Arrange / Act / Assert
+      }
+  }
+  ```
+- Use descriptive names: `fn <function>_<scenario>_<expected>`.
+
+## Async Tests
+- Use `#[tokio::test]` for async test functions:
+  ```rust
+  #[tokio::test]
+  async fn fetch_user_not_found_returns_error() { ... }
+  ```
+- Mock async I/O boundaries with `mockall` (`#[automock]`) — never hit real services in unit tests.
+
+## Integration Tests
+- Place integration tests in the top-level `tests/` directory; each file is a separate test binary.
+- Use `common/mod.rs` (or `common.rs`) under `tests/` for shared test helpers and fixtures.
+- Run with `cargo test --test <name>`.
+
+## Property-Based Testing
+- Use `proptest` for algorithmic and parsing logic where exhaustive edge-case enumeration is impractical.
+  ```rust
+  proptest! {
+      #[test]
+      fn parse_roundtrip(s in "\\PC*") { ... }
+  }
+  ```
+
+## Mocking
+- Use `mockall` to generate mocks for traits: annotate the trait with `#[automock]` and import `MockMyTrait` in tests.
+- Verify expectations explicitly with `.expect(n)` or `.times(n)` on mock methods.
+
+## Running Tests
+```bash
+cargo test                    # all tests
+cargo test --lib              # unit tests only
+cargo test --test integration  # integration tests only
+cargo test -- --nocapture     # show stdout during tests
+```

package/templates/shared/AgentSkills/OPERATING.md

@@ -2,14 +2,14 @@
 
 ## Workflow
 1. **Memory & Context**: Read `AgentSkills/memory/index.md` (create if missing); load only relevant domain lessons to avoid repeating past mistakes.
-2. **Role & Skill Discovery**: Load relevant role guidance from `AgentSkills/agents/` (`architect.md`, `reviewer.md`, `developer.md`) and skills from `AgentSkills/skills/` (including `AgentSkills/skills/review/SKILL.md`).
+2. **Role & Skill Discovery**: Consult `AgentSkills/skills/index.md` to identify and load task-specific skills from `AgentSkills/skills/` (including `AgentSkills/skills/review/SKILL.md`). Load relevant role guidance from `AgentSkills/agents/` (`architect.md`, `reviewer.md`, `developer.md`).
 3. **Pre-flight Inspection**: Inspect current codebase patterns, dependencies, and baseline build/test state.
 4. **Surgical Implementation**: Apply the minimal change required; adhere strictly to DRY, KISS, and YAGNI.
-5. **Verification**: Run the project's build and test commands (e.g. `npm test`, `dotnet test`, or project test suite) to verify happy paths and edge cases per `AgentSkills/skills/review/SKILL.md`.
+5. **Verification**: Run the language skill's lint, type feedback, and framework build, and fix what they report. Add or run tests only when the user asks. Follow `AgentSkills/skills/review/SKILL.md`.
 6. **Learning Loop**: If a mistake was made and corrected or a durable rule discovered, record a concise lesson in `AgentSkills/memory/lessons/<domain>.md` and update `index.md`.
 
 ## Completion Checklist
-- [ ] Project builds cleanly with zero errors or warnings.
-- [ ] Automated tests pass and cover failure paths and edge cases.
+- [ ] Lint, types, and the framework build are clean.
+- [ ] Tests were added or run only because the user asked. They pass when run.
 - [ ] No dead code, debug logging, unused imports, or temporary files remain.
 - [ ] Relevant documentation or memory lessons updated if applicable.

package/templates/shared/AgentSkills/agents/reviewer.md

@@ -14,10 +14,9 @@ Universal review guidance for AI agents and human reviewers across all stacks. S
 - **Review**: Adhere strictly to `AgentSkills/skills/review/SKILL.md`.
 
 ## Verification & Automated Checks
-- [ ] **Clean Build**
-- [ ] **Zero Lint Errors**
-- [ ] **Tests Pass**
-- [ ] **Test Robustness**
+- [ ] **Lint, types, and framework build**
+- [ ] **Tests** added or run only when the user asks
+- [ ] **Test Robustness** when the user asked for tests
 
 ## Standards & Skill Compliance
 - [ ] **Principles**: `AgentSkills/skills/principles/SKILL.md`

package/templates/shared/AgentSkills/skills/index.md

@@ -0,0 +1,10 @@
+# Skills Index
+
+Consult this index to load only the skills relevant to the current task.
+
+| Skill | Path | Description / When to Load |
+| --- | --- | --- |
+| principles | AgentSkills/skills/principles/SKILL.md | Foundational simplicity ladder, KISS, YAGNI, surgical changes |
+| standards | AgentSkills/skills/standards/SKILL.md | Code quality, 50-line limits, shallow nesting, clean signatures |
+| security | AgentSkills/skills/security/SKILL.md | Input validation, secrets handling, safe queries, least privilege |
+| review | AgentSkills/skills/review/SKILL.md | Code review framework, five review dimensions, verification rules |

package/templates/shared/AgentSkills/skills/principles/SKILL.md

@@ -27,5 +27,5 @@ Bug fix = root cause, not symptom. A bug report names a symptom. Grep every call
 - **Think Before Coding**: Thoroughly understand requirements. If ambiguous, ask before guessing.
 - **Surgical Changes**: Make the smallest change that satisfies the request; touch only what is explicitly required.
 - **Simplicity First (KISS / YAGNI)**: Favor simple, clear, maintainable solutions over clever abstractions. Do not add unrequested features.
-- **Zero-Error Builds**: Every change must compile cleanly and pass existing and newly added tests.
+- **Build**: Run the language framework build and fix what it reports before finishing. Add or run tests only when the user asks.
 - **Standards, Security & Review**: Adhere strictly to `AgentSkills/skills/standards/SKILL.md`, `AgentSkills/skills/security/SKILL.md`, and `AgentSkills/skills/review/SKILL.md`.

package/templates/shared/AgentSkills/skills/review/SKILL.md

@@ -15,9 +15,8 @@ Universal review framework and verification standards for AI agents and human re
 5. **Performance**: Avoid N+1 queries, unbounded loops, blocking operations in async flows, and redundant re-computations.
 
 ## Verification & Automated Checks
-- [ ] **Clean Build**: Project builds cleanly with zero errors or warnings.
-- [ ] **Zero Lint Errors**: Code adheres to project formatting and static analysis rules.
-- [ ] **Tests Pass**: Run test suite; all existing and newly added tests must pass.
+- [ ] **Lint, types, and build**: Formatting, static checks, and the language framework build are clean.
+- [ ] **Tests**: Add or run tests only when the user asks. When run, they pass.
 - [ ] **Test Robustness**: Tests must cover failure paths, edge cases, and boundary conditions, not just happy paths.
 
 ## Review Output Format

package/templates/shared/AgentSkills/skills/standards/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: standards
-description: Core code quality, complexity limits, naming, and structural conventions.
+description: Core code quality, simplicity, complexity limits, naming, and structural conventions.
 ---
 
 # Code Standards
@@ -11,11 +11,20 @@ description: Core code quality, complexity limits, naming, and structural conven
 - **Clean Signatures**: Maximum 4 parameters per function; use an options object or record for complex signatures.
 
 ## Design & Clean Code
-- **SOLID / DRY / KISS**: Single-responsibility components; eliminate duplicated logic; prefer clear, direct implementations over speculative abstractions (YAGNI).
+- **Simplicity First (KISS / YAGNI)**: Favor simple, clear, maintainable solutions over clever abstractions. Do not add unrequested features.
+- **SOLID / DRY**: Single-responsibility components; eliminate duplicated logic; prefer clear, direct implementations over speculative abstractions (YAGNI).
+- **Less is more**: Avoid over-engineering; prefer fewer moving parts and simpler designs.
+- **Consistent Style**: Follow the repository's style guide; use linters and formatters to enforce consistency.
+- **Configuration & Defaults**: Provide sensible defaults and configuration options; avoid hardcoding values.
+- **separation of Concerns**: Keep business logic, data access, and presentation layers distinct; avoid mixing responsibilities.
+- **Modular Design**: Break down large components into smaller, reusable modules; prefer composition over inheritance.
+- **Dependency Management**: Minimize external dependencies; prefer standard libraries and well-maintained packages; avoid unnecessary bloat.
+- **self-Documenting Code**: Write code that is clear and understandable without excessive comments; use meaningful names and expressive constructs.
+- **security & Privacy**: Follow best practices for secure coding; validate inputs, sanitize outputs, and protect sensitive data.
 - **Naming & Clarity**: Use descriptive, domain-meaningful names for classes, functions, and variables.
 - **No Magic Literals**: Replace magic numbers and strings with named constants or enums.
 - **Contracts & Schemas**: Design explicit, human- and machine-readable data contracts, schemas, and self-describing APIs.
-- **Intentional Comments**: Comment only where non-obvious rationale is required, never restate what the code itself expresses.
+- **Intentional Comments**: Comment only where non-obvious rationale is required, never restate what the code itself expresses. Comments should explain "why" not "what". CODE SHOULD BE SELF-DESCRIBING.
 
 ## Concurrency & Safety
 - **Async Safety**: Use idiomatic non-blocking `async`/`await`; ensure operations are free of race conditions and deadlocks.

package/templates/shared/entry-points/instructions.md

@@ -3,7 +3,7 @@
 > Operating instructions and engineering guidelines for AI agents and human contributors.
 
 ## Operating Contract
-Always follow `AgentSkills/OPERATING.md` before making changes. Review relevant agent personas in `AgentSkills/agents/` (`architect.md`, `reviewer.md`, `developer.md`) and skills in `AgentSkills/skills/` (including `AgentSkills/skills/review/SKILL.md`).
+Always follow `AgentSkills/OPERATING.md` before making changes. Consult `AgentSkills/skills/index.md` to load task-relevant skills (including `AgentSkills/skills/review/SKILL.md`), and review relevant agent personas in `AgentSkills/agents/` (`architect.md`, `reviewer.md`, `developer.md`).
 
 ## Goal
 Implement requested changes with production-quality code, preserving existing behavior and
@@ -17,12 +17,13 @@ minimizing the diff, following the project's own architecture, standards, and co
 - **Think Before Coding**: Thoroughly understand requirements. If ambiguous, ask before guessing.
 - **Surgical Changes**: Make the smallest change that satisfies the request; touch only what is explicitly required.
 - **Simplicity First (KISS / YAGNI)**: Favor simple, clear, maintainable solutions over clever abstractions. Do not add unrequested features.
-- **Zero-Error Builds**: Every change must compile cleanly and pass existing and newly added tests.
+- **Build**: Run the language framework build and fix what it reports before finishing. Add or run tests only when the user asks.
 
 ## Definition of Done
-- Builds cleanly and all tests pass without errors or warnings.
+- Lint, types, and the framework build are clean.
+- Tests are added or run only when the user asks, and they pass when run.
 - No debug code, dead code, unused imports, or temporary files left behind.
-- Changes are minimal, focused, covered by tests, and easy to review.
+- Changes are minimal, focused, and easy to review.
 
 ## Agent & Contributor Memory
 - Read `AgentSkills/memory/index.md` at the start of every task (create if missing); load only relevant domain lessons.

package/templates/dotnet/AgentSkills/skills/dotnet-best-practices/SKILL.md

@@ -1,79 +0,0 @@
----
-name: dotnet-best-practices
-description: >
-  Load when writing, reviewing, refactoring, or optimizing .NET/C# code.
-  Covers project conventions, CQRS, EF Core, async, testing, performance,
-  logging, security, and maintainability.
----
-
-# .NET/C# Best Practices
-
-Use this skill to keep .NET/C# changes simple, maintainable, testable, and aligned with repository conventions.
-
-## Repository Defaults & Structure
-- Follow target framework and language versions in `Directory.Build.props` (default `net10.0`, `LangVersion` `latest`).
-- Add XML documentation comments for public/shared API surfaces.
-- Organize code by feature or domain slices; place controllers, handlers, validators, repositories, and DTOs predictably.
-- Prefer clear, direct code over complex or speculative patterns (YAGNI).
-
-## CQRS & Architecture
-- **Commands**: Mutate state; return void, an identifier, or a minimal result.
-- **Queries**: Read state only; never mutate data.
-- **Thin Endpoints**: Keep controllers and minimal API endpoints thin; validate transport concerns and dispatch via mediator handlers.
-- **Domain Logic**: Encapsulate domain rules in domain entities or domain services, never in transport handlers.
-- **Immutability**: Use `record` for commands, queries, and DTOs; mark classes `sealed` unless inheritance is intentionally designed.
-- **Interfaces**: Define interfaces for boundaries requiring testing, multiple implementations, or out-of-process integration.
-
-## Dependency Injection & Lifetimes
-- Use constructor injection or primary constructors for required dependencies.
-- Register services with the narrowest appropriate lifetime:
-  - `Singleton`: Stateless, thread-safe services.
-  - `Scoped`: Request-bound services and EF Core `DbContext`.
-  - `Transient`: Lightweight, stateless operations.
-- Avoid resolving services manually via `IServiceProvider` or introducing static global state.
-
-## Async & I/O
-- Use `async`/`await` for all I/O, database, network, and file operations.
-- Never block async code using `.Result`, `.Wait()`, or `.GetAwaiter().GetResult()`.
-- Accept and propagate `CancellationToken` through all handler, EF Core, and outbound HTTP calls.
-- Avoid `async void` except for top-level event handlers.
-
-## EF Core & Data Access
-- Avoid N+1 queries by using explicit projections, `.Include()`, or separate optimized queries.
-- Use `.AsNoTracking()` for all read-only queries.
-- Select only needed columns into DTOs instead of loading full tracked entities.
-- Implement server-side pagination, filtering, and sorting; never filter unbounded sets in memory.
-- Prefer `AnyAsync()` over `CountAsync()` when testing for existence.
-- Use `ExecuteUpdateAsync` and `ExecuteDeleteAsync` for bulk operations where appropriate.
-
-## Logging & Observability
-- Use structured logging with message templates and named properties (`LogInformation("Order {OrderId} processed", id)`).
-- Avoid logging inside tight loops or hot execution paths.
-- Propagate correlation/request IDs across service and HTTP boundaries.
-- Never log secrets, passwords, connection strings, or sensitive personal data (PII).
-
-## HTTP & Resilient Integration
-- Use `IHttpClientFactory` for outbound HTTP calls.
-- Set explicit timeouts and pass cancellation tokens to all HTTP calls.
-- Use bounded retries with exponential backoff for transient failures; avoid unbounded retry storms.
-- Batch outbound requests rather than making external calls inside tight loops.
-
-## Security & Validation
-- Validate all incoming request payloads using FluentValidation or Data Annotations.
-- Never concatenate raw user input into SQL queries, shell commands, or file paths.
-- Follow the principle of least privilege for database connections and external service credentials.
-
-## Testing Standards
-- Use xUnit for unit and integration testing.
-- Structure tests using Arrange-Act-Assert (AAA).
-- Test happy paths, edge cases, validation failures, and cancellation flows.
-- Keep tests isolated, deterministic, and idempotent.
-
-## Review Checklist
-- [ ] No N+1 queries; read-only EF Core queries use `.AsNoTracking()`.
-- [ ] DTO projections used; no full entity graphs exposed to callers.
-- [ ] Async methods propagate `CancellationToken` without blocking.
-- [ ] DI lifetimes correctly configured (`Scoped` for DbContext).
-- [ ] Structured logging used without leaking sensitive data or secrets.
-- [ ] Input validation applied at boundaries.
-- [ ] Tests pass and cover edge cases.