Functions with deeply nested if/else where the happy path is buried inside multiple levels of indentation, and edge cases are conditionals around the main flow.
A function with deeply nested if/else where the happy path is buried under indentation; the agent must trace through edge-case branches to find the main flow.
Edge cases bail out early at the top of the function; the main flow is unindented and tells the happy path linearly.
Edge cases exit at the top of the function; the happy path runs at the function's base indent level, and adding a precondition is one new guard at the top instead of a rewrite of the nested branches.
Before the refactoring
function payAmount(employee) {if (employee.isSeparated) {return separationPay(employee);} else {if (employee.isRetired) {return retirementPay(employee);} else {return regularPay(employee);}}}
After the refactoring
function payAmount(employee) {if (employee.isSeparated) return separationPay(employee);if (employee.isRetired) return retirementPay(employee);return regularPay(employee);}
The dominant case is hidden under indentation; readers must trace down through edge-case branches to find the main flow; new edge cases extend an already-tangled structure.
The agent's parsing of the function's intent is obscured by indentation; reasoning about the happy path requires tracking which edge cases have already been ruled out.
If multiple paths share work, premature returns can duplicate that work — extract first, then guard.
Early returns can duplicate work if multiple paths share follow-up logic; the agent inlining guards must verify the shared work is genuinely separable.
Indentation drops; the dominant case is obvious; new edge cases land at the top without disturbing the rest.
Guards exit at the top of the function and the happy path runs at the function's base indent level; adding a precondition is one new guard prepended at the top instead of a rewrite of the nested branches.
Inlining guard clauses for every condition — including ones where the edge case shares work with the main path; the early returns duplicate work the structure was sharing.
Inlining guards for every condition — including ones that shared follow-up work — fragments the shared logic across early-return branches the agent must keep consistent.