Touch-Map: Map Before You Code

Where this fits

You ask your coding agent to add a new feature, and it immediately starts editing files. Halfway through, you realize it missed a boundary that affects another module. The agent didn't stop to think about what the change actually touches. This is the gap touch-map fills: it forces the agent to produce a map of affected parts and files before any code or plan is written, ensuring the change is fully scoped and the intent is settled.

Why agents benefit

• Prevents scope creep: The agent enumerates every file, function, and boundary that must change, so nothing is forgotten until implementation.
• Enforces decision closure: It halts mapping if the user hasn't settled on the desired behavior, avoiding wasted work on vague requests.
• Creates a reusable artifact: The touch map becomes a reference for later planning and implementation skills, keeping the pipeline organized.
• Reduces context switching: By mapping all touchpoints upfront, the agent avoids rediscovering dependencies mid-implementation.
• Improves change safety: For refactors and bug fixes, a clear map highlights risky boundaries before code is touched.

Practical scenarios

Adding a new API endpoint

Your agent needs to add a POST /orders endpoint. Touch-map makes it list the controller, service, repository, validation layer, and any middleware that intercepts requests. It also flags the database schema and migration files. The agent stops there—no code yet—so you can review the scope before implementation.

Fixing a bug in payment flow

When a user reports a payment failure, the agent maps the flow: payment gateway client, callback handler, order status updater, and notification service. It identifies that the bug likely spans multiple modules, and the map reveals a hidden dependency on a retry queue. This prevents a patch that only fixes the symptom.

Refactoring an authentication boundary

You decide to move from session-based to token-based auth. Touch-map forces the agent to enumerate every route that checks auth, every middleware, and every frontend call that relies on cookies. The map shows the full blast radius, so you can plan a safe migration without missing a single protected endpoint.

Add it to your agent workflow

Install the skill with:

npx skills add AlemTuzlak/skills --skill touch-map

Then, after the user confirms a change, invoke it with a prompt like:

Use touch-map to map what adding a discount code feature touches across the codebase.

The agent will return a structured map of files and components—no code, no plan. A later workflow skill can use that map to sequence implementation steps.

Compare before adopting

Before you integrate touch-map, compare it against other scoping skills or your agent's built-in planning. Look at how actively the repository is maintained (last commit, issues), the quality of its documentation, and whether the skill's philosophy matches your existing pipeline. Also consider alternatives like plan-mode or manual prompting—touch-map wins when you want a strict gate before any code.

Why it is worth tracking

With 39 stars and a clear, disciplined scope, touch-map shows signs of a focused tool. Its hard gates—no code, no next skill—make it a reliable checkpoint for agents that tend to jump ahead. Keep an eye on its adoption and any updates that add richer output formats. Evaluate it if you're building a multi-step agent workflow that needs a mapping stage. See more at https://www.openagentskill.com/skills/alemtuzlak-touch-map.