@ozerohax/assistagents 0.1.1

package/templates/skills/coder/csharp/coder-csharp-testing/SKILL.md

@@ -0,0 +1,398 @@
+---
+name: coder-csharp-testing
+description: C# unit and integration testing best practices. Use when writing tests, setting up test projects, mocking dependencies, or testing with EF Core and ASP.NET Core.
+---
+<skill_overview>
+  <purpose>Write effective, maintainable tests following industry best practices</purpose>
+  <triggers>
+    <trigger>Writing unit tests</trigger>
+    <trigger>Setting up integration tests</trigger>
+    <trigger>Mocking dependencies</trigger>
+    <trigger>Testing EF Core repositories</trigger>
+    <trigger>Testing ASP.NET Core APIs</trigger>
+  </triggers>
+  <sources>
+    <source url="https://learn.microsoft.com/en-us/dotnet/core/testing/">Microsoft Testing Documentation</source>
+    <source url="https://xunit.net/">xUnit Official Documentation</source>
+  </sources>
+</skill_overview>
+<framework_choice>
+  <recommendation>Use xUnit for new projects</recommendation>
+  <why>
+    <reason>Modern design by original NUnit authors</reason>
+    <reason>New instance per test (better isolation)</reason>
+    <reason>No class-level attributes needed</reason>
+    <reason>Community standard for .NET</reason>
+  </why>
+  <comparison>
+    <framework name="xUnit">
+      <test_attr>[Fact], [Theory]</test_attr>
+      <setup>Constructor + IDisposable</setup>
+      <isolation>New instance per test</isolation>
+    </framework>
+    <framework name="NUnit">
+      <test_attr>[Test], [TestCase]</test_attr>
+      <setup>[SetUp], [TearDown]</setup>
+      <isolation>Same instance per class</isolation>
+    </framework>
+    <framework name="MSTest">
+      <test_attr>[TestMethod]</test_attr>
+      <setup>[TestInitialize]</setup>
+      <isolation>Same instance per class</isolation>
+    </framework>
+  </comparison>
+</framework_choice>
+<unit_testing>
+  <pattern name="arrange_act_assert" required="true">
+    <description>Structure every test with AAA pattern</description>
+    <example>
+      <code>
+[Fact]
+public void Add_TwoPositiveNumbers_ReturnsSum()
+{
+    // Arrange
+    var calculator = new Calculator();
+    
+    // Act
+    var result = calculator.Add(2, 3);
+    
+    // Assert
+    Assert.Equal(5, result);
+}
+      </code>
+    </example>
+  </pattern>
+  <naming_convention>
+    <format>[Method]_[Scenario]_[ExpectedResult]</format>
+    <examples>
+      <good>Add_TwoPositiveNumbers_ReturnsSum</good>
+      <good>GetUser_NonExistentId_ReturnsNull</good>
+      <good>CreateOrder_EmptyCart_ThrowsException</good>
+      <bad>Test1, TestAdd, CalculatorTest</bad>
+    </examples>
+  </naming_convention>
+  <assertions>
+    <principle>One logical assertion per test</principle>
+    <note>Multiple related assertions for same concept are OK</note>
+    <example>
+      <code>
+[Fact]
+public void CreateUser_ValidInput_ReturnsUserWithCorrectProperties()
+{
+    var user = _service.CreateUser("john@example.com", "John");
+    
+    // Multiple assertions for one logical concept (user created correctly)
+    Assert.NotNull(user);
+    Assert.Equal("john@example.com", user.Email);
+    Assert.Equal("John", user.Name);
+    Assert.True(user.Id > 0);
+}
+      </code>
+    </example>
+  </assertions>
+  <test_isolation>
+    <rules>
+      <rule>No shared mutable state between tests</rule>
+      <rule>Don't depend on test execution order</rule>
+      <rule>Each test must be independently runnable</rule>
+      <rule>Clean up resources in Dispose</rule>
+    </rules>
+    <example>
+      <code>
+public class OrderServiceTests : IDisposable
+{
+    private readonly Mock&lt;IOrderRepository&gt; _mockRepo;
+    private readonly OrderService _service;
+    
+    public OrderServiceTests()
+    {
+        // Fresh instance for each test
+        _mockRepo = new Mock&lt;IOrderRepository&gt;();
+        _service = new OrderService(_mockRepo.Object);
+    }
+    
+    public void Dispose()
+    {
+        // Cleanup if needed
+    }
+}
+      </code>
+    </example>
+  </test_isolation>
+  <private_methods>
+    <rule>NEVER test private methods directly</rule>
+    <why>
+      <reason>Tests should verify public behavior, not implementation</reason>
+      <reason>Makes refactoring harder</reason>
+      <reason>If private method is complex, extract to separate class</reason>
+    </why>
+    <solution>Test through public API or extract to testable class</solution>
+  </private_methods>
+</unit_testing>
+<mocking>
+  <library_choice>
+    <recommendation>Moq (most popular) or NSubstitute (cleaner syntax)</recommendation>
+  </library_choice>
+  <moq_patterns>
+    <setup_returns>
+      <code>
+var mockRepo = new Mock&lt;IUserRepository&gt;();
+mockRepo.Setup(r =&gt; r.GetById(1))
+    .Returns(new User { Id = 1, Name = "John" });
+var service = new UserService(mockRepo.Object);
+      </code>
+    </setup_returns>
+    <setup_async>
+      <code>
+mockRepo.Setup(r =&gt; r.GetByIdAsync(It.IsAny&lt;int&gt;()))
+    .ReturnsAsync(new User { Id = 1 });
+      </code>
+    </setup_async>
+    <verify>
+      <code>
+// Verify method was called
+mockRepo.Verify(r =&gt; r.Save(It.IsAny&lt;User&gt;()), Times.Once());
+// Verify with specific argument
+mockRepo.Verify(r =&gt; r.Save(It.Is&lt;User&gt;(u =&gt; u.Email == "test@example.com")));
+// Verify never called
+mockRepo.Verify(r =&gt; r.Delete(It.IsAny&lt;int&gt;()), Times.Never());
+      </code>
+    </verify>
+    <matchers>
+      <code>
+It.IsAny&lt;int&gt;()           // Any value
+It.Is&lt;User&gt;(u =&gt; u.Id &gt; 0) // Condition
+It.IsIn(1, 2, 3)          // One of values
+It.IsRegex(@"^\d+$")      // Regex match
+      </code>
+    </matchers>
+  </moq_patterns>
+  <when_to_mock>
+    <mock>External dependencies (APIs, databases, file system)</mock>
+    <mock>Slow operations</mock>
+    <mock>Non-deterministic operations (DateTime, Random)</mock>
+    <dont_mock>Value objects, DTOs, simple classes</dont_mock>
+    <dont_mock>The class under test</dont_mock>
+  </when_to_mock>
+  <best_practices>
+    <practice>Setup only what you need for the test</practice>
+    <practice>Prefer Returns over Verify when possible</practice>
+    <practice>Use strict mocks sparingly</practice>
+    <practice>Don't mock what you don't own (wrap it first)</practice>
+  </best_practices>
+</mocking>
+<testing_efcore>
+  <principle name="dont_mock_dbcontext" priority="critical">
+    <description>NEVER mock DbContext - use real database instead</description>
+    <why>
+      <reason>LINQ queries don't work correctly with mocks</reason>
+      <reason>Change tracking doesn't work</reason>
+      <reason>Tests pass but production fails</reason>
+    </why>
+  </principle>
+  <sqlite_inmemory recommended="true">
+    <description>Use SQLite in-memory for fast, realistic tests</description>
+    <example>
+      <code>
+public class RepositoryTests : IDisposable
+{
+    private readonly SqliteConnection _connection;
+    private readonly AppDbContext _context;
+    
+    public RepositoryTests()
+    {
+        _connection = new SqliteConnection("DataSource=:memory:");
+        _connection.Open();
+        
+        var options = new DbContextOptionsBuilder&lt;AppDbContext&gt;()
+            .UseSqlite(_connection)
+            .Options;
+        
+        _context = new AppDbContext(options);
+        _context.Database.EnsureCreated();
+    }
+    
+    [Fact]
+    public async Task Add_ValidEntity_SavesSuccessfully()
+    {
+        var repo = new UserRepository(_context);
+        var user = new User { Email = "test@example.com" };
+        
+        await repo.AddAsync(user);
+        
+        var saved = await _context.Users.FindAsync(user.Id);
+        Assert.NotNull(saved);
+        Assert.Equal("test@example.com", saved.Email);
+    }
+    
+    public void Dispose()
+    {
+        _context.Dispose();
+        _connection.Dispose();
+    }
+}
+      </code>
+    </example>
+  </sqlite_inmemory>
+  <inmemory_provider>
+    <warning>Use only for simple cases - NOT a real relational database</warning>
+    <limitations>
+      <limit>No referential integrity</limit>
+      <limit>No transactions</limit>
+      <limit>Different SQL translation</limit>
+    </limitations>
+  </inmemory_provider>
+  <testcontainers>
+    <description>Use for critical integration tests with real database</description>
+    <example>
+      <code>
+public class DatabaseFixture : IAsyncLifetime
+{
+    private readonly MsSqlContainer _container;
+    public string ConnectionString =&gt; _container.GetConnectionString();
+    
+    public DatabaseFixture()
+    {
+        _container = new MsSqlBuilder()
+            .WithImage("mcr.microsoft.com/mssql/server:2022-latest")
+            .Build();
+    }
+    
+    public async Task InitializeAsync() =&gt; await _container.StartAsync();
+    public async Task DisposeAsync() =&gt; await _container.StopAsync();
+}
+      </code>
+    </example>
+  </testcontainers>
+</testing_efcore>
+<integration_testing>
+  <webapplicationfactory>
+    <description>Standard for ASP.NET Core integration tests</description>
+    <example>
+      <code>
+public class ApiTests : IClassFixture&lt;WebApplicationFactory&lt;Program&gt;&gt;
+{
+    private readonly HttpClient _client;
+    
+    public ApiTests(WebApplicationFactory&lt;Program&gt; factory)
+    {
+        _client = factory.CreateClient();
+    }
+    
+    [Fact]
+    public async Task GetUsers_ReturnsSuccessStatusCode()
+    {
+        var response = await _client.GetAsync("/api/users");
+        
+        response.EnsureSuccessStatusCode();
+        Assert.Equal("application/json", 
+            response.Content.Headers.ContentType?.MediaType);
+    }
+}
+      </code>
+    </example>
+  </webapplicationfactory>
+  <custom_factory>
+    <description>Override services for testing</description>
+    <example>
+      <code>
+public class CustomWebApplicationFactory&lt;TProgram&gt; 
+    : WebApplicationFactory&lt;TProgram&gt; where TProgram : class
+{
+    protected override void ConfigureWebHost(IWebHostBuilder builder)
+    {
+        builder.ConfigureServices(services =&gt;
+        {
+            // Replace real database with SQLite
+            var descriptor = services.SingleOrDefault(
+                d =&gt; d.ServiceType == typeof(DbContextOptions&lt;AppDbContext&gt;));
+            services.Remove(descriptor);
+            
+            services.AddDbContext&lt;AppDbContext&gt;(options =&gt;
+                options.UseSqlite("DataSource=:memory:"));
+            
+            // Replace external services with fakes
+            services.AddScoped&lt;IEmailService, FakeEmailService&gt;();
+        });
+        
+        builder.UseEnvironment("Testing");
+    }
+}
+      </code>
+    </example>
+  </custom_factory>
+  <test_authentication>
+    <example>
+      <code>
+public class TestAuthHandler : AuthenticationHandler&lt;AuthenticationSchemeOptions&gt;
+{
+    protected override Task&lt;AuthenticateResult&gt; HandleAuthenticateAsync()
+    {
+        var claims = new[] 
+        { 
+            new Claim(ClaimTypes.Name, "TestUser"),
+            new Claim(ClaimTypes.Role, "Admin")
+        };
+        var identity = new ClaimsIdentity(claims, "Test");
+        var principal = new ClaimsPrincipal(identity);
+        var ticket = new AuthenticationTicket(principal, "TestScheme");
+        
+        return Task.FromResult(AuthenticateResult.Success(ticket));
+    }
+}
+      </code>
+    </example>
+  </test_authentication>
+</integration_testing>
+<code_coverage>
+  <philosophy>
+    <principle>Coverage is a tool, not a goal</principle>
+    <principle>Focus on critical paths, not 100%</principle>
+    <principle>Test without assertions = coverage without value</principle>
+  </philosophy>
+  <targets>
+    <target scenario="High-risk systems (financial)">80-90%</target>
+    <target scenario="Business applications">70-80%</target>
+    <target scenario="Internal tools">50-70%</target>
+  </targets>
+  <what_not_to_test>
+    <skip>Auto-generated code</skip>
+    <skip>Configuration/startup code</skip>
+    <skip>Simple DTOs</skip>
+    <skip>Third-party library wrappers</skip>
+  </what_not_to_test>
+  <tool recommendation="Coverlet">
+    <command>dotnet test --collect:"XPlat Code Coverage"</command>
+  </tool>
+</code_coverage>
+<theory_tests>
+  <description>Parameterized tests for multiple inputs</description>
+  <example>
+    <code>
+[Theory]
+[InlineData(1, 2, 3)]
+[InlineData(-1, 1, 0)]
+[InlineData(0, 0, 0)]
+public void Add_VariousInputs_ReturnsCorrectSum(int a, int b, int expected)
+{
+    var calculator = new Calculator();
+    
+    var result = calculator.Add(a, b);
+    
+    Assert.Equal(expected, result);
+}
+[Theory]
+[MemberData(nameof(GetTestData))]
+public void Process_TestCases_ReturnsExpected(Order order, bool expected)
+{
+    var result = _service.IsValid(order);
+    Assert.Equal(expected, result);
+}
+public static IEnumerable&lt;object[]&gt; GetTestData()
+{
+    yield return new object[] { new Order { Total = 100 }, true };
+    yield return new object[] { new Order { Total = 0 }, false };
+}
+    </code>
+  </example>
+</theory_tests>

package/templates/skills/coder/rust/coder-rust-async-concurrency/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: coder-rust-async-concurrency
+description: Rust concurrency and async best practices using std and language features. Use when writing thread-safe or async code.
+---
+<skill_overview>
+  <purpose>Write correct, deadlock-free concurrent Rust code</purpose>
+  <triggers>
+    <trigger>Spawning threads or tasks</trigger>
+    <trigger>Sharing state across threads</trigger>
+    <trigger>Using channels for message passing</trigger>
+    <trigger>Writing async/await code</trigger>
+  </triggers>
+  <sources>
+    <source url="https://doc.rust-lang.org/book/ch16-00-concurrency.html">The Rust Book - Concurrency</source>
+    <source url="https://doc.rust-lang.org/book/ch17-00-async-await.html">The Rust Book - Async/Await</source>
+  </sources>
+</skill_overview>
+<message_passing>
+  <rules>
+    <rule>Prefer channels to avoid shared mutable state</rule>
+    <rule>Move ownership through channels to enforce safety</rule>
+  </rules>
+  <example>
+    <code>
+use std::sync::mpsc;
+
+let (tx, rx) = mpsc::channel();
+tx.send(42).unwrap();
+let value = rx.recv().unwrap();
+    </code>
+  </example>
+</message_passing>
+<shared_state>
+  <rules>
+    <rule>Use Arc&lt;Mutex&lt;T&gt;&gt; or Arc&lt;RwLock&lt;T&gt;&gt; for shared mutable state</rule>
+    <rule>Keep lock scopes minimal and consistent</rule>
+    <rule>Handle poison errors explicitly</rule>
+  </rules>
+</shared_state>
+<send_sync>
+  <rules>
+    <rule>Use types that implement Send and Sync across threads</rule>
+    <rule>Avoid Rc and RefCell in multi-threaded code</rule>
+  </rules>
+</send_sync>
+<async_guidelines>
+  <rules>
+    <rule>Use async/await for I/O-bound work</rule>
+    <rule>Do not block inside async functions</rule>
+    <rule>Async code still needs an executor to run</rule>
+  </rules>
+</async_guidelines>
+<deadlocks>
+  <rules>
+    <rule>Lock in a consistent order</rule>
+    <rule>Drop guards before calling into other code</rule>
+  </rules>
+</deadlocks>
+<anti_patterns>
+  <avoid name="rc_in_threads">Using Rc&lt;T&gt; across threads</avoid>
+  <avoid name="long_lock_scope">Holding a lock across long operations</avoid>
+  <avoid name="blocking_in_async">Blocking I/O inside async code</avoid>
+</anti_patterns>

package/templates/skills/coder/rust/coder-rust-axum-api/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: coder-rust-axum-api
+description: Axum Web API best practices including routing, extractors, state, middleware, and error handling. Use when building REST APIs with axum.
+---
+<skill_overview>
+  <purpose>Build robust, typed, and maintainable HTTP APIs with axum</purpose>
+  <triggers>
+    <trigger>Creating new axum endpoints</trigger>
+    <trigger>Designing routers and route groups</trigger>
+    <trigger>Using extractors for request data</trigger>
+    <trigger>Sharing application state safely</trigger>
+    <trigger>Implementing middleware and error mapping</trigger>
+  </triggers>
+  <sources>
+    <source url="https://github.com/tokio-rs/axum">Axum GitHub</source>
+    <source url="https://github.com/tokio-rs/axum/blob/main/axum/src/docs/extract.md">Axum Extractors Docs</source>
+  </sources>
+</skill_overview>
+<routing>
+  <rules>
+    <rule>Use Router::route with method routers for clarity</rule>
+    <rule>Group related endpoints with nested routers</rule>
+    <rule>Prefer typed Path and Query extractors over manual parsing</rule>
+    <rule>Use fallback to handle unknown routes consistently</rule>
+  </rules>
+  <example>
+    <code>
+use axum::{routing::{get, post}, Router};
+
+let app = Router::new()
+    .route("/users", get(list_users).post(create_user))
+    .route("/users/{id}", get(get_user));
+    </code>
+  </example>
+</routing>
+<extractors>
+  <principles>
+    <principle>Compose multiple extractors in one handler</principle>
+    <principle>Only one body-consuming extractor per handler</principle>
+    <principle>Validate and deserialize input via extractors, not manually</principle>
+  </principles>
+  <common>
+    <item>Path for route params</item>
+    <item>Query for query string</item>
+    <item>Json for JSON payloads</item>
+    <item>State for shared app state</item>
+  </common>
+  <example>
+    <code>
+async fn handler(
+    State(state): State<AppState>,
+    Path(id): Path<u64>,
+    Query(params): Query<Pagination>
+) { /* ... */ }
+    </code>
+  </example>
+</extractors>
+<state_management>
+  <rules>
+    <rule>Keep AppState cloneable and cheap to clone</rule>
+    <rule>Store shared resources behind Arc</rule>
+    <rule>Use State for app-level dependencies</rule>
+  </rules>
+  <example>
+    <code>
+#[derive(Clone)]
+struct AppState {
+    pool: std::sync::Arc<DbPool>,
+}
+    </code>
+  </example>
+</state_management>
+<middleware>
+  <rules>
+    <rule>Apply Router::layer for global middleware</rule>
+    <rule>Use route_layer for per-route middleware</rule>
+    <rule>Prefer explicit ordering of layers</rule>
+  </rules>
+  <example>
+    <code>
+use axum::{middleware, Router};
+
+let app = Router::new()
+    .route("/health", get(health))
+    .route_layer(middleware::from_fn(auth_middleware));
+    </code>
+  </example>
+</middleware>
+<error_handling>
+  <rules>
+    <rule>Return Result from handlers and map errors to responses</rule>
+    <rule>Implement IntoResponse for custom error types</rule>
+    <rule>Never panic on expected errors</rule>
+  </rules>
+  <example>
+    <code>
+enum AppError { NotFound, BadRequest }
+
+impl axum::response::IntoResponse for AppError { /* map to status */ }
+
+async fn handler() -> Result<impl axum::response::IntoResponse, AppError> { /* ... */ }
+    </code>
+  </example>
+</error_handling>

package/templates/skills/coder/rust/coder-rust-conventions/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: coder-rust-conventions
+description: Rust coding conventions, naming rules, and idiomatic patterns (rustfmt, clippy, ownership). Use when writing or reviewing Rust code.
+---
+<skill_overview>
+  <purpose>Write idiomatic, readable, and maintainable Rust</purpose>
+  <triggers>
+    <trigger>Writing new Rust code</trigger>
+    <trigger>Reviewing naming and style</trigger>
+    <trigger>Refactoring for idiomatic patterns</trigger>
+    <trigger>Setting formatting and lint rules</trigger>
+  </triggers>
+  <sources>
+    <source url="https://rust-lang.github.io/api-guidelines/">Rust API Guidelines</source>
+    <source url="https://rust-lang.github.io/rustfmt/">rustfmt</source>
+    <source url="https://github.com/rust-lang/rust-clippy">Clippy</source>
+  </sources>
+</skill_overview>
+<naming_conventions>
+  <rule name="snake_case">Functions, variables, modules, files</rule>
+  <rule name="PascalCase">Types, traits, enums, enum variants</rule>
+  <rule name="SCREAMING_SNAKE_CASE">Constants, static items</rule>
+  <rule name="as_">Use as_* for cheap conversions</rule>
+  <rule name="to_">Use to_* for potentially expensive conversions</rule>
+</naming_conventions>
+<formatting>
+  <rules>
+    <rule>Always run cargo fmt before commit</rule>
+    <rule>Prefer trailing commas to reduce diff noise</rule>
+    <rule>Avoid manual alignment; let rustfmt decide</rule>
+  </rules>
+</formatting>
+<ownership_and_borrowing>
+  <rules>
+    <rule>Prefer borrowing over cloning</rule>
+    <rule>Take &str or &[T] for read-only inputs</rule>
+    <rule>Use iterators instead of index-based loops</rule>
+    <rule>Return owned values when caller should own data</rule>
+  </rules>
+  <example>
+    <code>
+fn find_user(name: &str, users: &[User]) -> Option<&User> { /* ... */ }
+    </code>
+  </example>
+</ownership_and_borrowing>
+<pattern_matching>
+  <rules>
+    <rule>Use exhaustive match for enums</rule>
+    <rule>Avoid catch-all _ unless truly unreachable</rule>
+    <rule>Use if let / while let for single-variant matches</rule>
+  </rules>
+</pattern_matching>
+<anti_patterns>
+  <avoid name="unwrap_in_prod">Avoid unwrap/expect in non-test code</avoid>
+  <avoid name="clone_everywhere">Do not clone to silence borrow checker</avoid>
+  <avoid name="large_mutable_state">Avoid large mutable shared state</avoid>
+</anti_patterns>

package/templates/skills/coder/rust/coder-rust-error-handling/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: coder-rust-error-handling
+description: Rust error handling, validation, and Result best practices. Use when designing error flows or mapping errors across boundaries.
+---
+<skill_overview>
+  <purpose>Design predictable and ergonomic error handling in Rust</purpose>
+  <triggers>
+    <trigger>Designing error types</trigger>
+    <trigger>Propagating errors with Result</trigger>
+    <trigger>Mapping errors at API boundaries</trigger>
+    <trigger>Choosing between panic and Result</trigger>
+  </triggers>
+  <sources>
+    <source url="https://doc.rust-lang.org/book/ch09-00-error-handling.html">The Rust Book - Error Handling</source>
+  </sources>
+</skill_overview>
+<panic_vs_result>
+  <use_panic_when>
+    <case>Unrecoverable, invariant-breaking failures</case>
+    <case>Bug in the program (logic error)</case>
+  </use_panic_when>
+  <use_result_when>
+    <case>Expected errors (not found, validation)</case>
+    <case>I/O or external dependency failures</case>
+  </use_result_when>
+</panic_vs_result>
+<error_types>
+  <rules>
+    <rule>Define a dedicated error enum for a module or service</rule>
+    <rule>Implement Display and Error for custom errors</rule>
+    <rule>Use From to convert lower-level errors</rule>
+  </rules>
+  <example>
+    <code>
+enum ServiceError { NotFound, InvalidInput, Io(std::io::Error) }
+    </code>
+  </example>
+</error_types>
+<propagation>
+  <rules>
+    <rule>Use ? to propagate errors</rule>
+    <rule>Add context with map_err or custom variants</rule>
+    <rule>Preserve original error for debugging</rule>
+  </rules>
+</propagation>
+<boundary_mapping>
+  <rules>
+    <rule>Map internal errors to public error codes/messages</rule>
+    <rule>Do not leak sensitive details to clients</rule>
+  </rules>
+</boundary_mapping>
+<anti_patterns>
+  <avoid name="unwrap_in_flow">Avoid unwrap/expect for normal flow</avoid>
+  <avoid name="string_errors">Avoid plain String errors without structure</avoid>
+  <avoid name="panic_for_validation">Do not panic on validation failures</avoid>
+</anti_patterns>