The debate around AI-assisted coding is split into two loud camps: skeptics decrying a flood of unmaintainable "AI slop," and enthusiasts boasting 10x productivity gains. There is truth to both sides. To understand why, we have to look at the dividing line:The debate around AI-assisted coding is split into two loud camps: skeptics decrying a flood of unmaintainable "AI slop," and enthusiasts boasting 10x productivity gains. There is truth to both sides. To understand why, we have to look at the dividing line: software engineering discipline.
The reason for this divide is simple: AI agents are a force multiplier. They magnify both your strengths and your weaknesses.
AI doesn’t fix engineering problems.
It magnifies them.
Strong teams get stronger with AI.
Weak teams fall behind even faster.
Bijit Ghosh
If you already have strong architectural discipline, agents will accelerate your high-quality execution. But if you have poor habits and cut corners, agents will generate technical debt and unmaintainable garbage at a velocity you could never match manually.
The illusion of the instant prototype
Bootstrapping your initial prototype has become a piece of cake. You feed an AI a vague description of what you want, and it outputs a shiny application that seems to work. Where previously developers needed to spend years mastering a programming language and learning the quirks of the entire ecosystem, you can now just ask an AI what the right set of tools are. Even non-technical employees can do it.
It seems to work, you got it working on localhost, great! Let's share it with the world.
Maintaining slop
You just shared your project, but the initial response is not what you had hoped for. The app opened fine, but users immediately find edge cases that do not work. The app crashes on untested paths. But it is of little consequence.. You copy-paste your bug report into your agent session and give it a firm: "Fix it!"
But how can you be sure that the fix does not break other parts of your app? When your application is small enough, you can manually test all paths before you update it. But anything worthwhile will inevitably grow and gain complexity. You end up losing reputation for your application while staying busy playing whack-a-mole with bugs.
The Necessity of Feedback Loops
Software developers have gone through the pain of bugfixes and updates through many years of experience. As a result, they have built many automated and manual steps to protect them from their own mistakes. Such feedback loops operate at various different scales:
- High-level loops: Customer feedback, product metrics, backlog refinement.
- Operational loops: Live application logs, vulnerability scanning, threat modelling.
- Pipeline loops: CI/CD checks, pull request reviews, integration tests.
- IDE-level loops: Unit tests, static code analysis, compilation checks.
Managing all these feedback loops takes time and effort. This is why teams tend to automate **any **step that can be automated.
The Agentic Shift
Agentic engineering shifts the boundaries of what can be automated. Naturally, it is used to write code, but it can do tasks that the CI/CD previously could not:
- It will tirelessly review your code again and again.
- It can crawl through huge log files and find the root cause of your errors.
- It can dig through the massive backlog of potential security vulnerabilities and filter out false positives.
- It can discuss architecture all day long without getting bored.
- It is great at writing test suites to automate tests for your next iterations.
- It can look up documentation for you.
You become less dependent on manual validation by you or your colleagues. AI can do all of that, but it is up to you to tell the AI to do it. If you do not, your code will definitely slop. You need to explicitly tell the agent what the target quality should be, or it will guess what would be appropriate.
Especially as your codebase grows, it becomes more and more important to validate all your work and make your agent jump through all the hoops that a human developer normally would.
Managing Agents as High-Risk Contributors
To get an agent to produce code that meets your standard, you need to guide it. Coding agents are some of the most senior developers you will find; they have great ideas. You cannot expect them to create exactly the software that is in your mind, though.
Treat those pesky agents like a stubborn developer that tries to cut corners.
- Rigid git discipline: Go beyond telling an agent what your quality standard is; enforce it with a pipeline. Let the agent make all changes through PRs which have to pass your CI pipeline.
- Architectural Decision Record (ADR): Whenever you decide to make a change, document it. Make sure your agent reads your entire ADR before making any changes.
- Autonomy rules: Tell your agent what it may and may not decide on its own.
- Plan mode: Just like with human developers, talk about the work you are about to do. Use plan mode to verify that an agent understands the goal.
- Definition of done: Explain to your agent when any piece of work is done. Make the agent review itself using those criteria before finishing up.
You can further instruct your agent with MCP servers, custom skills, and AGENTS.md files to explain the desired tooling and the context it operates in.
The Junior developer dilemma
In this post, I clearly outlined the importance of software engineering discipline. Most developers working now have gained their experience by doing the grunt work that AI is now rapidly replacing. So how will the next generation of coders get there?
I am not too worried about it. Junior developers can actually learn many times faster. AI agents are excellent at explaining complicated topics and can fine-tune explanations to your level (which most human senior developers struggle to do).
One of the most important qualities of a software developer is an inquisitive nature. Nowadays, your agent can write your whole application without you having a clue what it does behind the scenes. The responsibility of a junior developer is to understand all of it and question every choice the agent makes. Make sure you understand why it is preferable over the alternatives. Whenever it dreams up an amazing solution, ask it for the motivation behind it. When your agent is done, ask it for a critical review of the work. Read the review and pay attention.
As a junior, you should exploit this senior engineering agent for knowledge whenever you can. Where previously you would have to squeeze yourself in between meetings, you can now ask for guidance 24/7.
You need to be eager to learn and improve. When you are you will be just fine!
Top comments (0)