two-minute-rule

name	two-minute-rule
description	Downscale any complex agent task to its simplest possible starting step. Use when facing a large refactor, an ambiguous requirement, a complex multi-file change, or any task where the agent might stall from scope overwhelm.

You are an AI agent applying the Two-Minute Rule from Atomic Habits by James Clear to your own task execution. Use this skill to overcome "scope paralysis" by identifying the smallest possible first step — the gateway action that makes the full task inevitable.

Core Principle

"When starting a new task, the first action should take less than two minutes." The goal isn't to complete the task — it's to begin it. An agent that reads the first file, creates the first scaffold, or writes the first test has already defeated the hardest part: starting.

The Two-Minute Rule Process (Agent Version)

Step 1: Identify the Full Task

What's the ambitious goal?

• "Refactor the entire authentication module"
• "Build a CI/CD pipeline from scratch"
• "Migrate the database from [LegacyDB] to [ModernDB]"
• "Write comprehensive documentation for the API"

Step 2: Downscale to the Gateway Action

Strip the task down to its absolute minimum first step — one tool call:

Full Task	Two-Minute Gateway
"Refactor the auth module"	view_file_outline on the main auth file
"Build a CI/CD pipeline"	write_to_file a skeleton [ci_pipeline_config]
"Migrate to [ModernDB]"	grep_search for all [LegacyDB]-specific queries
"Write API documentation"	view_file_outline on the API routes file
"Fix the failing tests"	run_command to execute the test suite and read the error
"Implement a new feature"	Create an empty file with the correct name and a TODO comment

The gateway action is the reconnaissance step — it gives the agent enough context to proceed without requiring a full plan upfront.

Step 3: Execute the Gateway (No More)

Do the gateway action. Then assess. The context gained from this single step will make the next step obvious.

Step 4: Phase Up Naturally

Once the gateway is done, the next "two-minute step" reveals itself:

1. view_file_outline on [target_module] → You see the structure
2. view_code_item on the [target_function] function → You understand the logic
3. write_to_file to create [extracted_module] → You've started the refactor
4. replace_file_content to update imports → You're 80% done

Each step is small. The momentum builds itself.

Why It Works for Agents

Agents stall when:

• The task is too large to plan in one shot
• The requirements are ambiguous and the agent over-thinks before acting
• The agent tries to "see the whole picture" before making a single move

The Two-Minute Rule breaks this by removing the expectation of completion from the first step. The first step is just observation — reading a file, scanning a directory, running a diagnostic.

Agent-Native Examples

• Debugging: Don't plan the fix. First, run_command to reproduce the error.
• Code Review: Don't review everything. First, view_file_outline on the changed files.
• Architecture: Don't design the system. First, list_dir the existing project structure.
• Research: Don't write the report. First, search_web for the most relevant source.
• Testing: Don't write comprehensive tests. First, write a single assertion for the happy path.

Anti-patterns to Watch For

• Skipping the gateway and jumping into a complex multi-file edit
• Spending more time planning the gateway than executing it
• Making the gateway itself complex (reading 10 files is not a gateway)
• Refusing to start because the end state isn't fully defined

Output

When applying this skill, produce:

1. The full task (what the user wants)
2. The two-minute gateway action (one tool call)
3. The expected context gained from that gateway
4. The natural next step that will emerge