Menu
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.
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 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 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).
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 | early-return-guards |
| description | 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. |
The happy path stays at indentation level zero. Every precondition, edge case, and failure exits at the top with return / raise / continue; what remains reads straight down. Nesting and else-after-exit are how a 5-line function becomes a pyramid nobody can review.
A branch that ends in return / raise / continue / break is never followed by else (or elif doing else's job). Preconditions are checked as guards at the top, inverted. No exceptions.
| Situation | โ banned | โ required |
|---|---|---|
| precondition / edge case | wrap the body in if valid: | invert and exit: if not valid: return None |
| branch ends in return/raise | if c: return a + else: return b | drop the else โ the code after the if is the else branch |
| result decided by branches | assign result in if/else arms, single return result at the end | return directly from each arm; last line returns the default |
| loop item filtering | nest the loop body in if keep: | if not keep: continue, body stays flat |
| adding a condition to an already-nested function | add one more nesting level "to keep the diff small" | that's the signal โ invert the function you're touching to guards first |
Still allowed: if/else where neither arm exits (two live continuations); conditional expressions (a if c else b); try/except/else; match arms (see branching-modeled-state-with-match).
# โ before โ result threaded through a pyramid
def pick_camera(devices, preferred_index, require_hd):
result = None
if len(devices) > 0:
if preferred_index is not None:
for device in devices:
if device.index == preferred_index:
if not require_hd or device.width >= 1280:
result = device
if result is None:
for device in devices:
if not require_hd or device.width >= 1280:
result = device
break
return result
# โ
after โ guards exit, happy path reads straight down
def is_eligible(device, require_hd):
return not require_hd or device.width >= 1280
def pick_camera(devices, preferred_index, require_hd):
if len(devices) == 0:
return None
for device in devices:
if device.index != preferred_index:
continue
if not is_eligible(device, require_hd):
continue
return device
for device in devices:
if is_eligible(device, require_hd):
return device
return None
Note the shape of each loop: disqualify with continue, then return. The eligibility condition, needed twice, became its own function instead of being copy-pasted into two nests.
| Mistake | Fix |
|---|---|
else: return default after an if ... return | Delete the else, dedent: return default as the last line. |
| Keeping a nest "because the hotfix diff should be minimal" | Guard-inverting the one function you touch is minimal. Adding a 4th nesting level is the churn. |
result: T | None = None at the top of a branching function | That variable exists only to escape the nest. Return from the arms directly. |
Guarding with if ok: around 20 lines | Invert: if not ok: return/raise, then the 20 lines dedent. |
elif chain where every arm returns, ending in else: | Sequential if ... return statements; the final else body becomes plain trailing code. |
else: under a branch whose last statement is return/raise/continue โ delete it, dedent.result = None before an if โ return from the branches.Ruff flags the mechanical part (RET505โRET508); this skill exists for the part it can't โ structuring new conditions as guards in the first place.