Review Verification Protocol

- Shortened and streamlined all verification gates for Rust code review findings; each step now references explicit Rust concepts and edition-aware concerns. - Updated all checklist and "before flagging" requirements to reflect Rust-specific features (trait impls, lifetimes, edition changes, concurrency primitives). - Added explicit edition checks for Rust 2024, including new language behaviors (lifetime capture, unsafe block requirements). - Expanded common false positive lists and "do NOT flag" sections with Rust-relevant guidance. - Significantly revised and extended the "Valid Patterns" section, focusing on Rust language and ecosystem best practices. - Removed most JavaScript/TypeScript and framework-specific content; protocol now targets Rust projects.

**Refined and clarified review verification gates and pattern lists for improved accuracy.** - Rewrote hard gates for clarity: renamed, re-ordered, and made pass conditions more explicit and objective. - Updated checklist and gate instructions to emphasize preventing false positives and ensure issues are reportable and actionable. - Revised code examples and patterns, now favoring TypeScript/React terminology where relevant over Python/FastAPI. - Expanded and updated the "Valid Patterns (Do NOT Flag)" section with new examples and language, especially for TypeScript and React. - Simplified and clarified when to apply each severity level; adjusted language for actionable vs. informational items. - General language, formatting, and explanation improvements to reduce ambiguity for reviewers.

**Expanded language and framework coverage, clarified mandatory review verification steps.** - Refined “Hard gates” to use objective, unit-based evidence and clarify pass conditions for each step. - Updated references and examples from Swift/Apple frameworks to Python, JavaScript, and web frameworks. - Rewrote common false positives and valid patterns sections with current examples (React, FastAPI, pytest, etc.). - Checklist language improved for clarity and applicability across multiple stacks. - Clarified severity calibration and explicitly listed review blockers and informational suggestions. - Improved formatting and conciseness throughout the verification protocol.

- Refined language and examples to target Apple platform development (Swift, SwiftUI, SPM, Xcode). - Updated search and usage checks for Apple/Swift specifics (e.g., @objc, #selector, public/open, asset catalogs, Interface Builder). - Clarified validation/error handling steps for Apple context (ViewModel, parent View, property wrappers, Apple framework behaviors). - Added Apple/Swift-specific common false positives and valid code patterns. - Adjusted performance, memory, and type-check verifications with Swift/SwiftUI paradigms. - Rewrote “Do Not Flag” and “Severity Calibration” examples to match Apple ecosystem use cases.

**Summary:** Overhauled and streamlined the code review verification protocol for greater clarity and broader language/framework applicability. - Rewrote "Hard gates" as five sequenced steps with more concise, general language and clearer pass criteria. - Checklist and gate order simplified and unified; section now emphasizes evidence, references, and distinguishing style from defects. - Framework- and language-specific references updated from Elixir/Phoenix/LiveView to Go and general patterns. - Examples under "Valid Patterns" switched focus from Elixir/Phoenix idioms to Go concurrency, error handling, and testing idioms. - All instructions and examples made clearer, more concise, and more generally applicable across stacks.

Expanded protocol to require hard evidence gates and stack-specific verification, with an emphasis on objective finding criteria and improved severity calibration. - Introduced "Hard gates": sequential, tool-backed verification steps required before any finding can be reported. - Updated verification checklist and issue-type guides for broader framework/language coverage, including Elixir/OTP/Phoenix/LiveView specifics. - Clarified severity calibration and redefined informational findings as non-blocking, non-actionable. - Added guidance on acceptable code patterns for Elixir, Phoenix/LiveView, and testing to reduce false positives. - Emphasized omitting or downgrading findings if all gates cannot be passed with hard evidence.

Edition 2024 review checks added for Rust code - Expanded checklist to require checking and applying rules per the project's Rust edition (2021 vs 2024). - New sections detailing false positives and correct flagging procedures for: - "Unnecessary Lifetime"/RPIT capture (Edition 2024) - "Missing Unsafe Block" (Edition 2024, including `unsafe_op_in_unsafe_fn`) - Updated "Valid Patterns" with edition 2024 idioms (e.g., explicit unsafe blocks, precise lifetime capture, reserved identifier usage, new standard library constructs). - Added reminders and examples for changes in Rust lint suppressions (e.g., `#[expect(lint)]`), async trait methods, and other Rust 1.80+ features. - Retains all previous review guidance; additions focus on reducing review mistakes in codebases adopting Rust 2024 edition.

- The verification protocol has been rewritten for the Rust language and ecosystem. - Checklist items, issue types, false positives, and valid patterns have all been updated to focus on Rust-specific concepts (ownership, traits, macros, async). - Severity calibration and context-sensitive rules now reflect common Rust pitfalls and best practices. - Previous framework- and language-specific advice (TypeScript, React, general) has been replaced by Rust patterns, async/Tokio, and idiomatic usage notes. - Examples and common false positives are now tailored for Rust code reviews.

- Updated valid code patterns and guidance from Python/FastAPI examples to TypeScript/React to better match modern web stacks. - Refined type assertion/unsafe cast section with TypeScript code samples and clarification between type annotation, assertion, and narrowing. - Added React-specific valid patterns and new context-sensitive guidance for React keys and useEffect dependencies. - Removed Python/FastAPI-specific patterns in favor of current frontend-focused advice. - Improved language and examples throughout for clarity and modern framework relevance.

- Protocol examples and context-sensitive rules updated from Swift/SwiftUI to Python/FastAPI - Valid patterns tables now focus on Python, FastAPI, and pytest best practices - Type assertion and narrowing examples changed from Swift to Python syntax - Added/edited rules for type annotation and exception handling specific to Python - Severity calibration, performance checklists, and informational guidelines clarified without major structural changes

- Updated all language- and framework-specific examples from Go to Swift and SwiftUI. - Revised tables of "Valid Patterns" and context-sensitive rules to reference Swift/SwiftUI idioms instead of Go/concurrency. - Adjusted code samples and terminology to better fit Swift, including Optionals, SwiftUI property wrappers, and XCTest conventions. - Clarified conditions for flagging errors in Swift, such as force unwrap, view complexity, and missing error handling. - General protocol structure, checklists, and severity definitions remain unchanged.

- Switched language-specific examples and valid patterns from Elixir/Phoenix to Go idioms and concurrency patterns. - Updated type assertion/unsafe cast guidance with Go-specific checks and example code. - Added Go-centric context-sensitive rules, such as error handling, goroutine lifecycle, and interface design. - Removed prior Elixir- and Phoenix-specific sections, replacing them with Go standards and conventions. - All general verification protocols and severity calibration remain unchanged.

- Broadened verification protocol beyond Rust: now includes guidance for Elixir, Phoenix, LiveView, and JavaScript/TypeScript frameworks. - Added new section for context-sensitive rules and valid patterns in Elixir and Phoenix contexts. - Updated pre-report checklist and verification steps to cover common web and backend frameworks. - Added informational-only review items, clarifying they should not appear in actionable counts or block merges. - Included examples of framework features that often create false positives, improving reviewer accuracy. - Minor text and terminology updates for broader applicability and clarity.

- Major update: protocol rewritten and customized for Rust code review workflows. - Verification steps, examples, and rules now reference Rust concepts (traits, ownership, error handling, async/Tokio, etc). - False positive examples and valid pattern lists are adapted for common Rust project realities. - Severity calibration updated to include Rust-specific criteria (unsafe blocks, data races, etc). - Guidance for flagging issues now considers Rust idioms—especially around `.clone`, error context, and concurrency. - All references to frameworks (e.g., FastAPI, React) replaced with Rust-specific tooling and practices.

- Updated all code and pattern examples from Go-centric to Python/FastAPI/pytest context - Revised "Valid Patterns" section to reflect Python, FastAPI, and pytest idioms instead of Go and concurrency examples - Adjusted context-sensitive rules for type annotations and error handling based on Python best practices - Removed Go-specific advice and replaced with Pythonic equivalents - Clarified sections and instructions to better suit Python/modern backend environments

- Protocol examples and allowed patterns updated from Swift/SwiftUI to Go and Go concurrency. - "Valid Patterns" and "Context-Sensitive Rules" sections reworked for Go idioms (e.g., error handling, channels, goroutines, testing). - Type assertion examples now use Go syntax and explain the "comma-ok" idiom and type switches. - Swift-specific references and patterns removed or replaced with their Go equivalents. - No code or logic changes outside of documentation—all updates are to SKILL.md guidance only.

**Summary:** Adds comprehensive, mandatory verification steps to standardize and improve the accuracy of code review findings. - Introduces a detailed pre-report verification checklist to reduce false positives. - Provides specific verification protocols for common issue types (unused variables, validation, type assertions, memory leaks, performance issues). - Defines calibrated severity levels and clarifies when to block merges versus noting informational feedback. - Lists context-sensitive and language/framework-specific patterns that must not be incorrectly flagged. - Establishes final review checks to ensure findings are accurate, valuable, and actionable.