Liskov developed her famous principle by analyzing Smalltalk's inheritance. Her research group focused on defining modules by their specified behavior, not their internal implementation. This perspective allowed her to solve a problem the implementation-focused OOP community was struggling with: a subclass must behave like its superclass to be substitutable.

As AI handles low-level coding, Barbara Liskov suggests the crucial human skill will be working at a higher level of abstraction. The future engineer's role will involve design, modularity, and verification to ensure the systems AI builds are correct, safe, and meet specifications, rather than focusing on implementation minutiae.

The term "formal methods" isn't a single, complex technique but a range of mathematical approaches. Many developers already use them via simple tools like Java's type checker (weak guarantees, easy to use), while full functional correctness requires PhD-level interactive theorem provers (strong guarantees, high cost).

To prevent a "ball of mud" codebase, OpenAI's system defines strict architectural layers using package boundaries and folder structures. By convention and tooling, different roles are restricted to specific layers—designers to the UI, PMs to business logic—ensuring modularity and preventing architectural decay.

Expert mathematicians adopt formal tools like Lean not primarily to catch errors, but to offload tedious, low-level deductions. This automation allows them to operate at a higher level of abstraction and focus their cognitive energy on creative intuition and problem-solving strategy.

In imperative code, functions can silently read or write shared global variables, creating invisible and dangerous dependencies. Functional programming forces these interactions to be explicit (e.g., through function arguments or monads), encouraging a more modular and less coupled design that is easier to reason about and maintain over time.

Instead of treating a complex AI system like an LLM as a single black box, build it in a componentized way by separating functions like retrieval, analysis, and output. This allows for isolated testing of each part, limiting the surface area for bias and simplifying debugging.

Python's design allows external code to modify a module's internal state. Liskov argues this is a critical flaw for large projects, as it relies on every programmer's discipline rather than compiler-enforced rules. Without encapsulation, the system's integrity is vulnerable to the least-skilled member of the team.

Use Occam's Razor to pursue the simplest solution, but counter it with 'Irreducibility' to protect essential components from being removed. This pairing helps find the sweet spot between clarity and completeness, creating systems that are simple enough to work but complete enough to be relied upon.