Focus Techniques

Purpose

Help developers achieve and maintain deep focus through:

•Proven focus techniques
•Distraction management strategies
•Energy optimization
•Flow state cultivation
•Sustainable productivity habits

When to Use

Invoke this skill when:

•Starting a coding session
•Struggling with distractions
•Experiencing mental fatigue
•Planning deep work sessions
•Optimizing productivity workflow

Instructions

Step 1: Assess Current State

Evaluate:

•Energy Level: High, Medium, Low
•Distractions: Number and severity
•Task Complexity: Simple, Moderate, Complex
•Time Available: Short (<1hr), Medium (1-3hrs), Long (>3hrs)

Step 2: Choose Appropriate Technique

Select based on context:

•Pomodoro: For sustained focus with breaks
•Time Blocking: For structured days
•Deep Work: For complex problems
•Batch Processing: For similar tasks
•Flow State: For creative work

Step 3: Prepare Environment

Optimize for focus:

•Eliminate physical distractions
•Close unnecessary apps/tabs
•Set communication boundaries
•Prepare water/snacks
•Ensure comfortable workspace

Step 4: Execute and Monitor

During session:

•Start timer/tracker
•Single-task (no context switching)
•Take scheduled breaks
•Monitor energy levels
•Adjust as needed

Focus Techniques

1. Pomodoro Technique

Best for: General coding, learning, documentation

Method:

code

1. Choose a task
2. Set timer for 25 minutes
3. Work with full focus (no distractions)
4. Take 5-minute break
5. After 4 pomodoros, take 15-30 minute break

Implementation:

typescript

// Pomodoro Timer
const WORK_DURATION = 25 * 60 * 1000; // 25 minutes
const SHORT_BREAK = 5 * 60 * 1000;    // 5 minutes
const LONG_BREAK = 30 * 60 * 1000;    // 30 minutes

class PomodoroTimer {
  private pomodorosCompleted = 0;

  async startWorkSession(): Promise<void> {
    console.log('🍅 Pomodoro started - Focus for 25 minutes');
    await this.timer(WORK_DURATION);
    this.pomodorosCompleted++;

    if (this.pomodorosCompleted % 4 === 0) {
      console.log('🎉 4 pomodoros done! Take a 30-minute break');
      await this.timer(LONG_BREAK);
    } else {
      console.log('✅ Pomodoro complete! Take a 5-minute break');
      await this.timer(SHORT_BREAK);
    }
  }

  private timer(duration: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, duration));
  }
}

Tips:

•No interruptions during the 25 minutes
•If distracted, restart the pomodoro
•Track number of pomodoros per task
•Adjust duration if needed (20-50 minutes)

Best Use Cases: ✅ Learning new concepts ✅ Writing documentation ✅ Code review ✅ Bug fixing ✅ Refactoring

2. Time Blocking

Best for: Full-day planning, multiple projects

Method:

code

1. Plan day in advance
2. Assign specific time blocks to tasks
3. Include buffer time (10-15%)
4. Schedule breaks and deep work
5. Protect blocked time fiercely

Example Schedule:

code

08:00-08:30  Morning review & planning
08:30-10:30  Deep Work: Feature implementation
10:30-10:45  Break
10:45-12:00  Code review & PR feedback
12:00-13:00  Lunch
13:00-15:00  Deep Work: Complex algorithm
15:00-15:15  Break
15:15-16:30  Meetings & collaboration
16:30-17:00  Email, Slack, admin tasks
17:00-17:30  End-of-day review & tomorrow planning

Implementation:

typescript

interface TimeBlock {
  start: string;
  end: string;
  task: string;
  type: 'deep-work' | 'meeting' | 'break' | 'admin';
}

const dailySchedule: TimeBlock[] = [
  { start: '08:30', end: '10:30', task: 'Feature implementation', type: 'deep-work' },
  { start: '10:30', end: '10:45', task: 'Break', type: 'break' },
  { start: '10:45', end: '12:00', task: 'Code review', type: 'admin' },
];

function getCurrentTask(schedule: TimeBlock[]): TimeBlock | null {
  const now = new Date();
  const currentTime = `${now.getHours()}:${now.getMinutes()}`;

  return schedule.find(block =>
    block.start <= currentTime && block.end > currentTime
  ) || null;
}

Tips:

•Block your best hours for deep work (usually morning)
•Batch similar tasks together
•Include buffer time between blocks
•Protect deep work blocks - no meetings
•Review and adjust weekly

3. Deep Work Sessions

Best for: Complex problems, architecture design, learning

Method:

code

1. Schedule 2-4 hour uninterrupted blocks
2. Eliminate ALL distractions
3. Single complex task only
4. No context switching
5. Full cognitive engagement

Pre-Session Checklist:

During Session:

code

Hour 1: Warm-up, context loading
Hour 2: Peak productivity
Hour 3: Maintain momentum
Hour 4: Wrap up, document progress

Tips:

•Build up to 4-hour sessions gradually
•Start with 90-minute blocks
•Take real breaks (not social media)
•Track what you accomplished
•Don't schedule back-to-back deep work

Best Use Cases: ✅ System architecture design ✅ Complex algorithm implementation ✅ Learning new framework deeply ✅ Major refactoring ✅ Performance optimization

4. The Two-Minute Rule

Best for: Small tasks, preventing task accumulation

Method:

code

If a task takes less than 2 minutes, do it immediately
Don't add it to your todo list

Examples:

•Reply to quick message
•Fix obvious typo
•Update documentation
•Merge approved PR
•Close resolved issue

Implementation:

typescript

function handleTask(task: Task): void {
  if (task.estimatedTime <= 2) {
    // Do it now
    executeTask(task);
  } else {
    // Schedule it
    addToBacklog(task);
  }
}

Tips:

•Be honest about time estimates
•Don't let it interrupt deep work
•Batch during admin time blocks
•Track to avoid scope creep

5. Batch Processing

Best for: Similar tasks, administrative work

Method:

code

1. Group similar tasks together
2. Schedule specific time for batch
3. Process all at once
4. Minimize context switching

Batchable Tasks:

•Email responses
•Code reviews
•Documentation updates
•Dependency updates
•Bug triage
•Meeting notes review

Schedule Example:

code

Monday 4-5pm:     Email & Slack
Tuesday 2-3pm:    Code reviews
Wednesday 4-5pm:  Documentation
Thursday 2-3pm:   Bug triage
Friday 3-5pm:     Weekly review & planning

Tips:

•Don't check email continuously
•Set expectations (reply within 24hrs)
•Use templates for common responses
•Limit batch duration (max 2 hours)

6. Flow State Optimization

Best for: Creative work, complex problem-solving

Prerequisites for Flow:

•Clear goals: Know exactly what you're doing
•Immediate feedback: See results quickly
•Challenge/skill balance: Not too hard, not too easy
•No distractions: Complete focus possible

How to Enter Flow:

code

1. Choose challenging but achievable task
2. Set clear, specific goal
3. Eliminate all distractions
4. Start with warm-up coding
5. Increase difficulty gradually
6. Maintain for 90-120 minutes
7. Take break before burnout

Flow State Indicators:

•Time seems to fly
•Complete absorption
•Effortless concentration
•Losing sense of self-consciousness
•Feeling in control

Tips:

•Protect flow time (no meetings)
•Use same environment/music
•Build a flow ritual
•Don't force it when tired
•Track when you achieve flow

Distraction Management

Digital Distractions

Eliminate:

bash

# macOS: Block distracting sites
sudo echo "127.0.0.1 facebook.com" >> /etc/hosts
sudo echo "127.0.0.1 twitter.com" >> /etc/hosts
sudo echo "127.0.0.1 reddit.com" >> /etc/hosts

# Use browser extensions:
# - Freedom (block sites/apps)
# - Cold Turkey (distraction blocker)
# - RescueTime (track time)

Communication Boundaries:

code

Slack: Status "🎯 Deep Work - Back at 2pm"
Email: Auto-responder "Checking email at 12pm and 4pm"
Phone: Do Not Disturb mode
Calendar: Block as "Focus Time"

Physical Environment

Optimize:

•Clean desk (no clutter)
•Good lighting (natural if possible)
•Comfortable temperature (68-72°F)
•Noise management (headphones, white noise)
•Ergonomic setup (prevent discomfort)

Focus Music:

•Instrumental music
•Lo-fi beats
•Nature sounds
•Binaural beats
•Silence (sometimes best)

Energy Management

Peak Performance Times

Identify Your Peak:

code

Morning person: 8am-12pm (deep work here)
Evening person: 2pm-6pm (deep work here)

Track for 2 weeks:
- When do you feel most alert?
- When do complex problems feel easier?
- When do you get into flow?

Match Tasks to Energy:

code

High Energy:
  - Complex problem-solving
  - Architecture design
  - Learning new concepts

Medium Energy:
  - Code review
  - Refactoring
  - Documentation

Low Energy:
  - Email responses
  - Meeting notes
  - Administrative tasks

Break Strategies

Micro Breaks (every 30 min):

code

- 30 seconds: Look away from screen (20-20-20 rule)
- Stand up and stretch
- Deep breathing (5 breaths)

Short Breaks (every 90-120 min):

code

- 5-10 minutes
- Walk around
- Hydrate
- Quick snack
- Step outside

Long Breaks (every 4 hours):

code

- 30-60 minutes
- Real meal
- Exercise
- Nature walk
- Power nap (20 min)

Measuring Focus

Track Metrics

typescript

interface FocusSession {
  date: Date;
  duration: number;  // minutes
  task: string;
  quality: 1 | 2 | 3 | 4 | 5;  // subjective rating
  distractions: number;
  output: string;  // what you completed
}

// Weekly analysis
function analyzeFocusQuality(sessions: FocusSession[]): {
  averageQuality: number;
  totalFocusTime: number;
  bestTimeOfDay: string;
  distractionsPerSession: number;
} {
  // Analyze patterns
}

Indicators of Good Focus

✅ Completed planned tasks ✅ Few distractions (< 3 per hour) ✅ Time flew by ✅ Quality output ✅ Felt energized, not drained ✅ Clear progress made

Indicators of Poor Focus

❌ Frequent task switching ❌ Checking phone/email repeatedly ❌ Time dragging ❌ Low quality work ❌ Exhaustion without progress ❌ Procrastination

Quick Reference

Starting a Focus Session

code

1. [ ] Clear goal defined
2. [ ] Timer set
3. [ ] Distractions eliminated
4. [ ] Water/coffee ready
5. [ ] Bathroom break taken
6. [ ] Phone on DND
7. [ ] Communication boundaries set

Best Technique for Each Scenario

Scenario	Best Technique
Bug fixing	Pomodoro (25 min)
New feature	Deep Work (2-4 hrs)
Learning	Pomodoro + Note-taking
Code review	Batch Processing
Complex algorithm	Deep Work + Flow
Documentation	Time Blocking
Admin tasks	Batch Processing
Design/Architecture	Deep Work

Output Format

When providing focus guidance:

code

## Focus Plan: ${Task}

**Recommended Technique**: ${technique}

**Duration**: ${duration}

**Preparation**:
- ${prep1}
- ${prep2}

**During Session**:
1. ${step1}
2. ${step2}

**Success Criteria**:
- ${criteria1}
- ${criteria2}

Related Skills

•time-management: For daily/weekly planning
•task-breakdown: For complex tasks
•energy-optimization: For peak performance
•habit-building: For consistency