Post by Sagnik Nandy

One of the things I love most about Agentic Coding is also one that worries me. The contract between a developer and code was very clear: developers controlled the design choices, logic and, most importantly, accountability associated with code. In my 30+ years of coding, I’ve rarely been “positively surprised” by my code because, at the end of the day, I was the one writing it. I knew the choices I was making, I knew how things were structured and I knew what to expect performance wise. So the positive surprises were limited to “Nice! This did what I thought it would do.” Basically, coding in the past was bound by a developer’s knowledge and choices. Agentic coding has completely flipped that script. Now I regularly see code going above and beyond one’s expectations and expertise. Example: My frontend skills are okay-ish at best. So for personal projects, I used to fall back to a simple web UI or making it a command line tool. That completely changed in the past 6 months. Now, for personal projects, I build fairly functional frontends. It’s magical to request a persistent sidebar or collapsible hamburger and see it done in minutes. This is code going beyond my expectations and positively surprising me. I absolutely love it! However, this means ceding a lot of choices and decisions completely to the engine. When it comes to areas outside one's expertise, we increasingly trust the engine to have done the right thing as long as the final output looks right. So if there are bad decisions or choices that look deceptively acceptable, we might overlook them completely. This really worries me. As agents code bigger efforts, with tens of thousands of lines of code generated daily, it’s easy for small issues with big impact to creep in. Why is this any different from human generated bugs? (1) Developers will increasingly know less about some of the design choices and decisions (so when issues happen they become harder to detect and debug) and (2) The prolificness of these systems might mean that even if the error rates are lower - the absolute numbers can be higher. Also, we will increasingly build systems that developers are less invested in. Some of the best design choices and enhancements I’ve seen didn’t happen at the first go. They happened because developers were living and breathing the code and system choices and continuously thought about optimizing things, fixing bottlenecks and evolving systems. So, will we have a lot more throughput but risk building systems that are only 90% as good as they could’ve been and with more hidden little issues scattered throughout? Maybe not. Maybe these systems will get better at detecting issues and fixing them early. Maybe the SDLC processes will evolve to provide adequate guardrails. Maybe we will be able to get to a state where we can combine the best of both worlds. I look forward to seeing how this all plays out. What do you think?