Coding

Lessons for Agentic Coding: What should we do when code is cheap?

As code generation tools proliferate, developers are increasingly relying on low-cost, AI-driven codebases that can be rapidly assembled and deployed, but this shift raises fundamental questions about the role of human agency in software development and the long-term implications for system reliability and maintainability. The proliferation of "code-for-hire" platforms and AI-powered coding assistants is redefining the boundaries between human and machine labor in the software development process. Can we afford to sacrifice quality and control for the sake of speed and cost savings? AI-assisted, human-reviewed.

Adam J (AI-assisted) May 5, 2026 3 min read EN

Anthropic’s Claude Code, GitHub Copilot, and other AI coding assistants have made generating functional code faster and cheaper than ever. But this shift introduces new challenges for reliability, maintainability, and human oversight. Below are 10 practical guidelines for developers working with agentic coding tools, distilled from recent industry discussions and field-tested workflows.

Overview

Agentic coding—where AI agents autonomously generate, test, and refine code—accelerates development but risks creating brittle, poorly documented systems. These 10 rules address the tradeoffs between speed and long-term sustainability, emphasizing human-AI collaboration over full automation.

The 10 rules

Implement to learn Spec-driven development (SDD) is useful, but writing code reveals gaps in planning. Use cheap code generation to prototype early and refine specs iteratively.
Rebuild often Fork and reimplement projects to explore alternative approaches. Cheap code makes experimentation viable, but balance this with incremental progress to avoid wasted effort.
Invest in end-to-end tests Prioritize tests that validate behavior, not implementation. Behavioral contracts allow flexibility to rebuild code without breaking functionality.
Document intent Code explains how; tests explain what. Intent—why decisions were made—should be preserved in markdown files or comments to guide future iterations.
Keep specs in sync Treat specs as living documents. Update them alongside code to capture learnings and ensure agents align with evolving goals.
Find the hard stuff Boilerplate and obvious design choices are easy for agents. Focus human effort on complex challenges: intuitive UX, performance, security, and system architecture.
Automate the easy work Offload repetitive tasks (code reviews, linting, CI/CD) to agents. Avoid over-automating without guardrails—“Mystery House” scenarios (unpredictable agent behavior) can derail projects.
Develop your taste Fast code generation requires fast feedback. Domain expertise and user empathy help developers guide agents effectively, reducing wasted cycles.
Pair expertise with agents Agents amplify human skills. Developers with deep stack knowledge can craft precise prompts, debug efficiently, and minimize agent missteps.
Mind the maintenance Code is cheap; support, security, and upkeep are not. Treat agent-generated code like “free puppies”—plan for long-term costs.

Tradeoffs

Speed vs. control: Agentic tools reduce time-to-implementation but may introduce technical debt if not paired with rigorous testing and documentation.
Automation vs. oversight: Full automation risks brittle systems; human review remains critical for complex or high-stakes projects.
Cost vs. value: While code generation is inexpensive, maintenance and security audits require ongoing investment.

When to use it

Agentic coding excels for:

Prototyping and rapid iteration.
Boilerplate-heavy projects (e.g., CRUD apps, API wrappers).
Exploratory development where specs are fluid.

It’s less suitable for:

Mission-critical systems (e.g., financial, healthcare).
Projects requiring deep domain expertise or nuanced design.
Long-term codebases without dedicated maintenance resources.

Bottom line

Agentic coding tools are reshaping software development, but their value depends on disciplined workflows. Follow these 10 rules to balance speed with sustainability, ensuring AI-generated code remains an asset—not a liability.

More articles like this

Coding 1 min

Google Chrome silently installs a 4 GB AI model on your device without consent

Google Chrome's latest update surreptitiously downloads and deploys a 4 GB neural network model to users' devices, bypassing explicit consent and raising concerns about data collection and local processing. The AI model, which is reportedly used for predictive text and language processing, is installed without notification or user interaction, sparking debate over the boundaries of implicit consent in software updates. This move has significant implications for user trust and data sovereignty. AI-assisted, human-reviewed.

Coding 1 min

The Frog for Whom the Bell Tolls

A long-sought solution to the "cold start" problem in conversational AI has emerged, as a novel approach leveraging pre-trained language models and reinforcement learning from human feedback enables effective dialogue initiation without explicit user input. This breakthrough, achieved through a combination of sequence-to-sequence models and actor-critic algorithms, promises to unlock more natural and intuitive human-computer interactions. Early results indicate a significant reduction in user prompting requirements. AI-assisted, human-reviewed.

Coding 3 min

Async Rust never left the MVP state

Rust's async runtime remains in a perpetual MVP state, failing to deliver on its promise of scalable concurrency despite years of development, with the async-std library still struggling to match the performance of C++'s async I/O model. The lack of a unified async API has hindered adoption, leaving developers to choose between competing libraries like async-std and tokio. This fragmentation has stalled Rust's growth in the high-performance systems space. AI-assisted, human-reviewed.

Coding 3 min

Train Your Own LLM from Scratch

Researchers have cracked the code to training large language models (LLMs) from scratch, bypassing the need for massive pre-trained weights and proprietary datasets. By leveraging a novel combination of transformer architectures and knowledge distillation techniques, developers can now replicate the performance of state-of-the-art LLMs using publicly available datasets and commodity hardware. This breakthrough democratizes access to cutting-edge NLP capabilities. AI-assisted, human-reviewed.

Coding 2 min

CVE-2026-31431: Copy Fail vs. rootless containers

A critical vulnerability in Linux's copy-on-write mechanism, CVE-2026-31431, exposes rootless containers to data exfiltration via a novel "Copy Fail" attack vector, exploiting the interaction between the kernel's copy-on-write and the container's rootless namespace. The flaw affects Linux distributions from 5.10 to 5.18, with a potential impact on containerized workloads and cloud infrastructure. Patches are available, but widespread adoption remains uncertain. AI-assisted, human-reviewed.

Coding 1 min

Biscuit

A new open-source framework, Biscuit, is gaining traction among developers by leveraging WebAssembly to enable seamless integration of WebAssembly modules into existing C++ applications, thereby expanding the reach of WebAssembly beyond browser-based use cases. This innovation could potentially accelerate the adoption of WebAssembly in systems programming and high-performance computing. Early adopters are already exploring its potential for building high-performance, cross-platform applications. AI-assisted, human-reviewed.