Developer Thinking Frameworks
Engineering frameworks from the developers who shaped how software is actually built — distilled into .md skill files for Claude, ChatGPT, and every LLM.
Software is built twice: once in the head, once in the editor. The developers in this collection left behind documented working methods for the first half — the part that decides whether the second half is worth doing. Carmack reasons from the actual machine, not the abstraction the language presents. Karpathy treats neural networks as a new kind of programming and writes his own teaching material rather than wait for textbooks. Linus Torvalds defends technical decisions in public correspondence that doubles as a design rationale. Grace Hopper insisted compilers were possible while peers said they weren't, then wrote one. Margaret Hamilton coined the phrase software engineering on the Apollo programme and treated reliability as a discipline rather than a hope. Barbara Liskov gave us the substitution principle that still underwrites every type system worth using. Use them when you're choosing an architecture that has to last, deciding what to build versus compose, prioritising which technical debt is real, or pressure-testing a design before someone ships it.
How developers think
- First-principles engineering — strip the abstraction and reason about what the machine is actually doing before optimising the inherited solution
- Simplicity as discipline — separate the easy from the simple; the most engineered code is the code you didn't have to write
- Strong opinions, weakly held — defend a technical position in detail until evidence forces revision, not before
- Tools shape thought — the language, the editor, the diff format quietly bound what a team is able to consider
- Reliability as a practice — the bug not written is faster than any optimisation, and cheaper than any incident review
Frameworks in this category
John Carmack
First-Principles Engineering & Obsessive Focus
Andrej Karpathy
Software 2.0/3.0 & Neural Network Pedagogy
Linus Torvalds
Pragmatic Engineering & Strong Opinions
Rich Hickey
Simplicity & Decomplecting
Grace Hopper
Compiler Pioneering & Plain-Language Computing
Margaret Hamilton
Software Engineering as Discipline & Mission Reliability
Barbara Liskov
Abstraction & Behavioural Subtyping
Tim Berners-Lee
Open Standards & Decentralised Architecture
David Heinemeier Hansson
Conceptual Compression & Convention Over Configuration
Donald Knuth
Literate Programming & Mathematical Rigour
Joel Spolsky
Developer Experience & The Joel Test
Brian Kernighan
Unix Philosophy & Tool Composition
Radia Perlman
Network Architecture & Spanning Tree
Frances Allen
Compiler Optimization & Algorithmic Foundations
When to use these frameworks
- Designing an architecture that needs to outlive the team currently building it
- Deciding whether to build, buy, or compose tools for a problem you'll own for years
- Working out which technical debt is worth paying down and which is worth accepting
- Making a language, framework, or platform choice the next team will inherit
- Pressure-testing a junior engineer's design before they ship it into production
Start here
Andrej Karpathy
Software 2.0/3.0 & Neural Network Pedagogy
Adjacent thinking
Frequently asked questions
Which developer framework is best for someone new to engineering?
Joel Spolsky and Brian Kernighan. Spolsky writes for working developers about the everyday decisions that compound — what good developer experience looks like, why specs matter, how to spot a healthy codebase. Kernighan's Unix philosophy gives you a small set of composable rules for writing software that other people can read. Karpathy's lectures are excellent once you have the basics and want to understand modern AI engineering specifically.
Are these useful if I'm not writing code professionally?
Yes. Engineering thinking transfers cleanly to product management, design, and founding work. The Liskov substitution principle is a useful test for any abstraction. Torvalds's bug-tracking discipline maps onto incident reviews of any kind. Hamilton's mission-reliability framing is how senior operators think about uptime, supply chains, and regulatory exposure. The frameworks are about reasoning under technical constraint; that constraint shows up everywhere modern work does.
Can these replace formal computer science education or a senior mentor?
No. These frameworks describe how experienced developers think, which is useful scaffolding, but they can't substitute for the slow craft of reading and writing real code under feedback from someone who's seen more incidents than you have. Use them as discussion material with a mentor or as orientation when prioritising what to study; not as a syllabus that replaces the work.
How do you handle the fact that some of these developers (Torvalds, DHH) are known for combative communication styles?
The framework captures the thinking pattern, not the tone. Torvalds's technical judgement on kernel architecture is worth studying separately from how he writes mailing list replies; DHH's argument for conceptual compression stands whether or not you'd want to work with him. Separate the signal from the style — these files document the engineering reasoning, and we're explicit when an approach has interpersonal costs the person in question chose to absorb.
Save when you build a bundle.
Mix and match across categories. 4 for $14.99 (save 25%) or 10 for $29.99 (save 40%).
Browse all 459 frameworks →