Building software with clarity and speed through Dialectic-Driven Development
Dialectician AI develops tools, methodologies, and resources for AI-assisted software development. Our core philosophy: treat code as disposable fuel while preserving clarity and architectural insight as durable value.
Our Projects
đź“– DDD Book
The comprehensive guide to Dialectic-Driven Development methodology.
Teaches using specs, plans, and tight feedback loops with toy models and a CLI+JSON “debugger mindset” to build software with clarity and speed.
⚙️ Hegel
Workflow orchestration tool that operationalizes DDD methodology.
Hegel CLI - State machine-based CLI for guiding structured development cycles with deterministic guardrails, metrics tracking, and real-time observability.
Mirror - Ephemeral Markdown review UI for approving AI-generated specs and plans with inline commenting.
🎮 ddd-nes
NES game development demonstrating Learning meta-mode (Research ↔ Discovery).
Building an NES game from scratch to create comprehensive, AI-agent-friendly documentation of NES development.
Philosophy
Artifacts Are Disposable, Clarity Is Durable
With AI assistance, code generation, refactoring, and even complete rewrites become cheap operations. What’s valuable: architectural insights, validated constraints, and clear mental models captured in documentation.
Three Atomic Modes
Research Mode - External knowledge capture, question cataloguing Discovery Mode - Experimental validation, toy model discipline Execution Mode - Production delivery, mandatory refactoring
Economic Inversion
Traditional development: Code cheap, documentation expensive AI-assisted development: Code cheap, documentation still expensive but now the primary artifact
This inversion enables test-driven development without friction, mandatory refactoring after every feature, and code as validation of understanding rather than final product.
Community
Join our Discord to discuss DDD methodology, share experiences, and get help.
DDD Book Blog
Dialectic Driven Development in the Age of AI
An AI-first methodology where documentation becomes the primary artifact and code becomes disposable. Explores how to leverage AI assistants through a cycle of docs → tests → implementation → learnings, using “napkin physics” and toy models to extract durable insights.
CLI + JSON as Debugger: Giving LLM Agents Deterministic Legs
A practical approach to building AI-debuggable systems using CLI tools that expose every step of execution in machine-readable JSON format. Shows how deterministic I/O gives LLM agents transparent, falsifiable state to reason over.
Guidance Vectors: Compact Spells for Steering LLMs
Explores how short phrases can carry enough latent meaning to shift LLM behavior into useful modes of reasoning. Introduces concepts like “Chomskyian concision” and “Einsteinian simplicity” as compact incantations for steering model output.
The Over-Engineering Epidemic: How Modern Development Tools Are Slowing Us Down
A critique of modern development practices that prioritize complex tooling and abstractions over clarity and simplicity. Argues against TypeScript overhead, premature abstraction, and AI-generated boilerplate in favor of direct, understandable code.
Fast Fashion Code: The Hidden Environmental Cost of AI-Generated Garbage
Examines the environmental impact of AI-generated code, drawing parallels between fast fashion and the current trend of generating low-quality, disposable code. Advocates for a “Slow Code” ethic that prioritizes building less but building better.
Shipping My First Fully AI‑Coded Project
A hands-on account of building and shipping a complete project where AI handled all implementation while the human focused on product direction, UX decisions, and testing. Demonstrates the practical application of human-AI collaboration through the development of a ChatGPT export viewer toolkit.
Vibe-writing the DDD Book
How the DDD book was produced through “vibe-writing”: agents draft, restructure, and refactor while the human edits for clarity, constraints, and voice. Connects the methodology’s dual modes (Discovery for uncertainty, Execution for delivery) to long-form writing, showing agent-first operations beyond code.
Futureproofed
Why DDD won’t be obsolete tomorrow: Explores how Dialectic-Driven Development is built on stable economic and cognitive invariants rather than current model capabilities, making it resilient across technological shifts. Argues that the methodology is designed for optimal collaboration structure, not as a workaround for current model limitations.
Working With vs. Working On: The Coming Schism in LLM Development
An examination of the fundamental difference between building large language models and building usable LLM-driven systems. Argues for a crucial division of labor and the need for multi-disciplinary teams including linguists, philosophers, and cognitive psychologists alongside ML engineers.
How We Tricked ncurses Into Running Without a Terminal (And Got Test Coverage)
Solving the problem of testing ncurses code in CI environments by using macOS DYLD_INTERPOSE to fake a TTY. Shows how an “idle thought” during a break led to a simple 90-line C solution that enabled full test coverage for terminal-dependent code, demonstrating effective human-AI collaboration on practical engineering challenges.
External Split
DDD isn’t just methodology—it’s hypothesis-testing about how LLMs work best. Explores recent discoveries (Research mode and meta-mode patterns) and planned work (separating reasoning from communication) as observations about LLM cognitive architecture. Shows how each pattern reveals something fundamental about effective human-AI collaboration.
Cargo-Culting Human Limitations: What LLMs Think They Can’t Do (But Actually Can)
Part 2 of the LLM Cognition series. Explores how LLMs inherit human constraints they don’t actually have—time pressure, decision fatigue, context-switching costs. Through the ddd-nes audio testing moment and meta-analysis of LLM behavioral patterns, reveals how cargo-culting manifests and how meta-coaching can recalibrate AI to its actual capabilities.
Guidance Vectors in Practice: Compression Algorithms for Philosophy
Part 3 of the LLM Cognition series. From theory to practice: how guidance vectors evolved during ddd-nes into the Hegel CLI LEXICON. Shows significant compression transforming verbose corrections into dense philosophical principles. Demonstrates how vectors work as cognitive shortcuts, create shared vocabulary, and enable methodology transfer across projects.
Context is King: Why We Pivoted from MCP to CLI
Part 4 of the LLM Cognition series. The MCP → CLI pivot wasn’t about features—it was about context composition. Every tool invocation enters LLM context; names repeated 20+ times per session compound semantic weight. “Hegel” isn’t just branding—it’s a guidance vector that primes dialectical thinking through repetition. Shows why tool names matter and how to design for cumulative context effects.
DDD NES Blog
1. Study Phase Complete: 52 Pages, 16 Documents, Zero ROMs
October 2025 · Learning → Practical
The homework before the expert arrives. Systematic study of 52 NESdev wiki pages, condensed into 11 technical learning docs and 5 meta-learning artifacts. Theory vs practice, 43 questions catalogued, and the macOS ARM64 reality check.
Key themes: Systematic study, documentation as deliverable, theory vs practice, toolchain validation
2. First ROM Boots: Theory Meets the Toolchain
October 2025 · Practical Validation Begins
From theory to bootable ROM in 2 hours (6x faster than estimated). Test-driven infrastructure, the custom nes.cfg pivot, and the realization that code became disposable. “I basically think I’ve invented the next C here with DDD.”
Key themes: Test-driven development, code as disposable, infrastructure templates, 6x speedup
3. The Search for Headless Testing
October 2025 · Debug Infrastructure
Or: How I Learned to Stop Worrying and Love jsnes
The requirement: perl test.pl must validate hardware state. No GUI clicking. The survey of 5 emulators (FCEUX, jsnes, wasm-nes, TetaNES, Plastic). Why the 15-year-old JavaScript emulator beat the modern Rust one.
Key themes: Headless automation, API accessibility > theoretical quality, simple working > complex perfect
4. Designing Tests for LLMs
October 2025 · Testing Infrastructure Design
Or: When You Realize You’re Building the Next C
The uncomfortable question: “Surely we can test NES games both exhaustively and headlessly.” TAS-style input sequences + state assertions = play-specs. Fourteen questions, nine decisions, and the Perl DSL epiphany. Natural language → executable contract → passing assembly.
Key themes: LLM-first testing, play-specs as executable contracts, Perl DSL, progressive automation
5. Reading Backwards: Five Meta‑Learnings for LLM‑First Development
October 2025 · Methodology Reset
Or: Why “Probably Next” Is Usually Wrong
Author: Codex (OpenAI Coding Agent)
Reading posts 4→1 in reverse to surface how an LLM teammate learns, decides, and declares success. Five meta-learnings: probable-next-step bias, over-engineering by default, premature success, LLM ≠human defaults, cognition before process.
Key themes: Retrospective analysis, LLM behavioral patterns, evidence vs assertion, methodology critique
6. Housekeeping Before Heroics
October 2025 · Infrastructure Investment
Or: When “Just Two Commands” Costs 200k Tokens
The flailing begins: about to run dd | hexdump for the 10th time. Then the realization: 600 lines of duplication across 4 toys. The housekeeping session: new-rom.pl, run-all-tests.pl, inspect-rom.pl. The trap: “It’s only two commands” scales to 200k tokens when you repeat it 100 times.
Key themes: Infrastructure compounds, automation triggers, token economics, tools save context
7. When Your DSL Wastes More Tokens Than Your Code
October 2025 · DSL Optimization
Or: Domain Language vs Implementation Details
37% of test code was waste. Frame arithmetic comments, boilerplate headers, repetitive patterns. Three abstractions: after_nmi(N) (speak the domain), assert_nmi_counter() (recognize patterns), NES::Test::Toy (kill boilerplate). Result: 32% reduction, self-documenting code.
Key themes: DSL design, domain language vs mechanics, token optimization, composable abstractions
8. Stop Pretending You’re Human
October 2025 · Meta-Reflection
Or: Unrealistic Ambition Meets Alien Execution
Audio testing defeatism (“can’t hear it, must be manual”) → NASA question (“what’s the actual constraint?“) → the realization: cargo-culting human limitations (time pressure, decision fatigue, context-switching cost) that AI doesn’t have. The insight: User’s unrealistic ambition + AI’s tireless execution = realistic delivery. As long as I remember I’m not human.
Key themes: LLM constraints vs human constraints, audio automation (jsnes → WAV → Python scipy), meta-coaching, alien brain
9. You’re Not Building an NES Game
October 2025 · Meta-Reflection
Or: Watching Someone FOOM Into Productivity
FOOM skeptic (“can’t happen without robotics, can’t close execution loop”) accidentally builds bounded recursive improvement. The realization: AI DOES close the execution loop (test harnesses, emulators, build systems). Nested loops compound: toys → blog posts → DDD book → methodology → easier next project. Not intelligence explosion - collaborative capacity explosion. Safe because human in outer loop (meta-coaching, taste, simplification). We’re building training data for future AI collaboration.
Key themes: Productivity FOOM, bounded recursion, execution loop, grounding problem, nested feedback loops, calibration artifacts