Menu
Use when converting a value to int, float, str, or bool in Python โ about to write int(x), float(x), str(x), bool(x), a bare `if x:` / `x or default` on a value where None, 0, or "" mean different things, or filter(None, xs).
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Based on SOC occupation classification
Use when writing or modifying a Python function with conditional branches โ about to nest an if inside an if, write an else after a branch that returns/raises/continues, or assign a result variable in branches to return at the end.
Use when naming or renaming a Python function, method, or class โ especially when a name is heading past three words (ensure_model_file_present, load_and_validate_config), contains and/or/with/if_missing, or describes several steps at once.
Use when writing Python that branches on a value carrying a modeled state โ a union of dataclass variants, a Literal-tagged kind/status/type field, or any state-machine state โ to choose behavior or a return value, or when adding a variant to such a union. Also when reaching for an if/elif or isinstance chain on a tag field, a hand-rolled exhaustiveness helper, or a dict lookup to consume a tagged union.
Use when composing or chaining dry-python returns Result / FutureResult values โ sequencing multi-step operations where each step can fail, recovering from a specific error, or deciding where a Result becomes a plain value, exit code, or response. Also when reaching for .unwrap(), .failure(), ._inner_value, isinstance(r, Success) / is_successful() mid-pipeline, match on Success/Failure outside the consumption edge, Result.do, or try/except around Result-returning code.
Use when authoring or converting Python type annotations โ defining a class / TypedDict / pydantic model / function signature, typing arguments or state, deciding between optional (None / NotRequired) fields and a union, or about to reach for Any, dict[str, Any], cast(), or a type-ignore comment. The minimum modeling rules for typed Python under pyright.
Use when branching off the prefix of a string with str.startswith (namespaced name families like "file.", "edit.", "edit.image.") and the number of prefix branches is growing, when a startswith if-chain is becoming hard to test or extend per-family, or when adding several new prefix families to an existing dispatcher.
| name | explicit-primitive-conversion |
| description | Use when converting a value to int, float, str, or bool in Python โ about to write int(x), float(x), str(x), bool(x), a bare `if x:` / `x or default` on a value where None, 0, or "" mean different things, or filter(None, xs). |
Blanket conversions hide intent and bury edge cases. bool(x) and a bare if x: collapse None, 0, 0.0, "", [], {}, and False into one bucket; str(x) quietly turns None into "None" and objects into repr noise; int(f) silently truncates toward zero; a naked int(s) on external input is an unhandled ValueError three frames away. Convert explicitly, and handle each edge case by name.
bool(x) for domain logic, x or default on a value with meaningful falsy states, and naked int()/float() on external strings are banned. No exceptions.
| Goal | โ banned (implicit) | โ required (explicit) |
|---|---|---|
| external string โ int/float | naked int(x) / float(x), int(x or 0) | int(x) in a try/except ValueError that names the failure โ or a pydantic model / Result (see chaining-returns-results) |
| float โ int | int(f) (silent truncate-toward-zero) | name the rounding: math.floor(f) / math.ceil(f) / round(f) |
| anything โ str | str(x) / f"{x}" on an Optional or object-typed value | handle None first: "" if x is None else str(x) โ or raise |
| presence / emptiness / zero | bool(x), bare if x: where None/0/"" differ, x or default | x is None / x == "" / count == 0 / len(xs) == 0; default if x is None else x |
| drop falsy items | filter(None, xs), [x for x in xs if x] | name the condition: [x for x in xs if x is not None] |
Still allowed: str(port) on a known int โ the type and rendering are what you intend; if not items: on a plain, never-None collection where emptiness is the whole question; comparisons themselves โ ok = x is not None already is a bool, there is nothing left to coerce.
# โ before โ every conversion is implicit
page = int(query.get("page") or 1) # "0" and "" and missing all collapse
label = f"user: {user.nickname}" # Optional[str] โ "user: None"
apply = bool(user) and bool(rate) # which falsy states did you mean?
tags = [t for t in raw if t] # drops "" โ and also drops "0"? None?
percent = int(ratio * 100) # truncates 99.9 โ 99, silently
# โ
after โ intent is named at every step
raw_page = query.get("page")
page = 1 if raw_page is None else parse_page(raw_page) # ValueError handled inside, by name
label = f"user: {user.nickname}" if user.nickname is not None else "user: (unset)"
apply = user is not None and rate > 0 # exactly the conditions you mean
tags = [t for t in raw if t is not None and t != ""]
percent = math.floor(ratio * 100) # the rounding is a decision, so name it
if x: / bool(x) / x or default test "is it truthy" โ but you almost never mean all seven falsy values. Writing the explicit condition forces you to name the one you actually mean:
x is not None (if x: would also reject a legitimate 0 or "")x != ""count > 0 (x or default would have replaced a real 0)x or default is the trap that passes review: it reads as "default if missing" but means "default if falsy", so a real 0 or "" silently becomes the default. Write default if x is None else x.
Any (or untyped)?Do not reach for str(x) / int(x) to dodge the type. Model it first (see precise-type-modeling) โ a pydantic model at the boundary converts once, validates, and names every failure. f"{x}" on a bare Any is itself a smell that the type was never modeled; don't launder it through a conversion.
| Mistake | Fix |
|---|---|
int(x or 0) "to handle missing input" | Collapses None, "", and "0" into one case. Branch on x is None, then parse with error handling. |
int(f) "to round" | It truncates toward zero (int(-1.5) == -1). Say which rounding you mean: math.floor / math.ceil / round. |
if x: (or x == None) for presence | x is None / x is not None โ identity, immune to __bool__/__eq__. |
if x: to detect NaN | float("nan") is truthy (and != itself). Use math.isnan(x). |
bool(flag_count) "because I need a bool" | You need a condition: flag_count > 0. A comparison already returns bool. |
Naked int(s) "pyright didn't complain" | Type checkers can't see that s came from the network. The ValueError is yours to name โ or validate with pydantic. |
bool( โ truthiness collapse. Write the is None / == / > condition you mean.if x: or x or default on an Optional, an int/float, or a str where "" is valid data โ name the condition.filter(None, ...) or if t in a comprehension โ name the predicate.int(x) / float(x) on anything from outside the process โ named error handling or a pydantic validator.str(x) / f"{x}" where x can be None or an arbitrary object โ handle the None/repr case first.Ruff catches fragments of this (SIM truthiness rules); this skill exists for the part it can't โ choosing the explicit replacement that says what you mean.