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.
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Baseado na classificação ocupacional SOC
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.