Should you use AI agents in development?

What decides whether AI agent helps

First things first, let's define what's an AI agent here. Simple answer — it's not a chat you dictate code to. It's a tool that's most useful inside the repository: to read the project files, search the code, run checks and prepare changes for review. An executor built into the process, not a reference book.

The next important issue is measuring the gain. Yes, you can't do that fully, but you can reason honestly: how long would a task take a developer alone vs with an AI agent? On complex business logic the gain is moderate. On routine work the time collapses — 2–3 hours may turn into a couple of minutes. Typical modules, repetitive boilerplate, mechanical refactoring: AI agent takes that off the plate almost entirely.

We at Sensus assess that with a realistic approach: you can gain around 2–3 times more work on that routine layer and close to nothing where an actual judgment is required. But it's not magic. So, let's take a look at what decides the outcome.

The agent works inside the project, not alongside it. Run in the context of the whole repository, the model sees the structure, config, history, dependencies, and can verify its own work — type checker, linter, code search. It doesn't invent solutions from nowhere, but leans on existing code and adapts to it. This is a sharp improvement over a model answering blind.

Context comes through documentation. Docs written for both a team member and an agent work on three levels:

• general conventions (naming, prefixes, imports, code style);
• the architecture (layers, how data travels from user action to server and back);
• individual modules: what each does and how it connects.

In Sensus we call it a terrain map. Without it, an agent reconstructs the project from indirect clues and often guesses. With it — writes in the project's conventions from the start.

Data types come from the API schema, not written by hand. Strict types are generated from the schema. All client code rests on them. The agent can't fantasise a non-existent field or muddle a response format — such code won't pass type checking. The schema is the source of truth; strict typing is the auto watchman catching mistakes before a human sees them.

A feedback loop closes it all — in a safe mode. The agent runs the checks itself, reads the output, fixes the errors — only then hands it over for review. A separate branch, a pull request, merging left to a human, explicit permissions in a config — it cannot quietly commit to master or take the repository down.

The main thing we've found out here is simple. What does a project need for an agent to be useful? The answer has 4 parts: maintained documentation, strict uniform conventions, generated types and fast automated checks. The pattern is simple: AI agent is exactly as good as the project organised around it. And this answers the next question.

How the models actually work (the main flaws in AI agents)

The model runs on guesses, not full understanding. It predicts the most plausible continuation. Even when the output looks like deep understanding, it's not. Under the bonnet it's statistically plausible guessing. The less support it gets — docs, types, examples — the more it improvises, and the more confidently it can be wrong. A confident tone is not a sign of correctness.

Context degradation. The longer the dialogue, the more the focus blurs. Early details get lost, earlier agreements get contradicted. Not a fault, a natural property. The sane response: small verifiable steps and a regular context restart.

Hallucinations. The model can confidently cite a non-existent method, parameter or file. Strict typing turns part of these into compile errors; where there are no checks — logic, copy, product decisions — catching inventions falls to a human.

Sensitivity to phrasing. The same request put differently gives different results. A vague brief all but guarantees the agent fills the gaps with its own assumptions — not necessarily the right ones.

No real memory or intent. AI agent remembers nothing between runs. It rebuilds the picture from what it's given. And it won't stop itself to ask whether the business needs this at all. That stays a human job.

What AI agent gives and where it fails

The main win we see is speed on routine and consistency. When a human tires and cuts corners, AI agent repeats the pattern for the 100th time without any complaints. Agent-ready documentation also speeds up onboarding. The flip side: the approach demands a mature project — the tool amplifies what's already there.

But the trickiest problem is the missed detail. You can do 95% of the code flawlessly, but a quiet slip in the remaining 5% — an edge case, an unusual state — and because the bulk looks neat, it slides past a quick glance. That's why handing over a whole feature is risky: the larger and vaguer the task, the faster wrong assumptions pile up. And an agent doesn't see the finished result the way a user would — judgment and taste stay with the human.

What to watch

Review is mandatory and non-negotiable, especially in sensitive places: money, payment logic, access rights. It's obvious that in fintech the price of a missed error is too high for a 'looks right' level of blank review. Secrets stay out of the agent's context. Stale documentation is more dangerous than none — the agent will confidently reproduce an outdated approach. And regenerate types after backend changes.

So, is AI agent actually worth it?

AI agent seriously speeds up the work. Well, as long as the team keeps its head on and does the critical things itself. The agent replaces hands, not brains. It does execution, not thinking. Ideas are still born, weighed and approved by a person who understands the business logic and consequences.