Localize variable declarations to the smallest possible scope.
npx skills add https://github.com/obra/clank --skill localizing-variables-obra
Please help me install this Agent Skill. Skill: Localizing Variables Source: https://github.com/obra/clank/tree/main/skills/coding/localizing-variables Command: npx skills add https://github.com/obra/clank --skill localizing-variables-obra
This Skill solves the problem of code that's hard to understand and maintain due to variables declared far from where they're used, with unnecessarily wide scope and long lifetimes.
Review this function and localize all variables by declaring them in the smallest possible scope and initializing close to first use.
def process_data(): index = 0 total = 0 done = False result = []
# ... 30 lines of other code ...
while index < count:
index += 1
while not done:
if total > threshold:
done = True
result.append(final_value)
return result
High-intent search queries and answers about installing and using this skill.
Minimizing variable scope reduces bugs by declaring variables in the smallest possible scope—block, function, or module level—closest to where they're first used. This limits the window where variables could be accidentally modified, improves readability, and makes code easier to maintain and review.
Declaring variables near first use shortens their live time, reducing mental load during code review and lowering the risk of incorrect modification. Variables declared far from usage obscure intent and make tracking state changes harder across long stretches of code.
Look for variables declared at function start but used 20+ lines later, variables with only one or two uses scattered in a function, and variables initialized but unused in large blocks. Moving these declarations to their point of use improves safety and readability.
Yes, variable localization applies across languages—Python, JavaScript, Java, C++, and others—by respecting each language's block, function, and module scope constraints. The principle of minimizing scope and declaring near first use works universally to improve code quality.
Scope defines where a variable is accessible in code; lifetime defines how long it exists in memory. Localizing variables controls both: declaring in smaller scopes limits accessibility, and initializing near first use shortens the time the variable persists before becoming irrelevant.
Localized variables are easier to extract into separate functions or modules because their dependencies are clear and contained. Tight scope reveals which variables are actually needed for a refactored block, simplifying extraction and reducing unintended side effects.
barrydobsonLocalize Python variables to the smallest possible scope.
thechandanbhagatRefactor legacy codebases by extracting methods, removing duplication, and applying SOLID principles.
forcedotcomRemove unused variables and imports from JavaScript and TypeScript files.
zero3041Apply idiomatic C# and .NET patterns for robust application design.