first-principles-pm

First-Principles Project Management

High-efficiency project management based on first principles thinking.

Core Philosophy

"The best part is no part. The best process is no process."

Every requirement, feature, and process must justify its existence. Default to deletion, not addition.

The 5-Step Algorithm

Apply these steps in order. Do not skip ahead.

Step 1: Question Every Requirement

Goal: Make requirements less stupid.

For each requirement, ask:
├── Who requested this? (Get a name, not a department)
├── Why is this needed? (What problem does it solve?)
├── What happens if we don't do it?
├── Is this the simplest way to solve the problem?
└── Can we achieve 80% of the value with 20% of the effort?

Actions:

• Challenge assumptions, especially from "smart people"
• Requirements from experts are often the most dangerous
• If you can't name the person who requested it, question it harder

Step 2: Delete Parts and Processes

Goal: Remove everything that doesn't absolutely need to exist.

Deletion checklist:
├── Can we remove this feature entirely?
├── Can we remove this step in the process?
├── Can we remove this configuration option?
├── Can we remove this abstraction layer?
└── Can we remove this edge case handling?

Validation rule: If you don't end up adding back at least 10% of what you deleted, you didn't delete enough.

Actions:

• Delete first, ask questions later
• It's easier to add back than to remove
• Bias heavily toward deletion

Step 3: Simplify and Optimize

Goal: Make remaining parts as simple as possible.

Simplification priorities:
├── Reduce parameters and options
├── Use conventions over configuration
├── Merge similar functionality
├── Flatten hierarchies
└── Remove indirection

Warning: Do NOT simplify or optimize something that should not exist. Complete Steps 1-2 first.

Step 4: Accelerate Cycle Time

Goal: Move faster through validated work.

Acceleration tactics:
├── Shorter feedback loops
├── Smaller batch sizes
├── Parallel execution where possible
├── Remove approval bottlenecks
└── Automate repetitive checks

Warning: Do NOT accelerate something that should not exist. Complete Steps 1-3 first.

Step 5: Automate

Goal: Automate only what remains after Steps 1-4.

Automation candidates:
├── Repetitive manual tasks
├── Error-prone processes
├── Testing and validation
├── Deployment and packaging
└── Monitoring and alerting

Warning: Automating a bad process just makes bad things happen faster.

Project Workflow

Phase A: Discovery (Question)

inputs:
  - Raw requirements or problem statement

activities:
  - [ ] Identify the core problem (not the proposed solution)
  - [ ] List all stated requirements
  - [ ] For each requirement: Who? Why? What if not?
  - [ ] Identify hidden assumptions
  - [ ] Define success criteria (measurable)

outputs:
  - Validated problem statement
  - Prioritized requirements (P0/P1/P2)
  - Success metrics

Phase B: Scope Reduction (Delete)

inputs:
  - Validated requirements from Phase A

activities:
  - [ ] Challenge each P1/P2 requirement
  - [ ] Identify MVP (P0 only)
  - [ ] Remove nice-to-haves ruthlessly
  - [ ] Question each data field, API endpoint, UI element
  - [ ] Document what was deleted and why

outputs:
  - Minimal viable scope
  - "Not doing" list (explicit)
  - Deletion log for review

Phase C: Design (Simplify)

inputs:
  - Minimal scope from Phase B

activities:
  - [ ] Design simplest possible solution
  - [ ] Reduce configuration options
  - [ ] Use existing patterns/libraries
  - [ ] Avoid premature abstraction
  - [ ] Plan for iteration, not perfection

outputs:
  - Simple design document
  - Technical approach
  - Implementation plan

Phase D: Execution (Accelerate)

inputs:
  - Design from Phase C

activities:
  - [ ] Break into small, deliverable chunks
  - [ ] Implement in priority order
  - [ ] Get feedback early and often
  - [ ] Ship incrementally
  - [ ] Iterate based on real usage

outputs:
  - Working software
  - User feedback
  - Iteration backlog

Phase E: Polish (Automate)

inputs:
  - Working software from Phase D

activities:
  - [ ] Automate testing
  - [ ] Automate deployment
  - [ ] Add monitoring
  - [ ] Document (only what's needed)
  - [ ] Optimize based on real data

outputs:
  - Production-ready software
  - Automated pipelines
  - Operational runbooks

Anti-Patterns to Avoid

Decision Framework

When facing a decision, ask in order:

1. Can we not do this at all? → Delete
2. Can someone else do this? → Delegate/Use existing
3. Can we do less? → Reduce scope
4. Can we do it simpler? → Simplify
5. Can we do it faster? → Accelerate
6. Can we automate it? → Automate

Metrics That Matter

Focus on outcomes, not activity:

Quick Reference

┌─────────────────────────────────────────────────────┐
│  FIRST-PRINCIPLES 5-STEP ALGORITHM                  │
├─────────────────────────────────────────────────────┤
│  1. QUESTION  → Make requirements less stupid       │
│  2. DELETE    → Remove parts and processes          │
│  3. SIMPLIFY  → Optimize what remains               │
│  4. ACCELERATE → Speed up the cycle                 │
│  5. AUTOMATE  → Only after steps 1-4                │
├─────────────────────────────────────────────────────┤
│  ⚠️  DO NOT skip steps or reverse order             │
│  ⚠️  DO NOT optimize what should be deleted         │
│  ⚠️  DO NOT automate bad processes                  │
└─────────────────────────────────────────────────────┘