focus-techniques

name	Focus Techniques
description	Science-backed techniques for maintaining deep focus, managing distractions, and maximizing productive coding sessions

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:

1. Energy Level: High, Medium, Low
2. Distractions: Number and severity
3. Task Complexity: Simple, Moderate, Complex
4. 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:

1. Eliminate physical distractions
2. Close unnecessary apps/tabs
3. Set communication boundaries
4. Prepare water/snacks
5. Ensure comfortable workspace

Step 4: Execute and Monitor

During session:

1. Start timer/tracker
2. Single-task (no context switching)
3. Take scheduled breaks
4. Monitor energy levels
5. Adjust as needed

Focus Techniques

1. Pomodoro Technique

Best for: General coding, learning, documentation

Method:

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:

// 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:

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:

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:

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:

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:

• Phone on Do Not Disturb
• Slack/Email closed
• Calendar blocked
• Task clearly defined
• All resources ready
• Water/coffee prepared
• Bathroom break taken

During Session:

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:

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:

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:

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:

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:

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

How to Enter Flow:

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:

# 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:

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:

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:

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):

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

Short Breaks (every 90-120 min):

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

Long Breaks (every 4 hours):

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

---

Measuring Focus

Track Metrics

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

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:

## 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