The AI agent for software development I rely on is a coding agent that works inside the repository, with limited permissions, and a set of automated checks that decide when a task is actually done. The model writes a good part of the code; tests, the pipeline and my review decide what gets merged. Here is the method, what independent research says about productivity, and where AI still gets it wrong.
AI agents for software development: the short answer
My main tool is Claude Code, an agent that reads the project, edits files and runs commands in the terminal. Three rules go with it:
- every task has a definition of done that a machine can check: tests, type checks, a build;
- the agent gets only the permissions it needs, and risky actions ask first;
- nothing reaches production without the pipeline and a human review.
With those rules in place, the agent takes the repetitive work and I keep my attention for architecture, security and decisions.
Assistant or agent: the difference
An assistant completes code as you type or answers in a chat window. A coding agent takes a task, explores the codebase, edits several files, runs the tests and fixes what breaks, until the task is done or it stops to ask you something.
The practical difference is where you review. With an assistant you review each line as it appears. With an agent you review a whole change set at the end, so you need stronger automated checks and permissions you set before it starts.
How I work with a coding agent
My workflow follows the official Claude Code best practices, which name the core problem well: the agent "stops when the work looks done", and without a check to run, "'looks done' is all it has to go on."
The steps:
- Written context. The repository has a short instructions file with the commands for tests, type checks and linting, plus the conventions and traps of the project. The docs recommend keeping it short, because every line competes for attention on every task.
- A spec before code. For bigger changes I first write what the change must do and how to verify it, then start the agent in a fresh session.
- A check that passes or fails. Tests, type checks and the build are the definition of done. When they exist, the agent runs them and fixes its own mistakes before it stops.
- Rules with no exceptions. Things that must never happen, such as reading secret files or touching migrations, go into permission rules or hooks instead of the instructions file. The docs are explicit: if something has to happen every time, make it deterministic.
- Human review. I read the diff the way I would read a colleague's, with extra care on access control, data handling and new dependencies.
What the research says about productivity
Independent data is more cautious than the marketing. METR's study, Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity, followed 16 experienced developers through 246 real tasks in their own projects. With AI allowed, tasks took 19% longer. Before the study the developers expected AI to cut their time by 24%, and afterwards they still believed it had cut it by 20%.
The DORA 2025 report from Google Cloud, focused on AI-assisted software development, reaches a similar conclusion at the organization level: "AI's primary role is as an amplifier, magnifying an organization's existing strengths and weaknesses."
My reading: AI speeds up teams that already have solid tests, pipelines and review habits, and it multiplies the mess where those are missing. How fast it feels is a poor measure of how fast it is.
Where AI still gets it wrong
The mistakes I watch for most:
- Invented dependencies. Spracklen and colleagues found that, on average, at least 5.2% of packages suggested by commercial models and 21.7% of those suggested by open-source models do not exist.
- Plausible but vulnerable code. In Asleep at the Keyboard?, about 40% of 1,689 programs Copilot wrote for security-relevant scenarios were vulnerable. The study dates from 2021, but the weak spots it found are still the ones to check: access control, input handling, secrets.
- Lost context. In long sessions the agent forgets decisions made early on. Short sessions with a written spec work better for large tasks.
- Tests bent to fit the code. An agent can change the test instead of fixing the code, so I always reread changes to tests.
For apps written mostly with AI, I keep a separate checklist: DevSecOps for AI-written apps.
Permissions, data and sandboxing
A coding agent runs commands on your machine or in a remote environment, so treat it like a user with access to your code. The Claude Code security docs describe permission modes, sandboxing for shell commands and deny rules, and state: "You're responsible for reviewing proposed code and commands for safety before approval."
My rules:
- production secrets are never in the folder the agent works in;
- network commands and destructive operations ask first or are denied;
- untrusted code runs in an isolated environment;
- the agent connects only to MCP servers I know.
What changes for a software team
For a team, the starting point is the automated checks. If a project has few tests and a weak pipeline, AI produces more code that someone has to verify by hand. If the checks are there, the agent becomes a real accelerator.
The order I suggest: tests and pipeline first, then shared permission rules in the repository, then agents on well-defined tasks, measuring lead time and defects before and after. If you are thinking about AI beyond the codebase, my page on AI agent development covers agents that work inside business processes.
Frequently asked questions
What is the best AI agent for software development?
There is no single best one: it depends on the language, the project and how you use it. An agent that works in the repository with clear permissions, plus automated checks that verify its output, matters more than the brand. I use Claude Code, and the method carries over to other tools.
What can AI agents do in software development?
Write code from a spec, write and run tests, fix bugs from error messages, refactor, explain existing code and draft documentation. Decisions on architecture, security and priorities stay with a person.
Will AI agents replace software engineers?
The work is shifting from writing every line to specifying, verifying and reviewing. Defining what "done" means, reading code quickly and spotting a security problem are becoming the core skills.
Is AI-generated code secure?
Not by default. Studies find vulnerabilities and invented dependencies in a share of generated code. It becomes trustworthy through human review, tests and a pipeline that checks secrets, dependencies and access control on every change.
Sources
- Best practices for Claude Code, Anthropic
- Security, Claude Code Docs, Anthropic
- Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity, Becker et al. (METR), 2025
- State of AI-assisted Software Development 2025, DORA, Google Cloud
- We Have a Package for You! A Comprehensive Analysis of Package Hallucinations by Code Generating LLMs, Spracklen et al., USENIX Security 2025
- Asleep at the Keyboard? Assessing the Security of GitHub Copilot's Code Contributions, Pearce et al., IEEE S&P 2022