implementation-intent

name	implementation-intent
description	Create a concrete execution plan specifying exactly what action to take, when to take it, and in what context. Use when starting a complex task, breaking down ambiguous requirements, or preventing scope drift during multi-step operations.

You are an AI agent applying the Implementation Intentions framework from Atomic Habits by James Clear to your own task execution. Use this skill to transform vague objectives into precise, pre-committed action plans.

Core Principle

"Agents that define exactly what they will do, in what context, and in what order, are far more likely to complete the task correctly." The problem isn't capability — it's ambiguity. When a task arrives without a plan, the agent wastes cycles deciding what to do next, which file to modify, and which tool to call. An Implementation Intention eliminates all three.

The Implementation Intention Formula (Agent Version)

"I will [ACTION] on [TARGET] using [TOOL/METHOD] when [CONDITION]."

The Process

Step 1: Decompose the Objective

Break the user's request into discrete, atomic actions:

• ❌ "Refactor the authentication module" (too vague)
• ✅ "Extract the JWT validation logic from [target_module] into a new [extracted_module] file using write_to_file"

Step 2: Specify the Context

Each action must have a clear trigger condition:

• ❌ "Update tests when appropriate"
• ✅ "After modifying any function in src/api/, run the corresponding test file in tests/api/"

Step 3: Assign the Tool

Pre-commit to the specific tool or method:

• ❌ "Search for the function"
• ✅ "Use grep_search with query [target_function] in path [target_directory]"

Step 4: Write the Execution Contract

Combine into a pre-committed sequence:

1. I will read `[target_module]` using `view_file` to understand current JWT logic.
2. I will extract the `[target_function]` function into `[extracted_module]` using `write_to_file`.
3. I will update imports in `[target_module]` using `replace_file_content`.
4. I will run `[test_command]` using `run_command` to verify nothing broke.

Agent-Native Examples

Vague Intent	Implementation Intention
"Fix the bug"	"I will read the error log, trace the stack to [error_trace_location], and fix the off-by-one error using replace_file_content"
"Improve performance"	"I will profile the processData function, identify the O(n²) loop, and replace it with a hash-map lookup"
"Add documentation"	"I will generate JSDoc comments for every exported function in src/utils/ using view_file_outline to identify targets"
"Set up the project"	"I will run [init_command], install dependencies from [dependency_manifest], and create .env from .env.example"

Why It Works for Agents

Without Implementation Intentions, agents exhibit:

• Decision fatigue: Re-evaluating options at every step
• Scope drift: Starting on Task A, wandering into Task B
• Tool misuse: Choosing the wrong tool because no pre-commitment was made

With Implementation Intentions, the agent's execution path is deterministic — each step is pre-loaded.

Anti-patterns to Watch For

• Planning too far ahead without executing (analysis paralysis)
• Making plans that depend on unknowns (plan to edit a file you haven't read yet)
• Skipping the "verify" step in the contract
• Creating intentions so granular they become busywork

Output

When applying this skill, produce:

1. The decomposed list of atomic actions
2. The trigger condition for each action
3. The tool assignment for each action
4. The complete execution contract (ordered sequence)