Agents think more code is better. Here's how you fix it
Coding agents confuse code volume with productivity. My experiments use explicit coding culture and a local definition of engineering quality to challenge that bias.
Lynn Cole / 标签
software craft
A thread through the work.
A name is a micro-value proposition
A product name is a micro-value proposition. A memorable conversation about naming came back to me while looking through 230 poetically named repositories.
Documentation is infrastructure
Documentation is infrastructure, whether it lives in code, a ticket, a notebook or a coffee-stained napkin. Write down what tomorrow will need.
The old religion of Python
Python once felt like a doctrine of disciplined predictability. An architectural failure got me thinking about explicit contracts and where rigidity belongs.
Writing modern Fortran feels like home
The new compiler wants you to think of it as a modern language.
Rethinking Glamin around learned embeddings
Mutable vector indexes made Glamin programs too easy to break and too hard to debug. Learned embeddings offer another path for the experiment.
Field notes on software reconstruction and a new donor truck
Field notes on reconstructing complex software and finding a donor truck to keep the talking-vehicle project alive.
A self-hosted DeepSeek security audit
A self-hosted DeepSeek audit checks templates and generated applications for malicious behavior, separating observed quality problems from the malware question.
What AI makes possible for independent builders
AI criticism goes in cycles, where the same people repeat the same arguments like they thought of them.
Planning a self-play experiment for a coding model
A planned self-play experiment uses compiler verification and multiple reviewers to turn a small Qwen model into a stronger Go developer.
Agents A1 and Qwen: coding-workflow observations
A coding-workflow comparison of Agents A1 and Qwen finds different failure modes across Go, Zig and Next.js, and a useful response to QA feedback.
Expose capabilities, not a frontier model
Expose useful product capabilities instead of embedding an open-ended frontier model. Let users bring the inference stack they already trust.
Reading code metrics in context
Lines of code mean more when read alongside completed features, deletions, commit hygiene and the conversion of activity into working software.
A coding-agent demo is not yet a product
A coding-agent demo can complete a task. A product needs to understand arbitrary codebases, resolve ambiguity and recover without constant babysitting.
Building in public as rational self-interest
You build in public to share your notes with like-minded developers, collaborators, and potential employers.
Reading layered context-control surfaces in Claude Code
A review of Claude Code’s layered context-control machinery: prompts, hidden reminders, tool serialization and parallel permission decisions.
The expensive part is the trial and error
Copying an existing agent harness can be fast. Discovering and handling its real failure modes is where the engineering time goes.
Engineering the conditions for automated work
The velocity AI creates in coding is interesting because it is not nearly as uniform as people assume.
Two questions before building an AI application
Before building an AI app, answer two questions: why use AI, and what are you optimizing for? Dirty, adaptive problems offer a different value proposition from rigid workflows.
The internet after the advertising model
The internet has changed from an information network into an advertising machine. I see a return toward lighter interfaces and an agent-mediated network.
Five years of learning to build coding agents
Five years of building coding agents led from GPT-2 experiments through Klara to modern tools. Human intent and engineering discipline still shape the result.
Designing a deliberately vague agent evaluation
A deliberately vague evaluation tests whether a coding agent can build, audit, document and revise an application without constant micromanagement.
Learning engineering through AI-assisted generation
Learning with AI-assisted generation can be a way into engineering. Build, question the output, document the process and discover what better means.
Mocks, refinement, and what a bug is telling you
Mocks can disappear from an agent’s memory after compaction. Detailed epics help—and bugs remain valuable information about the structure you actually built.
Documentation debt is still infrastructure debt
Documentation debt is still infrastructure debt. AI makes the habit easier, and information silos remain an expensive way to look busy.
Vibe coding and the upstream work of quality
Vibe coding moves more of quality upstream into requirements, prompts and validation, while giving more people a way to try building.
The old engineering work inside the new workflow
The familiar engineering work—planning, patterns and review—still lives inside the new AI coding workflow.
Busy’s complexity wall and changing deployment assumptions
Busy’s complexity wall led through Lua, Dart and a tunneling problem to a different deployment model—and a redesign of the plumbing.
Teaching the coding system what good means
Tell a coding system what good means: your architecture, standards, metaphors, file boundaries and expectations for documentation.
Enterprise software’s cognitive pipeline
Enterprise software can learn from marketers: target the information, respect cognitive resources and build engagement into the workflow.
Management is more than giving orders
Good management balances accountability, protects attention and builds a collaborative team. It is much more than giving orders.
Teaching automated QA to reason about scope
An automated QA system began losing track of scope as output accelerated. Formal documentation and a specialized management tool became the next step.
A context-infrastructure stack for Claude
Happy Trees, logic maps and current-state reports form a context-infrastructure stack for longer, more coherent Claude coding sessions.
Formal coding practices and a self-bootstrapping workflow
Building Grimes became an experiment in formal coding standards, logic maps and a self-bootstrapping agent workflow.
Invoices should be beautiful
An invoice should be beautiful. My invoicing-app experiment combines LaTeX, live previews and practical tools for independent consultants.
The fjords came back
A joking instruction about Nordic engineering turned into fjord poetry across the codebase—and returned when one old file was restored.
Learning COBOL for fun
I learned COBOL for fun a few years ago, seeing it through the eyes of a modern programmer.
Cheap software still needs someone behind it
Cheap software still needs support, proven behavior and someone accountable when it fails. Reconstructing a mature product remains real engineering work.
Hardening the coding agent across models and integrations
Hardening a coding agent means fixing integration seams, recertifying models and making the same workflow hold across providers.
What Glamin taught me about AI-native language design
Glamin taught me that fluidity belongs on the right layer. Learned embeddings and a more familiar source language suggest a different design.
A bad week for programming-language runtimes
A dated roundup of runtime-security failures across PHP, Ruby, Node.js, Go and Java, and what they suggest about the cost of finding and fixing bugs.
Software products are relationships
A software product is a relationship. Understanding users, giving them a reason to care and making a living are part of the same work.
The beginning of a faster Ruby compiler
Ruby's not my favorite language, but I find it offensive that anyone would replace a perfectly good Rails application with an app written in Rust.
Orchestration is an engineering art
Orchestration depends on explaining your process, your standards and your definition of done. Being a strong conventional developer does not automatically make that easy.
Hubnot: issue revisions, retries, and descriptive authority
Hubnot adds issue structure, explicit revision history, retry handling and stale-update checks while keeping assignment separate from execution authority.
Glamin in a local inference stack
Putting Glamin into a local inference stack turns vector-space state changes into a possible interface for tools, memory and small applications.
Why AI coding projects fail
AI coding projects fail for familiar engineering reasons: weak planning, vague standards, missing security, poor QA and testing surfaces nobody can manage.
Build tools for the inference stack people already use
Build tools for the inference stack people already use: delightful software, a community and something worth returning to.
GLM 4.7: early coding and behavior observations
Early GLM 4.7 observations: exceptional code output, rigid behavior and a tendency to act before asking the clarifying question.
Social-engineering probes for an agent interface
Social-engineering probes test whether an agent can be talked out of its instructions by claims of authority. These are some of my first checks.
Old code, fear of change, and the poetry of rebuilding
Old ASP code carries traces of fear, habit and human choices. Rebuilding it starts with cataloging the workflow rather than copying its implementation.