The thousand token rule

Chapters

• Good practices, finally at low cost 

  Why good software practices have always worked but were too expensive to follow consistently, and how AI changes the economics.
• Iterate where it's cheap 

  Quantifying iteration costs across development phases. Token economics, defect remediation multipliers, and when the thousand token rule breaks down.
• Requirements as constraints 

  Writing requirements that constrain implementation. Includes complete template, refinement techniques, and before/after examples.
• Planning variants 

  How planning changes for debugging, investigation, and modification work. Hypothesis-driven and archaeological approaches.
• Technical planning 

  From requirements to technical approach. Library evaluation, architecture decisions, interface design, and failure mode analysis.
• Test planning 

  Systematic planning before writing tests. Edge case identification, failure mode enumeration, and coverage goals.
• Stubs as specification 

  Code structure without implementation. Type signatures, documentation, and assertions as executable specs.
• Interface first contracts 

  Treating internal boundaries like external APIs. The companion file pattern and dependency management.
• Machines checking machines 

  Automated verification of AI-generated code. Build repeatable pipelines and configure tools for signal over noise.
• Languages and feedback quality 

  How language choice affects AI effectiveness. Comparing feedback loops across Rust, TypeScript, Go, and Python.
• Unit tests as contract 

  Test-driven development with AI. Writing tests against stubs, property-based testing, and when tests reveal design problems.
• Integration and end to end tests 

  Beyond unit tests. The testing pyramid, environment management, and test isolation strategies.
• Implementation as formality 

  When implementation feels inevitable. The constraint check and recognizing when to go back instead of improvising.
• One function at a time 

  Small increment implementation. The implement-test-commit rhythm and model routing for cost optimization.
• Context management 

  Structuring code for limited context windows. Context budgets, the companion file pattern, and module sizing.
• Audit and triage 

  Post-implementation verification. Specialized audits, the audit loop, and prioritizing findings.
• Review by exception 

  Focusing human attention. Change classification, risk-based review, and auto-commit criteria.
• Guided review 

  AI-assisted human review. Pre-review explanations, catching inconsistencies, and cost-benefit analysis.
• Plans become documentation 

  Evolving planning artifacts into long-term docs. The documentation lifecycle and avoiding duplication.
• The feedback loop 

  Improving the process over time. Metrics, template evolution, and knowing when to break the rules.