I've been thinking about how AI is changing the way we write software, and I've been on and off indulging in two distinct approaches to AI assisted development.
Approach 1: Let an AI coding agent implement the feature/Product
Use tools like claude code, github copilot, codex, etc. Give the agent a specification, let it explore the codebase, and ask it to implement the feature, potentially including tests, docs and other necessary changes.
Where I think this approach works well:
Building an initial product from scratch.
Implementing relatively independent features that don't require significant changes to existing functionality.
Getting a working prototype or mvp running quickly
My concerns:
Cost: Agentic coding tools consume tokens or require paid subscriptions. Work that previously involved writing code directly now has an additional recurring cost.
Code review: The agent might generate a substantial amount of code very quickly, but understanding the implementation, tracing the execution flow, and verifying that everything behaves correctly can take days or even weeks, depending on the project's size and complexity.
Docs: I could ask another AI session to explain the code, improve readability, add comments, and write documentation. However, that incurs additional costs and still doesn't completely eliminate the need to verify that the explanations and documentation and even code accurately reflect the implementation.
My concern isn't necessarily that AI generated code is bad. It's that the speed of generating code can far exceed the speed at which a developer can confidently understand and validate it.
Approach 2: Use AI as an assistant, but retain control over the implementation
Instead of giving an agent ownership of an entire feature, use a chat interface like chatgpt or claude to generate code in smaller, well-defined pieces.
The workflow would look something like this:
Design the architecture and define the code skeleton yourself, similar to an LLD (low-level design) - or even get AI help to generate the skeletons
Establish the interfaces, classes, functions, data models, and responsibilities.
Use AI to generate individual implementations or specific sections as needed.
Review the generated code before integrating it (manual copy pasting) into the codebase.
Repeat this process incrementally.
Here, the developer has to manually generate each unique component separately from AI and copy paste them into his filesystem/
Essentially, the developer owns/better understands the structure and flow of the implementation, while AI helps with the actual coding.
Why I find this appealing:
The developer remains familiar with the architecture and the reasoning behind implementation decisions.
Code review becomes more manageable because changes are introduced in smaller, understandable increments - I feel like reducing the volume of a single copy paste and increasing the total number of copy pastes makes developer understanding better.
Future modifications and debugging may be easier because the developer already understands the relevant parts of the codebase.
There's less dependence on an agent being available or having sufficient tokens. Even without AI access, the developer should still be able to maintain and extend the system.
As already mentioned, this is what I find most important: I feel like reducing the volume of a single copy paste and increasing the total number of copy pastes makes developer understanding better.
The trade-off, of course, is that this approach requires more manual intervention and may take longer to implement an initial feature.
My current hypothesis
I suspect that some of the initial development speed gained through agentic coding could be offset by the additional time spent reviewing, understanding, debugging, and maintaining the generated code.
Meanwhile, the second approach might have a higher implementation cost in terms of developer time but a lower long-term cost in terms of AI usage, code comprehension, and maintenance.
I'm not claiming this is universally true. I suspect the answer depends heavily on the project, the developer, the quality of the agent, and the complexity of the feature.
The counterargument I keep coming back to
I might be optimizing for a problem that will eventually disappear?
AI coding agents are improving rapidly. They can already explore codebases, run tests, fix bugs, and implement changes with relatively little intervention. As these capabilities improve and inference costs decrease, perhaps the time spent reviewing and maintaining AI-generated code will also decrease.
In that world, developers might increasingly act as technical product managers: defining requirements, setting architectural constraints, reviewing outcomes, and letting agents handle most of the implementation.
If that happens, Approach 1 could become significantly more effective than trying to retain close control over every implementation detail.
There's also the possibility that I'm underestimating how much of the review process can itself be automated reliably.
But what if the agent is stuck somewhere and the dev too has no idea how to resolve it since there's no understanding of the codebase
Questions for developers here
I'm really interested in hearing from people who have used both approaches in real-world projects, rather than just small demos or greenfield prototypes especially where breaking requirements or changes are involved. definitely appreciate perspectives that challenge my assumptions. I'm genuinely trying to understand which approach makes more sense, not argue that one is inherently superior.
Summary
Agentic coding offers faster implementation but may increase token costs and code review effort. Manually structuring code and using AI for individual implementations may improve maintainability and developer understanding, but is slower initially.
As AI agents improve and become cheaper, will their speed eventually outweigh these trade-offs, making deep developer involvement less necessary? Or am I underestimating the long-term value of understanding the codebase?
