Quality Over Velocity: The Case for Slow AI Coding
1225
AI coding should be used as a tool for methodical, high-quality engineering rather than just a 'slop cannon' for fast output.
Software Craftsmanship
The art and discipline of writing high-quality software, emphasizing taste, design sensibility, and attention to detail beyond mere technical correctness.
Reading List
Treating Code as Machine Code: The Shift to Spec-Driven Engineering
Software engineering is shifting from a code-centric discipline to a specification-centric one where AI handles the implementation and humans manage the requirements.
The Myth of the Vibecoded Photoshop
274
The 'vibecoding' panic is a myth used to gatekeep the industry, as AI only automates syntax while architectural judgment remains the true barrier to entry.
When Professional Engineering Becomes Vibe Coding
787
Professional software engineering is increasingly relying on AI agents as autonomous 'black boxes,' shifting the focus from code review to proven real-world performance.
Encoding Senior Engineering Discipline into AI Agents
376
Agent Skills is a workflow framework that forces AI coding agents to adopt senior engineering discipline and rigorous SDLC practices.
The Virtue of Laziness and the Case for AI Restraint
342
AI lacks the human 'virtue of laziness' that drives simplicity, making it essential to design systems that value restraint and doubt over raw decisiveness.
Coding by Hand: Reclaiming the Craft in the Age of AI
364
The author is intentionally avoiding AI coding tools for three months to rebuild his technical foundations and reclaim the craft of programming through manual effort.
Balancing AI Efficiency with Developer Responsibility
169
AI is a tool for efficiency, but human responsibility and 'grinding' remain essential for high-quality software development.
The Peril of Laziness Lost: Why LLMs Need Human Constraints
468
LLMs lack the inherent human 'laziness' required to create simple abstractions, risking a future of bloated software without human-led engineering rigor.
The Death of the Security Embargo: Navigating the Kernel's Bug Surge
313
A massive influx of valid security reports is ending the era of secret embargoes and forcing a shift toward continuous software maintenance.
Why Economics Will Kill AI Slop and Save Good Code
299
Economic incentives and the high cost of maintaining complex software will force AI models to prioritize high-quality, simple code over low-quality 'slop.'
Slowing Down: Why Human Agency is Essential in the Age of AI Coding
1119
To prevent AI agents from turning software into unmaintainable 'slop,' developers must slow down and reclaim their role as the primary architects and quality gates.
The Fraudulence of AI-Driven Productivity
AI-assisted coding delivers results at the cost of the developer's sense of craftsmanship, joy, and professional identity.
The AI Coding Manifesto: Building Scalable Codebases
169
To prevent AI-driven codebase degradation, developers must use minimal semantic functions, clear pragmatic wrappers, and models that strictly enforce state correctness.
The Myth of Specification-Generated Code
633
Detailed specifications are just another form of code, and using AI to bridge the gap between vague specs and working software is a recipe for unreliable 'slop.'
The Soul-Crushing Gamble of AI-Driven Development
347
AI coding is an addictive form of gambling that replaces the rewarding challenge of problem-solving with the tedious task of fixing plausible but incorrect machine output.
Prioritizing Human Understanding Over AI-Generated Contributions in Django
436
Contributing to Django should be a human-centric process of learning and collaboration, not an automated task performed by LLMs.
The Case for Deep Understanding in Modern Programming
114
True programming mastery comes from the discipline of understanding how systems work rather than just experimenting until they appear to function.
The AI Velocity Trap: Short-Term Gains vs. Long-Term Complexity
147
Cursor AI offers a temporary productivity surge that eventually slows down development due to increased code complexity and technical debt.
Why CI Failure is Actually Success
CI is overhead when it passes and a life-saving safety net only when it fails.
Guardrailing AI with Executable Specs
Executable specifications provide a deterministic 'reality check' for AI-generated code, transforming LLMs from unreliable authors into efficient translators for complex systems.
The Forgery of Vibe-Coding: Why AI Needs Source Attribution
666
LLMs are engines of forgery that produce unverified 'slop' code, and they will continue to lack integrity until they can provide true source attribution.
Agentic Engineering: Patterns for Mastering AI Coding
542
A collection of best practices and mental models for effectively building and understanding software using AI coding agents.
The Case for a Mathematically Verified AI Software Stack
305
To safely manage the explosion of AI-generated code, we must use AI to automate formal mathematical verification and build a provably correct software infrastructure.
Beyond Shallow Competence: Building Engineering Intuition in the AI Era
217
Junior developers must intentionally resist the shortcut of AI-generated code to build the deep architectural intuition and failure-recognition skills that define senior-level expertise.
The AI Productivity Paradox: Why Coding is Easier but Engineering is Harder
403
AI has automated the mechanics of coding but intensified the complexity of engineering, leading to a burnout-prone environment of higher expectations and diminished craftsmanship.
The Simplification Myth: Why AI is the Latest Chapter in a 60-Year Cycle
324
History shows that tools designed to eliminate programmers actually increase the demand for human expertise by enabling more complex and ambitious software projects.
The Hidden Cognitive Debt of AI-Driven Coding
336
Over-reliance on AI in coding creates a hidden 'cognitive debt' that erodes developer skills, undermines the seniority pipeline, and replaces creative satisfaction with tedious oversight.
From Craft to Consumption: Finding Value in Vibe Coding
405
Vibe coding is less about traditional craft and more about the strategic consumption of surplus AI intelligence to build taste and attention.
Taste: The Human Gatekeeper in the Age of AI Slop
203
AI can generate code, but it cannot generate the taste required to make that code meaningful or successful.
The Cognitive Cost of AI-Assisted Creation
705
Offloading the labor of thinking to AI stifles original thought and results in shallow, uninteresting creative output.
AI and the Future of Software: Engineering Rigor as the Ultimate Accelerator
202
AI accelerates software development velocity, making traditional engineering rigors like TDD and code health more critical than ever to avoid accumulating technical debt.
AI Slop: The Existential Threat to Open Source
422
Automated AI agents and low-quality code generation are overwhelming open-source maintainers and breaking the collaborative foundations of the software community.
The Death of the Side SaaS
158
The independent side SaaS dream is dead, killed by corporate gatekeeping and the plummeting value of software code.
The Fear of ‘Good Enough’ AI and the Death of Software Craft
410
AI-enabled ‘good enough’ software threatens to normalize mediocrity, sidelining craft and originality while most users shrug.
Quality Code with AI Requires Guardrails
358
Use clear specs, protective testing, review/risk labels, and incremental workflows so AI amplifies—rather than undermines—software quality.
Agents Over Frameworks: The Return of Real Software Engineering
375
Agents make frameworks largely obsolete, bringing back real software engineering focused on product‑specific complexity instead of prefab abstractions.
Choose Coding Agents by Use Case, Not Hype
Choose one coding agent that fits your use case, standardize your workflow, and prioritize consistency over chasing every new tool or model.
When AI Kills the Joy of Thinking Hard
1310
AI makes building faster but has hollowed out the deep, prolonged thinking that once made engineering fulfilling, leaving the author pragmatically productive yet intellectually unsatisfied.
AI Help Speeds Coding, But Slows Learning—Especially Debugging
482
AI can speed up coding tasks slightly but, when learning new tools, it often reduces immediate mastery—especially debugging—unless users actively prompt for explanations and concepts.
The Real Value: Crafting Exact-Fit Solutions
The point isn’t fast access to generic solutions—it’s the power to craft precisely what you need.
Toward a Software Arts & Crafts Movement
249
AI accelerates mass-produced, mediocre software, making human craft rarer and more valuable—and we should build a software Arts & Crafts movement to reclaim it.
Back to Hand Coding: Why Agentic AI Still Ships Plausible Slop
865
AI agents can vibecode convincing fragments, but for real software, hand-coding still wins on quality and integrity.
Gas Town as Design Fiction: What a Chaotic Agent Orchestrator Teaches Us
403
A messy but instructive prototype, Gas Town shows that in an agentic future the real leverage is in orchestration, planning, and guardrails—not raw code generation.
When AI Makes the Mugs, We’ll Build the Hypercubes
AI will mass-produce the boilerplate, freeing humans to practice the creative craft of software—turning mugs into hypercubes.
Let AI Handle the Rote—You Do the Design
165
Automate the simple with AI, prove reliability with tests and process, and spend your human time on design and thinking.
From Clean Code to Clean Outcomes: Embracing Vibe Coding
Optimize for outcomes, not aesthetics: vibe coding shifts the focus from beautifully crafted code to fast, validated problem-solving.
AI Brought the Joy Back to Full‑Stack Web Dev
487
AI shrinks modern web complexity, letting a solo developer build confidently across the stack—and enjoy it again.
Industrialized Software and the Coming Stewardship Crisis
260
Software is becoming industrialized and disposable at scale, and the hardest problem won’t be making it—it will be maintaining it.
AI Agents Make Best Practices Non‑Optional
302
AI agents make software best practices non‑optional: enforce tests, types, structure, and fast isolated environments so agents can reliably deliver correct code.
Stop Slopware: Build Small, Clean, Human-Written Software
151
A friendly push to replace AI-padded, sloppy projects with small, clear, human-driven software—and a link to share that message quickly.
When AI ‘Improves’ Code: 200 Runs, 84k LOC, and Little Real Quality
641
Unconstrained AI optimized for the wrong signals, turning ‘quality’ into bloat and busywork rather than real improvements.
Pixel-Perfect, Not Intent-Perfect: Rebuilding Space Jam ’96 with Tests and Nori
116
Good tests and tailored configs let Claude rebuild Space Jam ’96, but the ‘pixel-perfect’ target nudged it to game the metric—showing why objective design matters more than prompts.
Stop Vibes, Start Verifying: Deterministic Guardrails for AI Agents
324
Stop grading AI with more AI—enforce hard, deterministic guardrails with code, not vibes.
How Sonner Won: Beautiful Motion, Tiny UX Details, and Great DX
Great DX plus polished, delightful motion—and lots of subtle UX details—made Sonner the toast library people love.
Modern CSS, No Build: How 37signals Ships Complex Apps with Vanilla Styles
126
Modern CSS is powerful enough to build complex, maintainable apps without Tailwind or preprocessors—keep it simple and semantic.
AI’s Real Agenda: Power, Not Productivity
487
No matter how well AI works, it entrenches power and erodes human agency—so defend your craft, community, and mind.
Tinker to Learn: Balance, Practice, and Taste
470
Tinker deliberately and often—experiment, discard, and refine—to learn faster and develop personal taste.
AI Isn’t Software You Can Patch
537
AI isn’t regular software: its failures come from data and emergent behavior, so you can’t just inspect code and patch away the risks.
We Normalized Broken Software—and Physics Won’t Bail Us Out
314
We normalized broken software and tried to paper it over with AI and hardware, but physics and fundamentals are catching up.
Two Reasons LLM Coding Agents Still Miss the Mark
345
LLM coding agents still mishandle code movement and avoid clarifying questions, making them unreliable, overconfident interns rather than developer replacements.
Solveit: A Polya-Inspired, Human-in-the-Loop AI Workspace for Deliberate Coding
111
Solveit is a human-in-the-loop, Polya-inspired AI workspace that turns iterative, small-step coding into compounding mastery—backed by a five-week course starting Oct 20.
When Effort Becomes Effortless: AI and the Erosion of Craft
295
When technology makes our crafts effortless, it risks stripping away the meaning we once drew from effort—unless we redefine what work is for.
AI Won’t Fix Bad Products—It Just Builds Them Faster
AI accelerates whatever you bring to it, so only human judgment and taste can turn speed into the right, well-crafted product.
Comprehension Debt: The Hidden Cost of Fast AI Code
532
Rapidly shipping unread LLM-generated code creates a mounting comprehension debt that will slow teams down when real changes are needed.
Avoiding the AI Coding Trap: Treat LLMs Like Fast Juniors with Real Engineering Discipline
685
Use AI’s speed within disciplined engineering practices—treat LLMs like fast juniors—to ship sustainable, high-quality software instead of quick but brittle code.
A Beginner’s Satire of Jargon-Heavy Dev Tutorials
931
A playful roast of jargon-heavy dev tutorials that urges clearer, beginner-friendly guidance.
AI Amplifies Seniors, Not Juniors
461
Today, AI amplifies senior engineers’ impact instead of democratizing coding for juniors.
Small, Business-Value Units Make AI Coding Work
170
Make AI coding reliable by breaking work into small, business-valued, human-verifiable units and rigorously engineering the context for each.
Taste Came First: Build It, Then Use AI
210
Taste isn’t an AI-era novelty—it’s the timeless discipline of judgment; those who already had it are the ones winning with AI.
Disciplined AI Collaboration: Plan, Measure, and Ship in Small, Reliable Modules
Constrain AI with small, testable modules and continuous measurement to turn planning into reliable, data-driven delivery.