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:

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:

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:

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