What my dad taught me about AI coding in the 90s
TL;DR Highlight
Own the architecture and interfaces like a blindfold chess player, and let the LLM handle implementation details.
Who Should Read
A developer unsure how much to delegate to coding agents like Claude Code and how much to read themselves
Core Mechanics
- Delegate less code, keep the structure
- The author argues you should let the LLM write less code than you think.
- He says you need skills similar to a blindfold chess player.
- Think in positions, not lines
- Blindfold players don't memorize the whole board; they rebuild it from patterns like key piece placement and attack/defense relations.
- Good programmers likewise work from a mental model of architecture, components and interfaces rather than individual lines.
- Unfollowable pace means no understanding
- Previously code was planned and written at a digestible pace, which built the mental model.
- If an LLM builds code faster than you can follow, you lose deep understanding and get alien code, or slop.
- You design interfaces, the LLM implements
- The author often designs interfaces and components himself, then hands them to the LLM to implement.
- He says it isn't always obvious which decisions are positions versus details, and he's still learning.
Community Reactions
- Counterpoint: LLMs are non-deterministic, unlike chess
- One commenter says blind chess gives deterministic board state, so mental updates can be precise.
- They note LLMs are unpredictable even at temperature 0, and being blind to results quickly yields a system you don't understand.
- Opinion: not seeing results is just vibe coding
- A commenter who uses AI daily says they wouldn't trust it with safe system-level code.
- They compare it to believing 'checkmate' without hearing the moves.
- Experience: a barely-read trading system worked
- One commenter vibe coded a hobby trading system from their phone and verified it via benchmarks and order/fill checks.
- They don't know its internal structure but know which aspects were considered, and say experiences differ by readiness.
- Experience: interface violations bit them
- A commenter says if you can't look at the code, interfaces must constrain the implementation or leaky abstractions will bite.
- They gave an example where the interface allowed race conditions in a distributed system but the implementation didn't.
How to Apply
- Write the interface before the next feature
- Pick one task to delegate today and write the function signatures and component boundaries yourself.
- Then tell the agent to implement that interface.
- Check agent reports against your model
- When the agent summarizes its work, mark parts that don't match the structure you know.
- Open code only at those mismatches.
- List positions versus details
- Write down what you decide yourself (architecture, interfaces) and what you delegate (implementation details) for your codebase.
- Use the list to decide what to read in reviews.
Try It
# Paste into Claude Code or ChatGPT (simplified version of the article's idea)
You are a coding agent. I define the interfaces and component boundaries; you handle the implementation.
[Interface I defined]
{{interface/signatures}}
[Requirements]
{{feature description}}
Instructions:
1. Do not change the interface; only write the implementation.
2. Do not add behavior that isn't in the interface.
3. When done, report 'what you changed' and 'points that may not fit my mental model of the structure', each in 3 lines or fewer.
Next step: if the report flags mismatches, open only those files and check themTerminology
Related Papers
AI is a tool and using it well takes skill
A rebuttal to Hickey: LLMs are tools, and skill in directing and checking them decides the outcome
Reflective Prompt Optimization of a Deep-Research Agent: A Topic-Disjoint, Multi-Seed Protocol for Measuring Transferable Gains and Prompt-Level Overfitting
Reflective prompt optimization raised held-out citation reward from 0.702 to 0.781 on a deep-research agent.
GPT‑6 and Intelligent UI for everyone
GPT-6 reportedly adds generated UI to chat; with no article text, only comment reactions are available.
Base Models Can Reason By Taking a Cue From Training Data
Prefilling just two opening tokens lifted Olmo-3-7B's MATH-500 accuracy from 42% to 78%.
Labels Override Definitions in Jev-Style Typed Decision Models
Renaming options to A/B raised routing accuracy by +0.1511 over meaningful labels.
How Much Prompt Is Enough? A Blackbox Minimization of Few-Shots in LLMs
Delta debugging trimmed few-shot prompts by 65.3% on average with unchanged propositional output