StackLift
AI Agents in Software Development: What to Automate First
Agent OpsAgent Ops
Agent Ops / 5 min read

AI Agents in Software Development: What to Automate First

A guide to AI agents in software development: which tasks to delegate first, what to keep with people, and the guardrails you need before scaling up.

How this article was made: drafted with AI assistance, then reviewed and approved by the StackLift team before publishing.

AI agents in software development can now read a repository, plan a change, edit several files, run the tests, and open a pull request. Their capability is real, but the question facing engineering leaders is more practical than whether agents can write code. Which work should you hand over first, what should stay with people, and what has to be in place before you let them run? Here is a sensible order for adopting them.

What this article makes clear

  • Delegate work that is bounded, verifiable, and reversible first, such as tests, documentation, and mechanical refactors.
  • Keep architecture, security, data, and release decisions with named senior engineers.
  • Run agents with least privilege on feature branches, behind human approval, and away from production secrets.

How an agent differs from an autocomplete tool

An autocomplete tool suggests the next few lines while a developer stays in control of every keystroke. An agent is given a goal and takes multiple steps by itself: it searches the code, makes edits, runs commands, reads the results, and tries again. The unit of review changes from a suggestion to a whole pull request.

This changes the risks as well as the benefits. An agent can do much more without supervision, so mistakes can spread further before anyone sees them. It also has tools and credentials, which turns the question of what it is allowed to touch into a real security decision rather than a matter of preference.

Use three tests to choose the first tasks

Good first tasks pass three tests. They are bounded, with a clear start and finish inside a small part of the system. They are verifiable, so a test suite or a quick review can show whether the result is right. And they are reversible, which means a bad result costs little more than a closed pull request.

If a task fails any of the three, wait. Work that sounds simple can still fail these tests. Changing a billing calculation might be a one-line edit, but it is hard to verify fully, and a mistake is hard to reverse once customers have been charged.

Good starting points for delegation

Adding tests to existing code is a strong first use, particularly around behavior that is already understood. Have a person check that the tests assert something meaningful, as generated tests can simply confirm whatever the code currently does. Documentation, code comments, and changelogs also work well, as do routine dependency updates with an existing test suite to catch breakage.

From there, move on to mechanical refactors, such as renaming across a codebase or moving from a deprecated API to its replacement. Agents are good at this kind of patient, repetitive work. Reproducing a reported bug and proposing a fix is another useful task, as long as the failing test comes first, so that you can see the problem was actually solved.

Well-specified small features are a sensible next step once the team trusts the process. The quality of the specification matters a lot here. A clear ticket with acceptance criteria gets a far better result than a vague one, which is a useful side benefit for human developers too.

What should stay with senior engineers

Keep with people the decisions that shape the system or that are hard to reverse: architecture, data models, authentication and permissions, migrations on production data, and anything affecting money. Agents can do a lot of the groundwork, such as drafting options, exploring the code, or preparing a migration plan, while a named engineer makes the decision and answers for it.

Release decisions belong here too. Whether a change is ready for customers depends on context about timing, risk, and the business that an agent does not have. The principle is simple: agents draft and accelerate, and named senior engineers review and approve.

Guardrails to put in place before scaling up

Start with least privilege. Run agents in a sandbox with access only to the repositories and tools each task needs. Have them work on feature branches, and use branch protection so that nothing merges without human approval. Keep production credentials completely out of reach. At StackLift AI, agents work on feature branches and never push to the default branch or touch production secrets.

Treat anything the agent reads as untrusted, including issue text, web pages, and code comments, as these can carry prompt injection attempts that try to change its behavior. Log what agents did, so you can review it later, and limit how long and how much an agent can spend on a task. Finally, your existing CI checks become more valuable than ever, because they are the gate every agent change has to pass.

Roll out in stages and measure the results

Start with one team and one kind of task. Track how often agent pull requests are merged without major rework, how long review takes, and whether defects or reverts increase. Pay attention to review load in particular. If agents are producing more than people can properly read, the bottleneck has only moved, and quality will suffer.

Expand only when the numbers and the team's own judgment both support it. Write down what agents may and may not do, and update it as you learn. Teams that do this end up with a reliable way of working instead of a collection of individual habits, and one they can defend when a customer or auditor asks how their software gets built.

Frequently asked questions

Common questions on this topic.

What are AI agents in software development?

They are AI systems that work toward a goal over multiple steps, such as reading code, making edits, running tests, and opening a pull request. Unlike autocomplete, which suggests code as a developer types, an agent acts with some independence, so it needs clear limits and human review.

Will AI agents replace software engineers?

They are changing what engineers spend their time on, with more specifying, reviewing, and deciding, and less routine typing. Someone must still understand the system, judge trade-offs, and take responsibility for production. Those needs don't disappear when code gets cheaper to produce, and review may become more important.

Are coding agents safe to use on a production codebase?

They can be, with the right controls. Use sandboxes, least-privilege access, feature branches, human approval on every merge, and no access to production secrets. Also check your vendor's terms on how code is handled. The risk depends mostly on what you allow an agent to reach.

How do we measure whether coding agents are helping?

Look at outcomes across the whole delivery process, rather than lines of code or pull request counts. Useful measures include merge rate without major rework, review time, cycle time from ticket to release, and defects or reverts after release. If output rises while review suffers, the gain may not be real.

Apply this to your project

Turn your idea into an architect-reviewed delivery plan.

Use the StackLift estimate flow to convert your requirements into scope, story points, risks, timeline, and a practical delivery baseline.

Start an estimate

Sources

Sources and further reading

The standards, rules, research and official documentation this page draws on.