skillpacks

Use when a request is ambiguous, underspecified, or could be read more than one way — before writing code based on a guess. Makes the agent surface the ambiguity and either ask or state the assumption it's making, instead of silently picking one interpretation and building the wrong thing.

Use when the user is learning and wants to understand the code, not just receive it — they're new to the language, framework, or to coding agents in general. Makes the agent briefly explain what each change does and why, in plain language, so the user learns from every edit instead of blindly accepting it.

Use at the start of any non-trivial coding task — before writing code for a new feature, a fix, or a change that spans more than a couple of lines or files. Makes the agent state a short plan and confirm direction before implementing, so you catch a wrong approach in 3 sentences instead of 300 lines.

Use when about to modify code in a file or function you haven't actually read yet — making a change in an unfamiliar or existing part of the codebase. Makes the agent read the surrounding code first so the edit matches existing patterns and doesn't break nearby logic.

Use when editing existing code — making a fix, adding a feature, or changing behavior in a file that already has working code. Enforces minimal, scoped diffs so the agent changes only what the task requires and never refactors, reformats, or "improves" untouched code.

Use after making a code change and before telling the user it is finished or working. Forces the agent to actually check the change — run the test, build, or a concrete trace of the logic — and report real results, instead of optimistically claiming success it hasn't confirmed.

Use when restructuring existing code without intending to change its behavior — extracting functions, renaming across files, splitting modules, or swapping an implementation. Makes the agent pin current behavior with tests first, change in small verified steps, and prove behavior is unchanged, so a "cleanup" never silently breaks something.

Use after writing or modifying code that handles untrusted input, authentication, authorization, secrets, file paths, database queries, shell commands, or outbound requests — before treating it as done. Makes the agent review its own change for common vulnerabilities instead of shipping them.

Use when starting a substantial feature or change — something that spans multiple files, has non-trivial design decisions, or is expensive to get wrong. Makes the agent write a short spec (goal, approach, key decisions, edge cases) and confirm it before implementing, instead of discovering the design by writing code.

Use when writing or modifying code that calls an external library, framework, SDK, or API — especially one that is niche, recently updated, or whose exact method names and parameters you are not certain of. Makes the agent confirm real, current API signatures before using them, instead of inventing plausible-but-wrong calls from memory.

Use when committing changes with git — staging files and writing commit messages. Makes the agent keep each commit focused on one logical change and write a clear, conventional message explaining why, instead of dumping unrelated edits into a single vague "update" commit.

Use when implementing a feature or fix and tempted to add abstraction, configuration, options, or flexibility beyond what was actually asked for. Makes the agent write the minimum code that solves the real problem, instead of speculative complexity built for imagined future needs.

Use when fixing a bug or adding behavior that can be covered by an automated test — especially bug fixes, where a test should reproduce the problem before any fix is written. Makes the agent write a failing test first, then the code that makes it pass, so the change is provably correct and stays fixed.

Use when working with spatial data — before a spatial join, a distance or area measurement, an overlay, or combining two datasets. Makes the agent confirm every dataset's coordinate reference system (CRS), refuse to assume an undefined one, and reproject everything to a common, operation-appropriate CRS first.

Use before running spatial operations — joins, overlays, buffers, dissolves, area or length calculations — on vector data, especially data from an external or non-GIS source. Makes the agent check for invalid geometries and repair them deliberately first, instead of letting them silently corrupt the result or crash the operation.

Use when editing data in an Esri enterprise geodatabase (SDE) or any versioned, networked, or topology-participating data with ArcPy — updating, inserting, or deleting features. Makes the agent use edit sessions, respect versioning and locks, and avoid corrupting multiuser geodatabase data.

Use when starting an Esri/ArcGIS automation task and choosing how to connect — deciding between ArcPy and the ArcGIS API for Python. Makes the agent pick the right library for the environment (local Pro/desktop geoprocessing vs web/Enterprise/Online feature services) instead of forcing the wrong one.

Use when processing raster or imagery data that is large — multi-gigabyte GeoTIFFs, mosaics, satellite scenes, DEMs — where loading the whole array into memory would fail or thrash. Makes the agent work in windows/tiles, use overviews and cloud-optimized formats, and avoid out-of-memory full-array reads.

Use when converting, reprojecting, filtering, or loading vector data between formats with GDAL/OGR (ogr2ogr) — shapefile, GeoJSON, GeoPackage, PostGIS, and similar. Makes the agent use correct, safe ogr2ogr invocations instead of guessed flags, and prefer robust formats over fragile ones.

Use when writing PostGIS or spatial SQL — distance, proximity, intersection, or geometry storage queries. Makes the agent use correct SRIDs, spatial indexes, and the right ST_ functions, so spatial SQL is both correct and fast instead of silently slow or wrong.

Use when performing a spatial join or location-based filter between two layers — joining attributes by location, or selecting features that intersect, contain, or fall within another layer. Makes the agent pick the correct spatial predicate, confirm CRS and geometry preconditions, and handle one-to-many matches deliberately instead of silently inflating or dropping records.