skill-issues

Document Cairo language quirks, gotchas, and idiomatic workarounds; use when encountering unexpected compilation errors or behaviors in Cairo that differ from Rust.

Guide implementing custom numeric types in Cairo with invariant enforcement, overflow safety, and standard trait implementations; use when implementing fixed-point, signed integers, or other numeric primitives.

Explain how to write and run Cairo tests, including `#[test]`, assert macros, `#[should_panic]`, `#[ignore]`, and `#[available_gas]`; use when a request involves writing or running unit tests in Cairo.

Explain Cairo Array usage, ArrayTrait methods, array! macro, Span, and array read/write constraints; use when a request involves creating, updating, reading, or passing arrays in Cairo.

Explain Cairo associated items (functions, types, constants, implementations) in traits and impls; use when a request involves associated types, constants, or clarifying trait item placement in Cairo.

Explain Cairo closures, syntax, capture rules, type inference, and Fn traits; use when a request involves anonymous functions or passing behavior as a parameter in Cairo.

Explain Cairo comment styles and documentation comments (`//`, `///`, `//!`); use when a request involves commenting code, documenting functions/modules, or generating Cairo API docs.

Explain Cairo control flow with `if`, `else`, `loop`, `while`, `for`, `break`, and `continue`; use when a request involves conditionals, loops, or loop return values in Cairo.

Explain how to build custom data structures in Cairo using structs, traits, and dictionaries; use when a request involves implementing mutable collections (like a vector) or handling Destruct/Drop with Felt252Dict.

Explain Cairo scalar and compound data types, literals, conversions, and string forms; use when a request asks about Cairo types (felt252, integers, bool, strings, tuples, arrays, unit), type annotations, or conversion errors.

Explain Cairo Felt252Dict usage, insert/get/entry patterns, and dictionary squashing; use when a request involves key-value storage, dictionary performance, or borrow/ownership rules for dictionaries in Cairo.

Explain Cairo enums, defining variants with data, constructing values, and using Option; use when a request involves enum design, variant syntax, or pattern-matching enum values in Cairo.

Explain Cairo function syntax, parameters, return values, statements vs expressions, and `const fn`; use when a request involves defining or calling functions, return types, or function-related compiler errors in Cairo.

Explain Cairo generic data types and syntax for generic functions, structs, enums, methods, and impls; use when a request involves type parameters or generic signatures in Cairo.

Explain Cairo generics and traits at a high level, including monomorphization and code size impact; use when a request asks why generics/traits reduce duplication, how trait bounds relate to generics, or why contract size increases with generics.

Explain Cairo `if let` and `while let` concise control flow; use when a request involves matching a single pattern or looping over Option-like values in Cairo.

Explain Cairo match expressions, pattern matching on enums, exhaustiveness, and wildcard arms; use when a request involves matching Option/Result or enum values in Cairo.

Explain Cairo method syntax, traits/impl blocks, `self` parameter forms, and associated functions; use when a request involves defining or calling methods on structs in Cairo.

Explain Cairo paths for referring to items in the module tree, including absolute vs relative paths and `super`/`crate`; use when a request involves resolving module path errors in Cairo.

Explain how Cairo modules are split across files and folders, and how `mod` declarations map to files; use when a request involves organizing modules into multiple files in Cairo.

Explain Cairo modules, `mod` declarations, privacy, and scope control; use when a request involves organizing code into modules or resolving visibility errors in Cairo.

Explain Cairo operator overloading using core::ops traits like Add; use when a request involves redefining operators for custom types in Cairo.

Explain Cairo ownership, moves, Copy/Drop/Destruct traits, and scope-based destruction; use when a request involves use-after-move errors, copying values, or ownership semantics in Cairo.

Explain Cairo packages and crates, Scarb project layout, and crate roots; use when a request involves creating projects or understanding package/crate structure in Cairo.

Explain Cairo unrecoverable errors, `panic`, `panic!`, `panic_with_felt252`, `nopanic`, and `panic_with`; use when a request involves panics or panic annotations in Cairo.

Explain Cairo printing and formatting with print!/println!/format!, Display/Debug traits, and Formatter helpers; use when a request involves output formatting or printing custom types in Cairo.

Explain Cairo recoverable errors using `Result`, `ResultTrait`, and the `?` operator; use when a request involves returning, matching, or unwrapping `Result` values in Cairo.

Explain Cairo references, snapshots (`@`), `ref` parameters, and desnap (`*`); use when a request involves borrowing, avoiding moves, or mutating data through references in Cairo.

Explain Cairo smart pointers, especially Box types, boxed memory segments, and recursive types; use when a request involves boxing values, avoiding copies, or defining recursive types in Cairo.

Explain the Cairo example program that refactors rectangle area calculations into a struct, including `Into`/`TryInto` conversions; use when a request references the Chapter 5.2 struct example or asks for struct-based refactors.

Explain how to define and instantiate Cairo structs, field access, mutability, field init shorthand, and update syntax; use when a request involves struct definitions or field-related compile errors in Cairo.

Explain Cairo test organization for unit vs integration tests, tests directory layout, and shared helpers; use when a request involves structuring tests across files or crates in Cairo.

Explain Cairo traits, impl syntax, default methods, trait bounds, and visibility; use when a request involves defining traits, implementing traits, or resolving trait method availability errors in Cairo.

Explain Cairo `use` imports, aliases, re-exports, and grouped imports; use when a request involves bringing paths into scope or shortening module paths in Cairo.

Explain Cairo variable bindings, immutability, `mut`, constants, and shadowing; use when a request involves variable declaration, reassignment errors, changing types via shadowing, or defining constants in Cairo.

Diagnose and fix common snforge test errors including Sierra compilation failures, cost computation cycles, and version mismatches; use when tests fail with cryptic errors even though `scarb build` succeeds.

Explain Cairo arithmetic circuits using core::circuit, gates, CircuitElement, and evaluation; use when a request involves building or evaluating arithmetic circuits in Cairo.

Explain component dependency patterns, trait bounds, and dependency access helpers; use when a request involves components that rely on other components in Cairo.

Explain how to test Starknet components by embedding them into mock contracts and dispatching calls; use when a request involves unit tests for component logic in Cairo.

Explain Starknet components, embedding into contracts, and component interfaces; use when a request involves reusable contract logic or component-based design in Cairo.