TL;DR
Steve Krenzel argues that agentic AI makes previously optional engineering practices essential. His team enforces strict guardrails — including 100% test coverage, small files and namespaces, fast ephemeral dev environments, and strong typing — so LLM-driven agents produce reliable changes.
What happened
In a recent essay, the author describes how software agents powered by large language models expose and amplify weaknesses in codebases, making traditional 'nice-to-have' practices operational necessities. His six-person team adopted several concrete measures to make agentic coding predictable: a mandatory 100% code-coverage requirement so every line has an executable test, disciplined directory and file naming with many small files to help agents load context, and fast, ephemeral, concurrent development environments that can be spun up with a single command. They also lean on a typed stack — TypeScript, OpenAPI-generated clients, Postgres with checks and triggers, and Kysely for typed DB clients — and automate linters and formatters to reduce degrees of freedom for the model. The central thesis is that investing time up front in these guardrails pays off because agents perform better when the environment constrains and documents expected behavior.
Why it matters
- Agents can make many changes quickly; without strict guardrails, they can propagate mistakes across a codebase.
- Requiring tests for every line forces agents to demonstrate behavior, reducing ambiguity about new or modified code.
- Smaller files and clear namespaces improve how models load and reason about project context, boosting agent reliability.
- Fast, isolated dev environments let teams run automated checks frequently, keeping agent iterations short and safe.
Key facts
- The author’s team enforces 100% code coverage as a minimum; coverage reports double as a todo list for missing tests.
- The team prefers many small, well-scoped files and intentional directory naming to help agents navigate the codebase.
- Dev environments are designed to be fast, ephemeral, and concurrent; a single command creates a fresh worktree and starts an agent.
- Their test suite contains over 10,000 assertions that finish in about one minute when caching is enabled; without caching the run can take 20–30 minutes.
- The stack emphasizes strong typing: the team uses TypeScript, OpenAPI to generate typed API clients, and Kysely to produce typed Postgres clients.
- Postgres is used with checks and triggers to enforce invariants; third-party clients are wrapped to provide good types.
- Automatic linters and formatters are recommended and configured to apply fixes automatically when an agent completes a task.
- The filesystem (directories and filenames) is treated as an interface for agents, since they rely on listing and reading files to build context.
- The author notes that agentic tools require guardrails; without them, models can reflect and amplify a codebase’s existing problems.
- The team uses git hooks among other mechanisms to run quality checks during development.
What to watch next
- Whether other engineering teams begin adopting 100% coverage as a practical standard rather than a controversial ideal — not confirmed in the source.
- Emerging tooling that streamlines fast, concurrent, ephemeral developer environments and better isolation for agentic workflows — not confirmed in the source.
Quick glossary
- Agent / Agentic coding: Automated software processes driven by models that can read, modify, and create code or other artifacts with varying levels of autonomy.
- Code coverage: A measure of how much source code is executed by tests; used to identify untested lines or paths.
- Type system (TypeScript): A way to describe kinds of data in code so errors can be caught earlier and intent is documented; TypeScript is a statically typed superset of JavaScript.
- OpenAPI: A specification for describing RESTful APIs that can be used to generate client libraries, documentation, and other tooling.
- Ephemeral dev environment: A short-lived, fully configured development instance that can be created and destroyed quickly for isolated testing or development.
Reader FAQ
Does 100% coverage guarantee no bugs?
No. The author says 100% coverage is about forcing the agent to demonstrate behavior for every line, not a claim of bug-free code.
Why prefer many small files and clear directories?
Agents load context from the filesystem; smaller, well-named files reduce truncation and make it easier for models to find and keep relevant context.
Which languages and tools does the author recommend?
The author favors TypeScript, OpenAPI-generated clients, Postgres with checks and triggers, and Kysely; he explicitly advises against using Python in this context.
Will every team need to adopt these practices?
Not confirmed in the source.
AI Is Forcing Us To Write Good Code When Best Practices Are Best STEVE KRENZEL DEC 29, 2025 1 Share For decades, we’ve all known what “good code” looks like….
Sources
- AI Is Forcing Us to Write Good Code
- Zero Human Code -What I learned from forcing AI to build …
- AI coding is now everywhere. But not everyone is convinced.
- The Wrong Way to Use AI (and How to Actually Write Better …
Related posts
- Production failure from uninitialized C++ struct exposed undefined behavior
- Why LLMs Are Not Fun: A Developer’s Case Against AI-as-Teammate
- 2025: When AI’s Frenzy Met a Hard Reality Check on Growth