Thinking Better with Code: Using Mathematical Shortcuts to Master Large Codebases

Inspired by Marcus du Sautoy’s “Thinking Better: The Art of the Shortcut”

🚀 Introduction

Opening a massive codebase can feel like staring into chaos. Thousands of files, layers of logic, endless functions—it’s tempting to brute-force your way through and read everything.

But as mathematician Marcus du Sautoy shows in Thinking Better: The Art of the Shortcut, progress doesn’t come from brute force. It comes from shortcuts—clever strategies that skip wasted effort while still getting us to the right result.

This post explores how to apply mathematical shortcuts to understand and customize large software projects faster and with less pain.

🧩 Shortcut #1: Patterns & Symmetry → Spot the Repeats

Mathematicians love symmetry because it reveals hidden structure. Software systems also have repeating shapes.

👉 How to use it:

Look for feature folders or repeated app structures.
In Django: each app has the same skeleton (models.py, views.py, serializers.py).
In Vue: each feature has its own routes.ts, api.ts, views/.

Shortcut: Once you understand one, you understand them all.

🧩 Shortcut #2: Abstraction → Strip to the Essentials

Abstraction is about ignoring details until the structure appears. In code, that means mapping modules and data flow.

👉 How to use it:

Generate an imports graph (Python: pyan3 … > imports.dot).
Scan for data contracts (BaseModel, Serializer, Schema)—these define the real boundaries.

Shortcut: Instead of chasing functions, see the network of relationships.

🧩 Shortcut #3: Probability & Sampling → Read the Most Likely Files

Probability avoids checking everything—just a smart sample. Same with codebases: not every file matters.

👉 How to use it:

Find largest + most-edited files with:

git log --name-only --pretty=format: | sort | uniq -c | sort -nr | head -50

Read those first—they usually encode the critical business logic.

Shortcut: Learn the heart of the system in hours, not weeks.

🧩 Shortcut #4: Algorithmic Thinking → Index, Then Query

Mathematicians use algorithms to skip manual effort. Developers should too.

👉 How to use it:

Index code with LSP, Treesitter, and ctags.
Write ripgrep queries for recurring questions:
- Routes: rg "router\.|urlpattern".
- Object creation: rg "Factory|create\(".
- Side effects: rg "requests\.|axios\(".

Shortcut: Stop scrolling—start querying.

🧩 Shortcut #5: Invariants → What Must Never Change

Math proofs lock down truths. In software, invariants do the same.

👉 Examples:

Database schema rules.
API request/response formats.
Permissions and roles.
Event names.

Shortcut: Write quick contract tests to guard them before customizing.

🛠️ Customization Shortcuts

Once shortcuts reveal the structure, you can attach new logic without breaking the core.

Django Seams:
- Middleware → global concerns (logging, IDs, auth).
- Signals → trigger side effects.
- Serializers → adjust API payloads.
- Management commands → operational hooks.
Vue Seams:
- Axios interceptors → request/response shaping.
- Router guards → authentication and feature flags.
- Feature folders → extend with symmetry.

🔀 Decision Shortcut: Where Should You Customize?

Here’s a visual shortcut for deciding whether to attach to an existing seam, or fork core code:

flowchart TD
    A["Need new behavior?"] --> B{"Is there a seam?<br/>(middleware / signal / interceptor / plugin)"}
    B -- Yes --> C["Attach adapter / plugin<br/>(use seam)"]
    B -- No --> D{"Can it be wrapped?"}
    D -- Yes --> E["Create facade / service layer<br/>around existing code"]
    D -- No --> F["Minimal fork or patch<br/>(last resort)"]
    C --> G["Leave core untouched"]
    E --> G
    F --> H["Document & test heavily"]

Shortcut: Default to seams → wrappers → forks only if absolutely necessary.

⏱️ The 90-Minute Repo Playbook

0–10 min: Skim README, configs, and folder tree. Draw the symmetry map.
10–30 min: Build imports graph, note entry points & data contracts.
30–60 min: Sample top 10 files by churn. Identify invariants.
60–90 min: Plan customization through seams. Write smoke tests.

🎯 Conclusion

Large codebases can feel like mazes, but mathematics shows us mazes always have shortcuts. By applying ideas like patterns, abstractions, probability, algorithms, and invariants, we move from brute-force reading to strategic understanding.

With these shortcuts, you don’t just survive legacy systems—you bend them to your needs without breaking their core.

That’s the art of thinking better with code.