notes #17: on learning, prioritisation and long-term planning

Hey friends,

In today’s notes, I hope to share 3 thinking tools that are invaluable for the strategic engineer.

I also managed to finish reading The Pragmatic Programmer recently — a great read for engineers striving to improve their technical and non-technical skills.

Check out my notes below.

🧠 Thinking Tools

1. DiSSS (Tim Ferriss)

The DiSSS framework — Deconstruct, Select, Sequence, and Stakes — is a powerful approach to accelerated learning. For engineers picking up a new framework or tool, this method offers a structured way to focus on what matters. Start by deconstructing the skill into smaller components (e.g. routing, state management, or auth). Then select the few that create the biggest impact. Sequence your learning so it builds naturally. Finally, set up stakes to ensure follow-through—this could mean committing to a project deadline or sharing progress publicly. For technical learners, this keeps things lean and accountable.

80/20 Rule (Pareto Principle)

In software development, not all effort yields equal outcomes. The 80/20 Rule suggests that roughly 80% of results come from 20% of input. In debugging, this often means that reading logs carefully, reproducing bugs reliably, or asking better questions gets you most of the way there. Instead of chasing every possible lead, zoom in on the few causes that likely explain most of the issues. This principle also applies to learning, feature prioritization, and even refactoring—where a small portion of code or time usually offers disproportionate returns.

Compound Thinking

Compounding is a quiet force in engineering. Rather than seeking big wins or sudden breakthroughs, the idea is to build small habits and systems that accumulate value over time. For example: writing one reusable function every week, documenting lessons after each project, or refining tooling that shaves minutes off common tasks. These acts may feel minor in isolation but grow into exponential efficiency and knowledge. In a field that evolves fast, compounding ensures that learning and productivity aren’t reset with each new trend.

📘 Book I’m Learning From: The Pragmatic Programmer

Some lessons I keep coming back to:

🪚 Sharpen Your Saw

Your tools matter. Whether it’s your editor, terminal, or workflow scripts, these are extensions of your mind. A slow or cluttered setup leads to a slow or cluttered output. Investing time to master your environment may feel like overhead, but it compounds in the long run.

💬 Communicate Early and Often

Writing code is one part of the job; communicating intent is the other. From leaving helpful comments to raising blockers before they become emergencies, the ability to communicate clearly is what separates good engineers from great ones.

🔧 Design By Contract

This principle emphasizes that software components should communicate through well-defined contracts—preconditions, postconditions, and invariants. It encourages developers to make explicit what a function expects and guarantees, which in turn makes systems more robust, predictable, and easier to test. For engineers, designing with contracts reduces ambiguity and simplifies debugging by clearly outlining the responsibilities of each component.

Additional Readings

• Estimating Engineering Completion Time: Substack

Each week, I’ll keep showing up with something useful for your mind, your code, and your growth. If it helps, share it with a friend.

Till next week,
Joesurf