home / skills / coowoolf / insighthunt-skills / lno-time-management

lno-time-management skill

/decision-thinking/lno-time-management

This skill helps you prioritize work by classifying tasks as Leverage, Neutral, or Overhead to focus perfectionism on high-impact work.

npx playbooks add skill coowoolf/insighthunt-skills --skill lno-time-management

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.4 KB
---
name: LNO Time Management Framework
description: Categorize tasks into Leverage (10x), Neutral (1x), and Overhead (<1x) to escape the trap of treating all tasks as equally important. Apply perfectionism only to L tasks.
---

# The LNO Framework

> "The mistake is that we treat all tasks as created equal. They are not." — Shreyas Doshi

## What It Is

Categorize tasks into **Leverage (L)**, **Neutral (N)**, and **Overhead (O)**. Strive for perfection only on L tasks (10x-100x impact). For N and O tasks, "good enough" is the goal.

## When To Use

- **Daily prioritization** decisions
- When feeling **overwhelmed by to-do lists**
- To escape the trap of **treating all tasks as equally important**
- When you notice perfectionism is **burning time on low-value work**

## Core Principles

### Task Classification Matrix

| Type | Impact | Approach | Examples |
|------|--------|----------|----------|
| **L** (Leverage) | 10x-100x | Apply perfectionism | Strategy docs, key PRDs, hiring decisions |
| **N** (Neutral) | 1x | Good enough | Standard code reviews, routine meetings |
| **O** (Overhead) | <1x | Minimum viable | Expense reports, calendar scheduling |

### Key Insights

1. **Identify L Tasks** — These are high leverage with 10x impact. Apply all your perfectionism here.

2. **Speed Through N/O Tasks** — Neutral and Overhead tasks (1x or <1x impact) should be done strictly "good enough" or delegated.

3. **Placebo Productivity** — Use N/O tasks to build momentum before tackling a scary L task.

## How To Apply

```
STEP 1: List Today's Tasks

STEP 2: Tag Each Task
└── L = Will this 10x something important?
└── N = Needs to be done, but standard work
└── O = Administrative / no direct impact

STEP 3: Allocate Time
└── L tasks: Block 2-3 hours of deep work
└── N tasks: Batch into 30-min windows
└── O tasks: Automate, delegate, or do in 5 min

STEP 4: Resist Perfectionism on N/O
└── Set timer limits
└── "What's the minimum acceptable here?"
```

## Common Mistakes

❌ Applying perfectionism to O tasks (spending hours on expense reports)

❌ Defaulting to N/O tasks because they feel productive and safe

❌ Not recognizing that the same task type can shift categories based on context

## Real-World Example

Writing a bug report can be an **L task** (if it's a critical, complex failure) or an **O task** (standard minor bug), and should be treated differently.

---
*Source: Shreyas Doshi, Lenny's Podcast*

Overview

This skill teaches the LNO Time Management Framework: categorize tasks into Leverage (L), Neutral (N), and Overhead (O) so you stop treating every item as equally important. It focuses perfection and deep work on L tasks while driving speed, batching, delegation, or automation for N and O tasks. The result is higher-impact output with less busywork and reduced perfectionism burnout.

How this skill works

You list tasks, tag each as L (10x impact), N (1x), or O (<1x), and allocate time according to impact. L tasks get blocked deep-work time and high-quality focus; N tasks are handled “good enough” in short batches; O tasks are automated, delegated, or completed in minimal time. Built-in checks prevent perfectionism on low-impact work and help you use easy tasks as momentum before tackling big ones.

When to use it

  • Daily prioritization and planning
  • When to-do lists feel overwhelming
  • If you notice perfectionism on low-value work
  • Before scheduling deep-work blocks
  • When deciding what to delegate or automate

Best practices

  • Start each day by tagging tasks L / N / O and be strict about definitions
  • Block uninterrupted 2–3 hour sessions for each L task
  • Batch N tasks into timed windows (e.g., 30 minutes) to avoid context switching
  • Automate or delegate O tasks; set a 5–10 minute max if you must do them
  • Ask “Will this 10x something important?” to identify true L work

Example use cases

  • Preparing a major product strategy doc: tag as L and schedule a deep-work block
  • Routine code reviews: treat as N and batch them into a single afternoon window
  • Filing expense reports: tag as O and automate or delegate
  • Writing a bug report: classify as L if it blocks major revenue/users, otherwise handle as O
  • Hiring decisions and PRDs: L — apply rigorous review and iteration

FAQ

How do I decide if something is truly L (10x)?

Ask whether completing this task will multiply impact by an order of magnitude (remove major bottlenecks, enable new revenue or scale). If unsure, treat it as N and reassess after a quick spike of investigation.

Won’t ignoring N/O tasks create problems?

No—schedule short regular windows for N tasks and automate/delegate O tasks. The framework prevents neglect by allocating minimal time while preserving focus on high-impact work.