On this page
- What “AI in development” actually means
- Where AI tools genuinely help
- Boilerplate and repetitive code
- Tests
- Reading unfamiliar code
- Translating between languages and frameworks
- Drafts of documentation and commit messages
- Where they don’t help, or hurt
- Unclear requirements
- Architecture decisions
- Security-sensitive code
- Newer or niche libraries
- Performance work
- How we review AI-written code
- What this changes for the client
- A sensible way to adopt these tools in your own team
- The short version
AI coding assistants are now part of most development teams’ daily tools, ours included. The marketing around them is loud, so it is worth being plain about what they do well, what they do badly, and what process keeps the output safe. This is how we use them at our Bhubaneswar studio, and what we tell clients who ask.
What “AI in development” actually means
Three different things get lumped together.
- Autocomplete inside the editor. It suggests the next line or block as you type.
- Chat and agent tools. You describe a task, the tool reads your codebase, proposes changes across files and can run tests.
- AI inside the product. Features like search, summaries or assistants that your customers use. That is a separate topic, and we cover one part of it in our post on RAG versus fine-tuning.
This post is about the first two: tools that help engineers write software.
Where AI tools genuinely help
Boilerplate and repetitive code
Form validation, CRUD endpoints, data-transfer types, serializers, migration scripts. This code is well understood, easy to check and boring to type. An assistant produces a good first draft in seconds, and an engineer spends their time on the review instead.
Tests
Given a function, an assistant is good at proposing test cases, including edge cases a tired engineer skips: empty input, null, a date at midnight, a negative quantity. You still decide which tests matter, but the starting list is useful.
Reading unfamiliar code
Dropping into a legacy module and asking “what does this function do and who calls it” saves real time. The explanation can be wrong, so you confirm it by reading the code, but it points you at the right place faster than searching alone.
Translating between languages and frameworks
Porting a utility from JavaScript to TypeScript, converting a SQL query to an ORM call, or moving a component from one UI library to another. The pattern is mechanical, so the tool is reliable.
Drafts of documentation and commit messages
Good for a first pass. A human should still edit them, because tools like to describe what the code does rather than why it exists.
Where they don’t help, or hurt
Unclear requirements
If the business rule is fuzzy, an assistant will fill the gap with a plausible guess. It does not know that your refund policy in Odisha differs from your policy in Karnataka. Clarifying requirements with the client is still a human job, and it is where most project risk lives.
Architecture decisions
Assistants optimise for the file in front of them. They will happily add a fourth way of doing something your codebase already does three ways. Decisions about boundaries, data models and what to build versus buy need someone who holds the whole system in mind.
Security-sensitive code
Authentication, payment flows, permission checks and anything handling personal data. Generated code in these areas often looks right and misses a case: a missing ownership check, a token that never expires, an unescaped value. We treat these areas as human-written and human-reviewed, with AI used only for suggestions.
Newer or niche libraries
Tools are trained on past code. For a library that changed its API recently, they may produce calls that no longer exist. This happens often enough with fast-moving mobile and frontend packages that we always check against the official docs.
Performance work
An assistant can suggest an optimisation, but it cannot see your production traffic. Profiling and measuring remain manual, and you should never accept a “faster” rewrite without a measurement.
How we review AI-written code
The rule is simple: the engineer who commits the code owns it, no matter who or what typed it. “The AI wrote it” is not an answer in a review.
- Read every line before committing. If you cannot explain a block, you do not merge it. Generated code that you only skimmed is where bugs come from.
- Run it. Unit tests, type checks and linting run in CI on every pull request, the same as human code. Agent tools that run the tests themselves are helpful, but CI is the final judge.
- Check the dependencies. Assistants sometimes import a package that does not exist or pull in a heavy library for a one-line job. Every new dependency is checked by hand: does it exist, is it maintained, is the licence acceptable.
- Look for the missing case. We read generated code asking what it does not handle: errors, empty states, slow networks, large inputs, other users’ data.
- Keep pull requests small. A 100-line change gets a real review. A 2,000-line generated change does not. If an agent produces a large diff, we split it.
- Never paste secrets or client data into a tool. API keys, customer records and unreleased client code stay out of prompts unless the tool and the contract allow it. This matters under India’s data protection rules, and it is a client-trust issue regardless.
What this changes for the client
Honest answer: it changes some things and not others.
It helps us move faster on the routine parts of a build, so more of the budget goes to design, testing and the hard problems specific to your business. It does not remove the need for discovery, a clear scope, QA on real devices or a person who is accountable for the result.
It does not mean the work is free. Reviewing, testing and integrating still take engineer time, and we do not discount a project on the grounds that “AI does most of it”. We tell clients how we work, and where a client has rules about AI tools on their code, we follow them.
A sensible way to adopt these tools in your own team
If you run an engineering team in Odisha or Bangalore and want to start, this order works.
- Start with tests and boilerplate. The risk is low and the benefit is easy to see.
- Write down a short policy: what may be pasted into a tool, which tools are approved, and who owns reviewed code.
- Keep CI strict. Type checks and tests catch a lot of generated mistakes before a human sees them.
- Track what goes wrong. If reviewers keep finding the same kind of error, put it in your guidelines.
- Train juniors to understand code before they accept it. A junior who copies suggestions without understanding them stops learning, and the team pays for that later.
The short version
AI tools are good at the predictable parts of programming and weak at judgement. Use them for drafts, tests and reading code. Keep humans on requirements, architecture and security. Review everything as if a new hire wrote it, because in effect one did.
If you are planning a build and want to know how we would use these tools on your project, talk to us and we will explain our process in plain terms. For more on how we work on apps and platforms, see our software development services.