pythonista-patterning_skill

Overview

This skill helps developers discover existing code patterns and extract reusable helpers before writing new code. It enforces a pragmatic balance: prefer small focused helpers extracted immediately, and escalate architectural changes for discussion. Use it to avoid subtle duplication and keep implementations consistent across a codebase.

How this skill works

It guides you to search for similar implementations (sibling files, parallel modules, repository-wide grep) and document what is common vs what varies. It recommends following established naming, parameter, and error-handling patterns, and gives concrete rules for when to extract a simple helper vs propose new infrastructure. It includes a short checklist to run before adding or changing code.

When to use it

• Before writing any new functionality that might resemble existing code
• When you see keywords like pattern, duplicate, extract, helper, refactor, or DRY
• When adding similar endpoints, services, or database queries in multiple places
• During code review when spotting repeated logic or inconsistent validation
• When preparing a change that could affect multiple modules or teams

Best practices

• Search sibling and parallel files first; use repository grep to confirm scope
• Document the common structure and clearly list what varies vs what stays constant
• Match existing parameter names, types, error handling, and validation strategies exactly
• Extract small, focused helpers immediately for duplicated calculations or queries repeated 3+ times
• Propose new infrastructure only after discussion if the change affects multiple components or adds an architectural layer
• Never duplicate validation handled by lower layers; trust each layer’s responsibilities

Example use cases

• You’re implementing update_campaign and find an almost-identical update_drip — extract an auto_increment_version helper
• Multiple services perform the same DB query — extract a shared repository function and update callers in the same PR
• You notice repeated validation logic across endpoints — extract a validator utility and reuse it consistently
• Two feature teams consider a shared manager; use this skill to decide between a simple helper or starting a design discussion
• Refactoring to reduce duplicated error handling across similar API functions