Almost no software house tells a client that an agent writes their code alone. Not because it technically can't, in narrow cases it already does, but because that sentence is a liability nobody signs up to carry. So teams reach for a softer word instead: assisted. It sounds like a hedge, a temporary stop on the way to something more autonomous once the tools mature. For work that has a paying client on the other end, it usually isn't a stop at all. It's where the work is supposed to live.
AI software development spans a whole spectrum of setups, from an agent that finishes a pull request unattended to one that suggests a single line and waits for a keystroke. The words used to describe that spectrum, assisted, augmented, autonomous, get used almost interchangeably in vendor copy and almost never get defined precisely enough for a team to build a review policy on top of them.
Assisted, augmented, autonomous: what do the words actually mean?
AI-assisted software development is work where a person stays the unit of authorship: an agent proposes code, a test, or a refactor, and a developer reviews and accepts each change before it merges. Augmented development widens the loop, the agent runs several steps unattended (planning, editing, running its own tests) but a person still reviews the outcome before it ships, even without checking every intermediate step. Autonomous development is an agent completing a task end to end, including the decision that the result is good enough to release, with no required human checkpoint anywhere in the chain. These are not three rungs on one ladder toward full autonomy. They are three different answers to the same question, who decides what counts as done, and a team can run all three at once, on different repositories, whether or not anyone in the company has written the distinction down yet.
The confusion starts when "autonomous" gets used as a synonym for "better," as if every team is racing toward the same finish line and assisted setups are just behind. Most software houses that build for clients aren't racing toward that finish line at all, because the thing that decides which mode fits isn't how advanced the agent is. It's who is contractually on the hook when the result is wrong.
Why isn't the middle a waiting room?
An internal tool, a prototype, a script nobody else depends on, these are places where letting an agent run further unattended is close to free: the cost of a bad outcome is a redo, absorbed by the same team that shipped it. Client work is a different shape of risk. The team that ships is rarely the team that absorbs the cost of a wrong shipment, the client does, in production, in front of their own users or regulators. That asymmetry doesn't shrink as agents get better at writing correct code; it's a property of the relationship, not of the tool.
The Stack Overflow Developer Survey 2025 is one data point on why "better agent" doesn't automatically resolve this: 69% of developers using coding agents report higher individual productivity, but only 17% report better team collaboration. An agent that writes correct code faster doesn't automatically produce something a team, or a client, trusts without checking. Assisted setups exist precisely to close that second gap, not the first one, which is why they don't disappear once the agent gets smarter.
Why does the signature stay human?
Anthropic made auto mode the default in Claude Code in August 2026, removing step-by-step confirmation prompts for most actions. What that change actually altered wasn't whether a human could still be required to sign off, it was where in the workflow that requirement sits: fewer manual approvals for routine steps, an automatic fallback to manual review when the tool's own classifier hits a run of blocked or risky actions. Even the vendor building the most autonomous version of this tool kept a human checkpoint in the design, because a technical decision (can the agent do this safely) and a contractual one (who is accountable if it's wrong) aren't the same question, and only one of them can be answered by better engineering.
For a software house, the contractual answer rarely changes: the person or company delivering the work is the one who signs the acceptance, the invoice, and the support commitment that follows it. An agent can be extremely reliable and still not be a party the contract can hold liable. That's not a temporary gap waiting on model improvement. It's the reason the signature stays with a person even in the most automated setup a team runs.
What does a good assisted setup look like?
| Mode | Who executes | Who decides it's done | Where it fits | |---|---|---|---| | Autonomous | Agent, unattended | Agent, no required checkpoint | Internal tools, low blast radius | | Augmented | Agent, multiple steps | Person, reviews the outcome | Trusted repos, known client, established patterns | | Assisted | Agent, per change | Person, reviews each change | New client, regulated domain, contractual acceptance |
The table isn't a maturity curve to climb. It's a map a team can use per repository, per client, sometimes per change, to decide up front how much unattended range an agent gets, instead of discovering the answer after something ships wrong.
Where to draw your own line
Pick the line by contract, not by comfort with the tool. Three questions settle most of it: who signs the acceptance for this repository, what does the contract say happens if a shipped change is wrong, and can the agent's own log of what it did survive a client asking for it six months later. Where the answers are clear and the stakes are low, augmented or autonomous ranges are a legitimate choice. Where a client's name is on the acceptance, assisted with a documented review step isn't the cautious option, it's the one that matches what was actually signed. Write the line down per repository before the next agent session starts, not after the first disputed change. That's the same split the layer above the agent is built around: the system prepares, the person signs, whatever mode decided how much the agent got to do on its own first.