Building Software With AI Coding Agents: Speed, Quality and Risks

AI coding agents speed up software development on well-defined, repetitive work such as boilerplate, tests, refactors, migrations and documentation. They do not make a project cheaper or safer on their own. Clear scope still drives the cost, and engineers who review every change, backed by automated checks, still decide the quality. Used with the right rules, they mean earlier demos and more frequent deliveries; used without them, they mean bugs that are hard to spot.

This article is for companies that commission software and ask: "Will AI make my project faster or cheaper, and is it safe?" We use coding agents every day in our web application development projects. Here is what we hand to them, what we never hand over, and what that means for your project.

What is an AI coding agent?

Code completion tools suggest the rest of the line you are typing. A coding agent goes a step further: it works across the whole codebase, finds and reads the relevant files on its own, runs commands in the terminal, runs the tests, tries to fix what fails and finally proposes a change. An engineer gives it a task such as "add email validation to this form and write the tests," and the agent plans, implements and reports back.

Claude Code, OpenAI Codex, GitHub Copilot's agent mode and Cursor are well-known examples. Most can be set to ask for approval before running a command or changing a file. Agents can also connect to tools such as a database, an issue tracker or documentation through protocols like MCP, which we explain in What Is MCP?

Where do coding agents speed things up, and where don't they?

Agents are strong where the task is clear and the result is easy to verify:

  • Boilerplate: the repetitive skeleton of a new screen, API endpoint or data model.
  • Tests: unit and integration tests for existing code, especially systematic coverage of edge cases.
  • Refactors: changing a name, a library usage or a code pattern consistently across many files.
  • Migrations: moving from one framework version to the next, or replacing an old API with a new one.
  • Documentation: setup notes, API descriptions and summaries of what the code does.
  • Prototypes: turning an idea into a clickable demo quickly, so decisions are made on screen rather than on paper.

The work agents cannot speed up is often the most expensive part of software:

  • Unclear requirements: if nobody knows what is wanted, the agent just builds the wrong thing faster.
  • Architecture decisions: how the data model is shaped, how the system grows, which part runs where. These decisions last for years and need an understanding of the whole business.
  • Domain knowledge: an agent cannot know the exception to an accounting rule, the regulations in your industry or how your users really work.
  • Stakeholder alignment: balancing what different departments expect is a communication job, not a coding job.

So agents shorten only the part of a project where code gets written. Discovery, design, decisions and acceptance testing still need the same care.

Which guardrails protect quality?

Code written by an agent has to pass through the same gate as code written by an engineer. These are the controls we use:

  • Small changes: the agent gets one job at a time. A change that runs to thousands of lines cannot be reviewed properly.
  • An engineer reviews every change: code does not go straight into the main branch because an agent wrote it. The reviewer takes responsibility for it as if they had written it.
  • Automated tests and CI: every change is built and tested in the continuous integration pipeline before it is merged. Code that fails the tests waits.
  • Code style and static analysis: formatting, naming and common bug patterns are checked by tools. Project-specific rules are given to the agent in writing too.
  • Security scanning: code and dependencies are scanned for known vulnerabilities.
  • No secrets in prompts: passwords, API keys and connection strings never go into prompts, chats or files the agent can read.
  • Dependency checks: every new package an agent suggests is checked for maintenance, license and whether it really exists. Models sometimes invent package names that do not exist.

Most of these controls belong in any good software team anyway. Agents do not make them unnecessary; they make them more important. We describe shipping small changes every day behind automated checks in DevOps without the drama.

What are the risks of AI coding agents?

  • Subtle bugs: agent code usually looks clean and compiles. The problem hides in an edge case or a misunderstood business rule, and clean-looking code can lull the reviewer.
  • Security flaws: a missing permission check, unvalidated user input or an unsafe default can sit inside code that appears to work.
  • Licensing and IP: ownership of the generated code and the licenses of the components it uses should be settled in the contract.
  • Confidentiality: while it works, the agent sends code and the files it reads to a model provider. That is why the terms under which client code is processed matter, and why real personal data should never enter the development environment.
  • Over-reliance: if a team starts accepting agent code without understanding it, the system turns into something nobody fully knows. The bill arrives at maintenance time.
  • Agent permissions: an agent that can run commands can delete files or touch the wrong environment when misdirected. That is why agents do not get access to production systems or production databases.

All of these risks can be managed, but none of them manage themselves. For the wider security picture, see our cybersecurity checklist for growing companies.

How do we work with coding agents?

Our team uses coding agents every day. The split is clear: design, architecture and review stay with people; well-defined implementation work goes to agents.

In practice, an engineer frames the task as a small, clear job, shows the agent the project's rules and the relevant files, reviews the proposed change line by line and fixes it where needed. The change then goes through our Jenkins CI/CD pipeline, on projects built with .NET 8 and SQL Server. What counts is the result of the tests and the review, not the agent's own account of what it did.

Working with agents had one side effect we did not expect: waiting. While an agent edits several files and runs the tests, the engineer moves on to something else and can miss the moment it finishes or asks for permission. Next Notify came out of that need: it starts at sign-in, waits in the tray or menu bar and sends a desktop notification when the agent finishes a task or asks for permission.

What does this mean for a company commissioning software?

Here is how working with a team that uses coding agents shows up on your side:

  • Faster iterations: your feedback reaches the screen sooner.
  • Earlier demos: ideas show up as prototypes early, so a wrong direction is caught while it is still cheap.
  • Scope still sets the cost: if what to build is unclear, change requests keep coming or integrations are complex, agents do not make that cost go away. Review, testing and quality assurance remain fixed parts of the work.

Before you start with a vendor, ask these questions about their AI use:

  • Which coding agents and which model providers do you use?
  • How do those providers handle our code and data, and is it used to train models?
  • Does an engineer review every change the agent writes?
  • At which stage do automated tests, static analysis and security scanning run?
  • Does real customer data ever enter the development environment?
  • How does the contract define ownership and licensing of the generated code?

A team that cannot answer these clearly may be using agents to work without control, not to move faster. If you want to look at AI beyond software development, across your business processes, see our AI consulting page.

The agent writes the code; an engineer always owns it.

Frequently asked questions

Will coding agents make my project cheaper?

They can lower some line items, especially repetitive development work and prototypes. Total cost is still driven by how clear the scope is, how complex the integrations are and what quality you expect. Unclear scope is expensive with agents too.

Is code written by an agent secure?

Not by default. Agent code has to be reviewed, tested and scanned like any engineer's code. Security comes from the process around the tool, not from the tool itself.

Is our source code sent to an AI provider?

While the agent works, the relevant parts of the code are sent to the model provider. Whether that data is used for training and how long it is kept depend on the provider's terms and the plan in use. On sensitive projects, settle these terms in writing before work begins.

Will coding agents replace developers?

Not in our experience. Agents speed up implementation, but engineers still decide what to build, how to design it and whether the code is ready to ship. What changes is that engineers spend more of their time on design and review.

Can coding agents work on an existing project?

Yes. Agents are useful for reading and understanding an existing codebase and for writing tests. On older projects with few tests, the first job is to add tests for the critical flows before any changes begin.

Where to start?

On your next software project, ask your vendor to describe their AI use in writing: which tools, which controls and which data rules. The question list above is a good place to start that conversation. If your own team will use agents, pick a small job first, write down the review and testing rules, then widen the scope.

If you want your web application built by a team that uses coding agents within a controlled process, get in touch.

← All articles

Chat on WhatsApp