The Second-Time Rule: Turn Fixes Into Systems

Show Notes

The second time you do something, turn it into a protocol. One-time work that pays off each time. A rule for turning fixes into lasting systems.

Featuring: James Clear, Ali Abdaal, Matt Gray

Watch on YouTube

Read the full post

Brought to you by:

Trends.vc: Discover new markets and opportunities. https://trends.vc/

HeadsUp: Know when your competitors move. Before your customers do. https://headsup.bot

Multi: Turn any content into a YouTube video. https://makemulti.com

Where to find Dru:

Essays: https://druriley.com/
X: https://x.com/DruRly
YouTube: https://www.youtube.com/@dru-notes
Apple Podcasts: https://podcasts.apple.com/podcast/drus-notes/id1888795427
Spotify: https://open.spotify.com/show/3lFHqgKxuvEHmdiEUfYShG

Subscribe to Dru's Notes for a new episode every day.

Creators and Guests

Host

Dru Riley

Founder of Trends.vc

AA

Guest

Ali Abdaal

Featured in Dru's Notes: The Second-Time Rule: Turn Fixes Into Systems.

JC

Guest

James Clear

Featured in 2 Dru's Notes episodes.

MG

Guest

Matt Gray

Featured in Dru's Notes: The Second-Time Rule: Turn Fixes Into Systems.

What is Dru's Notes?

One mental model each day in a few minutes. Habits, business, building products and thinking clearly. From Dru Riley, founder of Trends.vc.

Last week I caught myself about to make a one-time fix.

I was working on Multi, the tool that turns content into YouTube videos. An agent added a high-priority item to the product backlog. The backlog sorts by arrival time, so the high-priority item landed at the bottom.

My instinct was to drag it to the top. Five seconds, problem solved. But tomorrow another agent adds another item and it sinks to the bottom again.

I fixed the source instead and added a prioritization protocol to the top of the backlog file: priority tiers, ordering rules. Now any agent that touches the backlog reads the protocol and places the item where it belongs.

I did the work once. It pays off each time.

Each problem gives you two options. You can patch the instance or write the protocol that handles each future version.

A patch solves it once. Next time the same problem shows up, you patch again.

A protocol solves the source. Next time the same problem shows up, the protocol handles it automatically.

Rule of thumb: the second time you do something, turn it into a protocol. The first time is discovery. The second time is when you build a rule.

What's one repeat problem you could solve at the source?