AI-assisted software development: choosing the right tool for the job
We frequently see software engineers copy-pasting code into (potentially insecure) LLM chat windows to debug complex system issues, only to receive generic advice that misses the architectural context of their project. Meanwhile, dev teams struggle with subtle bugs introduced by massive code changes proposed by AI agents and not properly reviewed by human developers.
The difference between a high-performing AI-enabled dev team and one drowning in technical debt often comes down to this: knowing how to incorporate AI and using the right tool for the job.
How to choose the right tool for the job
New AI tools are springing up every day, but with a sharp eye you'll notice they share common patterns for how users interact with them. Names and brands may differ, but being able to classify these tools into categories helps developers pick the right one for the job.
This doesn't mean new types of user interaction and new types of AI tools won't appear in the future. For developers working now, it's essential to be able to identify whether a new tool is something genuinely novel or just another variation of an existing type.
1. External chat – conversational assistants
Chatbots like ChatGPT were the first to hit the mainstream, even though the APIs underpinning them were available for a long time.
Chatbots are great for high-level discussions, brainstorming, and conceptual problem solving, but they quickly reach their limits for practical coding tasks, especially when they are not integrated with your codebase.
Typical use-cases: General-purpose questions, architecture design, explanations of concepts, troubleshooting.
When to use: When you need a dialogue to explore high level ideas or clarify a concept that spans multiple systems.
Pros: Natural language interaction, fast answers and feedback.
Cons: Not practical for copy-pasting code or providing relevant context.
Claranet’s advice with chatbots is to pay close attention to data sensitivity. Pasting production code, logs, or data into public chat services can lead to data leaks and compliance violations. Use anonymisation or internal tools when dealing with sensitive information.
2. Code completion – ghost-text suggestions
This is the "flow state" maintainer. It's the first integrated feature we found in IDEs like VS Code with GitHub Copilot, serving as the smartest autocomplete we've seen so far.
These have now evolved to be able to suggest larger blocks of code, but they are still fundamentally best at providing inline suggestions based on the current or recent files. Being fast comes at the cost of context breadth.
Typical use-cases: Writing a few lines, completing a function signature, filling in boilerplate code.
When to use: When you are focused on a single file or a single function and need quick, inline suggestions.
Pros: Seamless inline experience, low latency.
Cons: Limited to short snippets, might lack some understanding of context.
3. Integrated chat – code generation
This is a chatbot which is embedded in the integrated development environment (IDE) and which has access to the codebase. This allows for more targeted and specific coding tasks.
Typical use-cases: Generating a small, well-scoped piece of code such as a function, class, or unit test.
When to use: When the task is well defined and affects one or only a few files.
Pros: No need to copy and paste, context (input) can be seamlessly provided and code (output) is directly applied.
Cons: Requires a clear prompt and outputs may need manual tweaking.
4. Agent mode – autonomous multi-step assistants
Agents are the latest tool for AI-assisted coding. They're best suited to handling complex, multi-step tasks that span multiple files or even systems. They can plan, execute, and correct themselves autonomously, and can execute tasks with real-world outputs (such as running commands and deploying code).
Typical use-cases: Complex tasks like refactoring a whole module or implementing a large feature.
When to use: When the scope is project-wide and you need the AI to orchestrate a series of actions in sequence.
Pros: Can run for long time periods, manipulate many files, and even interact with external services.
Cons: Higher risk of unintended changes, requires careful review and security gating. Also have the longest and slowest feedback loop.
Where do agents run and why does it matter?
Local agents run directly on your machine, either embedded in your IDE or as terminal-based tools. IDE-integrated agents typically work on one task at a time, allowing you to observe each step and intervene when needed. Terminal agents offer more flexibility as you can spin up multiple instances in parallel with each tackling a different aspect of your project.
Cloud-based agents operate in managed environments where multiple agents can work simultaneously on different parts of your system. This parallel execution dramatically speeds up large-scale refactoring or migration projects. However, cloud agents require sending your code to external services, introducing data residency and compliance considerations. The trade-off is power and scale versus control and security.
Why choose one over the other?
Or, to put the question another, which type of agent is best for your workflow? For exploratory work or tasks requiring frequent human oversight and guidance, local IDE agents provide the right balance of assistance and oversight. For repetitive, well-defined transformations across large codebases—like framework upgrades or API migrations - cloud-based parallel agents can compress weeks of manual work into hours.
At Claranet, we often recommend a hybrid approach: prototype with local agents, then when the process has been proven to work, scale up with cloud-based parallel agents under appropriate guidelines and security controls.
How do we help you build a strategy?
Adopting AI tools isn't just about purchasing licenses. It requires a deliberate strategy to ensure these tools actually improve productivity without introducing security risks or increasing your technical debt.
At Claranet, we guide organisations through adopting AI tools into your software development workflow with a clearly structured process:
1. Choose the right tool for the job
Don't try to solve every problem with the same tool. A team maintaining legacy monoliths might benefit more from deep-context agents, while a team building greenfield microservices might prioritise fast code completion. We help you identify which types of AI coding assistant fit your specific workflows.
2. Establish security guardrails
Security cannot be an afterthought. We implement Policy as Code and secure gateways to ensure that while developers move fast, sensitive data doesn't leave the perimeter and any code generated by AI meets your compliance standards.
3. Focus on enabling developers
Tools evolve rapidly. We provide ongoing enablement to help developers master prompt engineering and context management, turning them from passive users into active pilots of their AI stack.
Ready to modernise your development workflow?
Navigating the ecosystem of AI coding tools can be overwhelming. Whether you are looking to boost developer productivity, modernise legacy applications, or secure your software supply chain, Claranet has the expertise to help you choose and implement the right solutions.
Get in touch with our application modernisation experts to discuss how we can tailor an AI-assisted development strategy for your organisation.