website·Indexed 30 days ago
https://gauntletci.comGauntletCI is a local-first change risk engine for C# and .NET that analyzes pull request diffs to detect behavioral risks. It provides a comprehensive set of rules (GCI series) covering security, data integrity, async and concurrency, architecture and design, and observability and error handling. The tool can be integrated into CI/CD pipelines, editors, and AI assistants.
// Before diff: the implicit contract
if (user == null) return;
Process(user.Name);
// After diff: guard removed, tests still pass.
Process(user.Name);GauntletCI is designed to identify 'Behavioral Change Risk'—changes that are syntactically correct and compile cleanly but introduce runtime risks. Unlike AI review tools that focus on style and intent, GauntletCI analyzes the staged diff to find logic shifts that often bypass human and AI reviewers, such as:
NullReferenceException or invalid-state paths that might be missed during testing.// Triggers GCI0059: Guard removed, but 'order' is still accessed
- if (order is null) throw new ArgumentNullException(nameof(order));
return order.Total;
// Passes GCI0059: Guard is replaced by a safe return
- if (order is null) throw new ArgumentNullException(nameof(order));
+ if (order is null) return 0;
return order.Total;// This would trigger GCI0035 if Microsoft.EntityFrameworkCore
// is forbidden in the Domain layer:
// src/MyApp.Domain/Order.cs
using Microsoft.EntityFrameworkCore;To maintain trust and repeatability in a CI/CD pipeline, separate the discovery of a finding from its explanation. A reliable AI code review system should follow this architecture:
This approach prevents 'debugging the reviewer'—where developers encounter different results for the same code—and ensures auditability for compliance.
[Deterministic Engine] -> Identifies: "Condition changed from non-null to non-null active; no test updated"
[AI Layer] -> Explains: "This change narrows the accepted input set. If inactive records should be excluded, add a test to prove this behavior."GauntletCI serves as a deterministic risk gate within the GitHub review process. Unlike probabilistic AI tools or broad static analysis, GauntletCI is designed to block merges when it detects specific behavioral or contract risks, such as:
// Triggers GCI0020 (Removal of timeout handling or resource cleanup)
try { await ProcessAsync(order); }
- catch (TimeoutException) { }
// OR
- using var conn = new SqlConnection(cs);
// Passes GCI0020 (Proper timeout and error handling)
try { await ProcessAsync(order, TimeSpan.FromSeconds(30)); }
+ catch (TimeoutException ex) { _logger.LogError(ex); throw; }Behavioral Change Risk (BCR) is a software risk category where a code modification alters the observable behavior of a system, but that change is not detected or asserted by the existing test suite. This creates a validation gap where the system's actual behavior diverges from what the tests are capable of verifying.
BCR occurs when two conditions are met:
B(C + ΔC) ≠ B(C).ΔB) is not exercised and asserted by the test suite T against the modified codebase.Crucially, BCR is not always a defect; it is a validation gap. The risk is that the behavioral change has not been explicitly validated, regardless of whether the change was intentional or accidental.
GauntletCI is a reference implementation designed to automate the detection of Behavioral Change Risk (BCR). It analyzes code diffs to identify structural patterns associated with BCR categories (e.g., identifying when a guard clause was removed or an exception handler was narrowed).
Unlike general static analysis tools (like Semgrep, CodeQL, or SonarQube) that analyze the full codebase, GauntletCI scopes its analysis specifically to the diff at the pre-commit stage. This allows developers to address behavioral shifts at the moment of lowest remediation cost. The tool surfaces the 'what' (the pattern), while the developer provides the semantic judgment on the 'why' (whether the change is intentional or acceptable).