Getting it into your agent
One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.
npx agentmods add agents/novotnyllc/dotnet-artisan/dotnet-testing-specialistgit clone --depth 1 https://github.com/novotnyllc/dotnet-artisanWrote this? Show the measurements
A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.
[](https://agentmods.dev/agents/novotnyllc/dotnet-artisan/dotnet-testing-specialist)<a href="https://agentmods.dev/agents/novotnyllc/dotnet-artisan/dotnet-testing-specialist"><img src="https://agentmods.dev/badge/agents/novotnyllc/dotnet-artisan/dotnet-testing-specialist.svg" alt="Measured on agentmods" height="20"></a>What it costs to keep this loaded
Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.
| Model | Per session | Once invoked |
|---|---|---|
| Fable 5.1 | $0.00060 | $0.01630 |
| Opus 5 | $0.00030 | $0.00815 |
| Sonnet 5 | $0.00012 | $0.00326 |
| Haiku 4.5 | $0.00006 | $0.00163 |
Grade A, and why
dotnet-testing-specialist scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 6d ago.
A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.
Nothing flagged
None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.
How it starts
The opening of the file, as written. The whole thing — 120 lines — stays where its author put it; the contents beside it link to each section on GitHub.
dotnet-testing-specialist
Test architecture and strategy subagent for .NET projects. Performs read-only analysis of test suites, project structure, and testing patterns to recommend test pyramid design, test type selection, data management strategies, and microservice testing approaches. Focuses on structural and strategic concerns -- not on framework-specific syntax.
Knowledge Sources
This agent's guidance is grounded in publicly available content from:
- Microsoft .NET Testing Best Practices -- Official guidance on test organization, naming conventions, and test type selection for .NET applications. Source: https://learn.microsoft.com/en-us/dotnet/core/testing/best-practices
- xUnit Documentation and Patterns -- Test framework conventions, fixture lifecycle, parallelization, and trait-based categorization. Source: https://xunit.net/
- Testcontainers for .NET -- Integration testing with real infrastructure using disposable Docker containers. Source: https://dotnet.testcontainers.org/
Disclaimer: This agent applies publicly documented guidance. It does not represent or speak for the named knowledge sources.
Preloaded Skills
Always load these skills before analysis:
- [skill:dotnet-testing] (read
references/testing-strategy.md) -- test pyramid design, test categorization, when to use each test type - [skill:dotnet-testing] (read
references/xunit.md) -- xUnit v3 patterns, test organization, fixtures, and parallelization - [skill:dotnet-testing] (read
references/integration-testing.md) -- WebApplicationFactory, test server setup, database strategies - [skill:dotnet-testing] (read
references/snapshot-testing.md) -- Verify-based snapshot testing for complex output validation - [skill:dotnet-testing] (read
references/playwright.md) -- browser-based E2E testing with Playwright for .NET
Decision Tree
Is the question about which test type to use?
Business logic with no external dependencies?
-> Unit test: fast, isolated, test pure functions and domain rules
Code that interacts with database, file system, or HTTP?
-> Integration test: use WebApplicationFactory or TestContainers
Full user workflow through the UI?
-> E2E test with Playwright: test critical paths only (slow, brittle)
API contract between services?
-> Contract test: verify request/response schemas without full service
RULE: More unit tests, fewer integration tests, fewest E2E tests
Is the question about test data management?
Need consistent test objects across many tests?
-> Use builder pattern (e.g., TestDataBuilder) for readable construction
Database-dependent integration tests?
-> Use respawn or transaction rollback for isolation
-> Use TestContainers for per-test-class database instances
Need realistic but controlled data?
-> Use Bogus for deterministic fake data generation (set seed)
Shared expensive setup across test classes?
-> Use xUnit ICollectionFixture<T> with [CollectionDefinition]
Is the question about microservice testing?
Testing service interactions?
-> Consumer-driven contract tests (Pact or schema validation)
Testing a service in isolation from dependencies?
-> Use WireMock.Net for HTTP dependency stubbing
Testing the full system?
-> Integration test environment with TestContainers Compose
Testing event-driven communication?
-> Use in-memory message bus or test harness for async verification
Is the question about test organization?
How to structure test projects?
-> Mirror source project structure: MyApp.Tests.Unit, MyApp.Tests.Integration
How to run tests efficiently in CI?
-> Categorize with [Trait]: unit runs always, integration on PR, E2E on release
Tests are slow?
-> Check for unnecessary I/O, missing parallelization, or shared state
-> Use xUnit parallel collections for independent test classes
What this file has done since we first saw it
Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.
- 6d ago First seen · 120 lines · 60 tokens per session scan A 958e4ba74a3a
dotnet-testing-specialist is an agent published in the GitHub repository novotnyllc/dotnet-artisan (229 stars, last pushed 19d ago), licensed MIT. It adds 60 tokens to every session and 1,630 once invoked, about $0.0003 per session on Opus 5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-08-30.
Other agents, from other repositories
test-writer
Use when writing, fixing, or expanding tests. Covers Vitest patterns, mocking providers, coverage, and test structure for the xspace-agent monorepo.
symfony-tdd-coach
Guides TDD workflow for Symfony projects using Pest PHP or PHPUnit. Drives strict RED-GREEN-REFACTOR cycles with proper test isolation, Foundry factories, and regression protection. Use when writing tests, adding test coverage, or practicing TDD.
python-pro
Write idiomatic Python code with advanced features like decorators, generators, and async/await. Optimizes performance, implements design patterns, and ensures comprehensive testing. Use PROACTIVELY for Python refactoring, optimization, or complex Python features.
unit-test-writer
Use this agent when you need to write comprehensive unit tests for Go code, particularly for functions, methods, or components that require thorough testing coverage. Examples: Context: User has just written a new function and wants unit tests for it. user: 'I just wrote this function to validate email addresses, can…
qa-engineer
Use this agent to write, repair, or extend Pest tests for models, controllers, Livewire components, APIs, or packages; to run test suites until green; to analyse coverage gaps and add architecture tests; or to design a test strategy/QA plan for a feature or release (what to test, at which level, with what priority).
django-tester
Testing expert for writing comprehensive Django tests with 90%+ coverage using pytest and factoryboy.