teddyjfpender/skill-issues

cairo-quirks

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

cairo-numeric-types

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.

cairo-testing

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.

cairo-arrays

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.

cairo-associated-items

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.

cairo-closures

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.

cairo-comments

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

cairo-control-flow

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.

cairo-custom-data-structures

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.

cairo-data-types

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.

cairo-dictionaries

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.

cairo-enums

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.

cairo-functions

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.

cairo-generic-data-types

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.

cairo-generics-traits

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.

cairo-if-let-while-let

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.

cairo-match

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.

cairo-method-syntax

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.

cairo-module-paths

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.

cairo-modules-files

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.

cairo-modules-scope

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

cairo-operator-overloading

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

cairo-ownership

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.

cairo-packages-crates

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.

cairo-panic

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

cairo-printing

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.

cairo-recoverable-errors

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

cairo-references-snapshots

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

cairo-smart-pointers

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.

cairo-structs-example

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.

cairo-structs

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.

cairo-test-organization

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.

cairo-traits

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.

cairo-use-keyword

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.

cairo-variables-mutability

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.

cairo-snforge-troubleshooting

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.

cairo-arithmetic-circuits

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

cairo-component-dependencies

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

cairo-component-testing

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.

cairo-components

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