AI coding tools have moved from novelty to everyday use remarkably quickly. Assistants such as GitHub Copilot suggest code as you type; agentic tools such as Claude Code can read a codebase, run commands, make multi-file changes and explain what they did. Automation platforms like n8n let teams wire AI into business workflows without building everything from scratch.
I use these tools daily. They have changed how I work — but not in the way the most breathless headlines suggest. Here is a practical view of what they do well, where they fall short, and what it means for businesses building software.
What AI tools are genuinely good at
Removing boilerplate
Form scaffolding, API client functions, type definitions from a JSON sample, test setup, repetitive mapping code — the work that is necessary but not intellectually demanding. AI tools produce a solid first draft in seconds, and reviewing a draft is faster than typing it.
Understanding unfamiliar code
Asking an assistant to explain a module, trace where a value comes from or summarise what a legacy function does is one of the most valuable uses. For consultants and new team members, it shortens the time needed to become productive in an unfamiliar codebase.
Debugging support
Given a stack trace, relevant code and a description of the symptoms, AI tools are good at proposing likely causes and things to check. Agentic tools can go further: run the failing test, add logging, try a fix and re-run. They do not replace systematic debugging, but they speed up each step of it.
Writing and improving tests
Generating test cases — including edge cases a tired developer might skip — is a strong use case. The tests still need review: a test that asserts the current buggy behaviour is worse than no test.
Mechanical refactoring and migrations
Renaming across a codebase, converting class components to hooks, migrating to new API signatures, updating deprecated patterns: tasks that are well-defined but tedious. Agentic tools can handle many of these across multiple files, with a human reviewing the diff.
Documentation
Drafting READMEs, API documentation, code comments and architecture summaries from existing code — then editing for accuracy — takes a fraction of the time it used to.
Where they fall short
They do not know your business
An AI tool can write a function that calculates a discount. It does not know that your enterprise customers have negotiated exceptions, that finance rounds differently, or that a regulation applies in one region. Requirements, context and trade-offs still come from people who understand the business.
Architecture needs judgement
Tools can suggest patterns, but deciding how a system should be structured — where boundaries go, what to optimise for, which trade-offs to accept for this team and budget — depends on context that goes beyond the code. A model will confidently generate code in whatever direction you point it. Pointing it in the right direction is the valuable skill.
Confident mistakes
AI-generated code can look correct and still be wrong: a subtle off-by-one, an API that does not exist in the version you use, an edge case silently ignored, a security check missing. Because the output is fluent, errors are easy to overlook. Every change needs the same review you would give a colleague's pull request — arguably more.
Security and licensing awareness
Generated code can introduce insecure patterns (unsanitised input, overly broad permissions, secrets in code) if nobody is looking for them. Teams also need a clear policy on which code and data may be shared with which tools.
Speed can create a new kind of technical debt
If a team can generate code five times faster, it can also generate technical debt five times faster. Without architectural guidance, conventions and review, a codebase grows quickly in inconsistent directions.
How development work is changing
In teams that use these tools well, I see a consistent shift:
- Less time typing, more time specifying and reviewing. Clear descriptions of what should be built — and why — produce better results from both people and tools.
- Higher value on reading code. Reviewing a generated diff critically is now a core skill.
- Architecture and conventions matter more, not less. Tools follow existing patterns in the codebase. Good patterns get amplified; bad ones do too.
- Tests become the safety net for speed. Fast generation only works when a strong test suite and CI pipeline catch regressions immediately.
- Senior judgement becomes more leveraged. One experienced engineer guiding tools and reviewing output can move a lot of work forward — provided that judgement is actually applied.
Using AI tools responsibly in a team
A few practices make adoption productive rather than chaotic:
- Agree on a usage policy. Which tools are approved, what code and data may be shared, and how licensing concerns are handled.
- Keep humans accountable for every merge. "The AI wrote it" is not a review outcome. The person who merges owns the change.
- Invest in guardrails first. Linting, type checking, automated tests and CI make AI-assisted changes safer to accept.
- Document conventions. Tools like Claude Code can read project instructions and conventions; well-written guidance improves output quality significantly.
- Start with low-risk, high-volume tasks. Tests, documentation, boilerplate and migrations before core business logic.
- Measure outcomes, not lines of code. Look at lead time, defect rates and review load — not how much code was generated.
Beyond coding: workflow automation
Some of the most practical business value is outside the editor. Platforms such as n8n make it straightforward to connect systems — CRM, email, spreadsheets, internal APIs — and add AI steps where they help: classifying incoming requests, extracting data from documents, drafting responses for a human to approve. The same principle applies: automate the repetitive steps and keep people in the loop for decisions that matter.
What this means for businesses
AI tools can make capable teams noticeably more productive. They do not turn an unclear product vision into a good product, and they do not replace the engineering judgement needed to build software that stays maintainable, secure and fast.
The winning combination is experienced people who understand architecture and the business, using modern tools to move faster — with quality gates that keep that speed safe. If you are considering how to introduce AI-assisted development into your team, or want to automate repetitive workflows, I can help you set it up in a way that improves delivery without compromising quality.