Lena Park

Every productivity framework promises a better you. The one that actually works looks nothing like the ones being sold.

Code generation models predict plausible syntax, not working software. Understanding that distinction changes how you should use them.

Parkinson's Law isn't just about bureaucracy. It's quietly governing your most valuable technical work, and you're probably helping it.

Canceling a meeting isn't procrastination. It's often the most productive decision you'll make all day, and here's the mechanism that explains why.

If a bug only shows up once and then vanishes, that's not luck. That's a system telling you something about its own hidden complexity.

Most task managers are optimized for capture, not completion. The design choices that make adding tasks frictionless are the same ones that bury the work that actually matters.

Bigger AI models aren't always better. Smaller, focused models are faster, cheaper, and often more accurate at the tasks that actually matter.

A fintech team shipped faster than ever with AI assistance. Then a senior engineer left and nobody could explain the codebase. A cautionary pattern worth taking seriously.

Model collapse is real, measurable, and already happening in the wild. Here's what it looks like mechanically and why it matters.

Starting fresh feels productive. It almost never is. The real leverage is in closing out what's already in motion.

A look at how Basecamp restructured around unscheduled communication and what it reveals about the hidden cost of synchronous coordination.

LLMs generate code by predicting plausible text, not by reasoning about execution. Understanding that gap changes how you use them.

Completion feels like progress. But a finished list just means you did everything you planned, not that you planned the right things.

Every line of code you keep is a liability. The best engineers know that removing code is often the highest-value work they can do.

AI models don't hedge at the edges of their knowledge. They extrapolate smoothly and state the result as fact. Here's what's actually happening.

Most task managers are optimized for capture, not completion. The design choices that make adding tasks effortless are the same ones making finishing them harder.

Getting better at productivity systems often produces more tasks, not fewer. Here's the mechanism, and what to do about it.

Canceling a bad meeting feels productive. But the real problem is that you scheduled it in the first place, and probably will again.