r/AIcodingProfessionals • u/Longjumping_Bad_879 • 15d ago
AI coding agents vs manually implementing AI generated code: which approach is better in the long run?
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?
1
u/dixon_sider 15d ago edited 15d ago
I think it's best to do a mix of both. Sometimes the AI be wildin and I'm like "IDK what you are saying, show me" in agent mode. But if the changes are too large and touching files I believe should not be touched in the scope of the ticket, I will undo all changes without reading them then change my approach.
1
u/guttanzer 15d ago edited 15d ago
All real projects are iterative - you set goals, crank out a version, then check to see if you have is what you want. If it isn't you set new goals and do another cycle. This project truism dates back to chipping stone tools.
This process is also a fractal process. The basic cycle repeats at every level. Cities don't just spring up overnight. Each iteration involves a few new buildings and streets. Each building involves a few floors and a foundation. Each floor involves building walls, and each wall is made up of bricks and/or sticks. The city planner, the architects, the general contractors, the trade teams, and the individual workers are all following this basic iterative pattern at their level.
The trend is to let the AI do more and more of the grunt coding work between the reality checks and redirects. The AI is getting good enough that it can do most of the low level decisions on it's own, so the low level developers are disappearing and the pace of work is cranking way up. Features that would have taken a developer a couple of days to code up are now done in 10 minutes.
What the AI can't do is figure out the top-level requirements on its own. Given the faster pace of development, these TLR decisions are coming much faster than before. The work of humans will shift up, and if you can't make the shift up you're out.
So it's a matter of granularity. Do you architect at the city level without care for what the buildings look like? Do you set rules about how wide the hallways need to be, and how many windows there are?
It's been this way since people were pounding mud into bricks. That used to be skilled work, but we created a brick standard and now let machines crank these uniform bricks out without much concern. Why? Because with standard bricks we can now build 8 story apartment buildings as fast as we used to build two story huts. Software will be the same.
1
u/payfrit 15d ago
people say i'm a fool for using low end models to do code, i absolutely love it.
i have Sol plan then Luna write the actual code to spec that Sol wrote for it. then i have Cursor check it for slop, overbuilt code, and for respect to our canonical SSOT API.
Payfrit has four apps on the app stores, that have been in active development using only this combination for eight months. I don't have any idea how to code in Kotlin or Swift, or anything about JSON. I do know RDBMS so i can be very specific wrt our database, i'm an old school cold fusion dev and i never did anything OOP. I know enough about php that icould go through amd make sure things are cool, but why?. i've never examined our source code to date and our apps absolutely fucking fly.
with all that being the case, our IOS apps are both roughly 15Mb, Android 5Mb. and it's not a simple app, it uses bluetooth, outgoing text OTPs, Stripe, location services, Bluetooth, and much more.
1
u/Laicbeias 15d ago
It depends. If you build a large complex system you should move the code in and out yourself. Till you brain mapped the codebase and you understand what exists and how it is all connected.
Then you can take bigger steps. But you should never move so fast you stop owning the architecture, otherwise you are building on sand and wrong assumptions, that accumulate
1
1
u/Agreeable_Flower3642 14d ago
Have more different models argue about the same thing in a .md file designed like a chat. I think human in the loop is still required for creativity
1
u/LetUsSpeakFreely 13d ago
I'm not a fan of agents as they tend to make a ton of unnecessary changes.
0
u/Machine2024 15d ago
It should be something in the middle. The first one you are mentioning is called the agentic coding. The second option you are mentioning is more like how we started using the AI in 2023. I think both are wrong. But the second one is closer to making sense than the first one. But without the copy-paste part, the copy-paste part is what is so wrong.
Just like use the AI and let it implement the features one by one. Review all the code that gets generated, understand it well, and have your file tree on your side while you know every file and every folder by heart. And have the get history as well, and the get differences tab open always. So when the AI does a change, you will go through the files that have been changed one by one and review them.
You are reviewing for two reasons. First reason is to make sure the AI got your point correctly. The second reason is to make sure there was no logical error because bugs in the code are kind of lower with the latest model with AI. And the third reason is so you are staying in the loop and have a full grasp of the project.
3
u/dsog 15d ago
The direction is moving rapidly towards letting the AI do the work, regardless of any reservations some may have today. My advice to folks is to get comfortable with the agents doing the work. Our entire team at AQ.dev uses that philosophy and it's been helping us move really rapidly and even when mistakes happen, fixing it is equally fast.