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

10 Lessons for Agentic Coding
What should we do when code is cheap?
Lately, this blog has featured a lot of writing about agentic coding. Frontier models are really good at coding these days, much better than they are at other tasks. Coding with agents feels like a preview of the future, a playground for seeing how far we can push agent capabilities. It’s invigorating, rewarding, and deeply weird.
I’ve been keeping a running list of tips for agentic coding: guidelines or rules one might give to someone just getting started with Codex, Claude Code, Pi, or any other agent. Ideally each tip is generalizable guidance, relevant to any agentic programming. I’m also looking for durable lessons that will stick around as models and harnesses improve.
Below is my current list: 10 Lessons for Agentic Coding. Ten’s a nice round number; a good time to put this out there.
To be clear: I take credit only for honing and compiling these guidelines. As Kshetrajna Raghavan said to me today, “It’s crazy how we’re all converging on similar lessons.”
(If you think I’ve missed anything below, please reach out!)
10 Lessons for Agentic Coding
- Implement to learn. You can go far with Spec-Driven Development, but the act of writing code surfaces decisions you hadn’t considered and makes your spec better. When code is cheap, implement to learn.
- Rebuild often. Implement early and often to learn more. Fork and recode crazy thought experiments. Find out how far you can take feature. Of course, you want to iterate and compound your efforts, but cheap code means you can reconnoiter and reinvent in ways you never could.
- Invest in end-to-end tests. When we can reinvent our code cheaply, we should spend time writing tests that measure our product’s functions, not how it performs them. We want behavioral contracts that grant us the freedom to rebuild and reimplement.
- Document intent. Tests detail our goals while code encodes our methods, but neither captures the why. Your intent motivates your decisions, and persisting it alongside the code helps you and your agent compound those decisions in a consistent direction.
- Keep your specs in sync. Update your specs, the markdown files containing your goals and plans, as you advance your code and your tests. Treating your spec as a frozen artifact written before work begins, you’ll fail to capture learnings during implementation. Keeping it current lets it constantly inform your and your agents’ choices, and makes frequent rebuilds easier.
- Find the hard stuff. Work on a project long enough and things will stop being easy. You’ll speed through the boilerplate work, the obvious design decisions, and start hitting the ugly, difficult work: intuitive design, performance, security, resilience, and systemic architecture. Anyone can vibe the easy stuff. The hard work is where the value is. Find it and dig in.
- Automate everything that’s easy. To spend more time on the hard stuff, minimize the time you spend on easy things. Distill learnings into skills, build loops, automate code reviews, and let your tools compound. But careful: don’t get stuck in a Mystery House.
- Develop your taste. When code arrives fast but feedback doesn’t, the only source of feedback that keeps up is your own. The better you know your domain, your users, and their problems, the further you can go without checking in.
- Agents amplify experience. Talented developers underestimate how much intuition they bring to their prompts: the right terms, the right framing, and the right level of specificity. If you know your stack, you can save countless cycles during both implementation and debugging, and cut down needless agent exploration. Pair technical expertise coupled with great taste for an unbeatable advantage.
- Code is cheap, but maintenance, support, and security aren’t. Agentic code is “free as in puppies.” Support isn’t cheap and neither is security. Build fast, but mind the maintenance you’re adopting.

Facts Only

Implement to learn, using Spec-Driven Development.
Rebuild often to learn more, experimenting with feature possibilities.
Invest in end-to-end tests to measure product functions.
Document intent to capture goals and motivations.
Keep specifications in sync by updating goals and plans with code and tests.
Find the hard stuff: work on intuitive design, performance, security, resilience, and systemic architecture.
Automate everything that is easy to focus on the hard stuff.
Develop personal taste, leveraging domain knowledge as a feedback mechanism.
Agents amplify experience by combining technical expertise with intuition.
Maintenance, support, and security are not cheap, even if agentic code creation is cheap.

Executive Summary

Agentic coding shifts the focus from mere implementation to learning, testing, and strategic problem-solving when code is inexpensive. The core lessons emphasize that developers should prioritize learning through implementation and frequent rebuilding, investing heavily in end-to-end tests to establish behavioral contracts. Furthermore, maintaining clarity through documentation of intent is crucial, ensuring decisions are captured alongside the code. The advice guides practitioners to tackle the most difficult aspects of development—intuitive design, performance, security, and systemic architecture—rather than focusing on easily automated boilerplate. Finally, the text stresses that while agentic code creation is cheap, the costs of long-term maintenance, support, and security remain high, demanding a focus on quality beyond initial speed.

Full Take

The narrative suggests that the accessibility of coding capabilities via agents introduces a critical tension between rapid creation and long-term sustainability. The focus on "implement to learn" and "rebuild often" correctly frames the process as an iterative experiment, acknowledging that the cheap nature of code allows for exploration of possibilities previously constrained by cost. However, this pursuit of cheap creation risks masking the essential trade-off between speed and resilience. The lessons implicitly challenge the notion that low-cost code automatically equates to low-cost maintenance; the explicit warning that maintenance, support, and security are not cheap points to a systemic failure in prioritizing non-functional requirements. The theme of finding the "hard stuff"—intuitive design, security, and architecture—as the source of true value suggests that the agentic shift is not just about automating execution, but about shifting human focus toward high-leverage, non-obvious cognitive tasks. This dynamic implies that the true advantage of agentic coding lies not in maximizing output speed, but in using the abundance of cheap code as a foundation to deliberately confront complexity, ensuring that the resulting artifacts are robust and maintainable, rather than merely functional.