Click any tag below to further narrow down your results
+ llm
(2)
+ andrej karpathy
(1)
+ software 3.0
(1)
+ natural language programming
(1)
+ code review
(1)
+ dyadic scanning
(1)
+ reading code
(1)
+ socratic code mentor
(1)
+ learning
(1)
+ motivation
(1)
+ spaced practice
(1)
+ deliberate practice
(1)
+ the pragmatic programmer
(1)
+ andrew hunt
(1)
+ david thomas
(1)
Links
A 1999 book by Andrew Hunt and David Thomas offering practical tips on software development rather than a formal theory. It introduced or popularized ideas like DRY and rubber duck debugging, and a 2019 20th-anniversary edition updated it for modern tools and practices.
- The book is a collection of pragmatic tips, not a systematic theory, built around analogies and short stories like broken windows, stone soup, and the boiling frog.
- It describes a pragmatic programmer through traits such as early adoption, fast adaptation, inquisitiveness, critical thinking, realism, and being a jack-of-all-trades.
- It coined or popularized DRY (don't repeat yourself) and rubber duck debugging, and it is still used as a university textbook.
Code isn't like reading a book — execution order matters more than readability, and you're usually reading diffs not complete programs. The best approach is multiple passes through different code paths rather than front-to-back reading, and you still need to do this yourself even with AI-generated code.
- Code has three structural differences from English: execution order is determined by the computer not the reader, you read diffs (incremental changes) not finished products, and dependencies span entire codebases while grammatical dependencies stay within paragraphs.
- The "dyadic scanning" technique works better than sequential reading: make multiple passes tracing specific code paths (like the happy path), then fan out to understand how functions are used across call-sites, before doing a final careful end-to-end read.
- AI-generated code still requires careful human review because LLMs make alignment errors (solving problems that don't exist, over-engineering solutions) that don't show up as bugs but violate your engineering values.
LLMs have made it too easy to skip the struggle that actually builds learning, so the author rebuilt his approach: use LLMs as Socratic mentors that ask questions instead of giving answers, delegate boring grunt work, plan projects in phases to stay motivated, and make progress visible to maintain curiosity.
- The core problem: LLMs can one-shot solutions, removing the productive struggle your brain needs to actually learn and retain information—you have to force yourself to work through problems first, then use LLMs to explain concepts you're stuck on.
- Use LLMs as a Socratic mentor, not a code generator: ask it to ask you questions that lead you to the answer yourself, which makes the lesson stick far better than being handed the solution.
- Plan your learning projects in detailed phases with clear goals and checkboxes before you start; this kills procrastination and lets you resume work with zero willpower, plus spaced practice across short sessions actually cements learning better than marathon grinding.
- Build visible progress into your project—a REPL, UI, benchmark chart—to maintain motivation and curiosity; the author's LSM-tree compaction code making reads 100× faster was what kept him engaged.
@neil_xbt on X
Neil (@neil_xbt) argues that Andrej Karpathy has framed a new era of software, where natural language is the programming interface, LLMs act as the computer, and prompts serve as code. The post is a hype-heavy thread built on Karpathy's Software 1.0/2.0/3.0 framing, with little detail beyond that framing itself.
- Software 1.0 was hand-written explicit code, Software 2.0 was trained neural network weights, and Software 3.0 is English prompts run on LLMs.
- The post claims the history of software was a workaround for computers not understanding humans, and that workaround is now optional.
- The author promises a 40-minute explanation but the post itself offers only the three-stage framing and no evidence or examples.