AI-assisted development: what changed on my team

AI-assisted development: what changed on my team

AI-assisted development at Aldena runs on agent teams that work from written tickets, with an allow, ask or deny policy on every tool and a person reading each pull request.

Aaron Delasy
Aaron Delasyfounderupdated

AI-assisted development is a workflow change, not a typing aid

AI-assisted development on my team means Aldena's own agent teams take written tickets and do the production work, while a person reads every pull request before it merges. A developer typing while a model finishes the line is a much smaller thing. My setup looks more like staffing, and I write every ticket so an agent can start it without a meeting.

The work happens in isolated projects. Each conversation in a project gets its own sandbox with one checkout of the code, and every agent in that conversation shares it. Two projects never share a filesystem, so a build in one cannot reach the checkout in another. Every change lands as a pull request, and a person approves it before it goes anywhere.

I have shipped Aldena's own backlog this way, and the code generation turned out to be the least interesting part. Whether a run worked came down to the ticket, the role boundaries, the guardrails and the review gate.

I am not the only one who ended up here. Levi9's engineers published a practice report in June 2026. It covers about eighteen months of running agents inside a real delivery team.

Their agents have their own accounts and sit in the standup channel as teammates rather than tools. Point by point, they reached almost the same conclusions I did, which I found reassuring and a little humbling.

Tickets replaced prompts as the unit of work

Tickets replaced chat prompts as my unit of work, and a ticket an agent picks up alone needs four things a prompt can skip. A chat prompt gets away with being vague, because I am sitting right there to answer a follow-up every thirty seconds. A ticket has nobody sitting there.

So every ticket I hand to an agent carries the goal, the constraints, the surfaces it touches, and a clear definition of done. If a contractor could not finish the ticket without a meeting, neither can an agent. That is the test I use.

A ticket carries the goal, the constraints, the surfaces it touches and a clear definition of done, then flows one conversation per ticket, one checkout per conversation in its own sandbox, one branch per checkout and one pull request per branch

That sounds like pure overhead until you notice the side effect. Writing tickets to that standard made the backlog better for the humans too. Vague tickets used to sit in the backlog for weeks, because everyone silently agreed not to pick them up.

An agent exposes the vagueness at once. It either stops to ask a clarifying question, or it builds the wrong thing quickly. Either way, the hole in the spec becomes impossible to ignore.

Each ticket also gets its own conversation, and each conversation gets its own sandbox with its own clone of the repository. Two tickets in one checkout meant two agents editing the same files at once, and the collisions never stopped until I split them.

The rule I run now is one conversation per ticket, one checkout per conversation, one branch per checkout and one pull request per branch.

Each agent has one job, and the boundaries do the work

A team of agents in Aldena is a set of separate agents, each hired for one job, and each job comes with something that agent refuses to do.

The requirements agent asks its clarifying questions before it writes the spec. The delivery agent never writes code itself. It delegates the build to the build agents, drives the review loop and opens the pull request.

The code review agent has the refusal I lean on hardest. It reports what it finds in the diff and never edits what it reviews. The bug fix agent reproduces the failure first, then fixes the root cause and pins it with a regression test.

Four agents with one job and one refusal each: requirements and delivery never write code, code review never edits the code it reviews, bug fix never fixes before the failure is reproduced

The refusals matter more than the abilities. A reviewer that can edit code quietly stops being a reviewer. It fixes what it finds, and then nobody reads the findings. The second opinion you thought you had is gone.

A build agent that could merge would stop waiting for review, and no agent in Aldena merges its own work. Every boundary I keep guards a check like that one. Remove one and two roles collapse into one, and a check I was counting on disappears with it.

Setting a team like this up step by step is its own job, and I wrote it up as a separate walkthrough.

Guardrails took longer to get right than the agents

Aldena gives every tool an agent can call one of three policies, allow, ask or deny, and deciding which tool gets which took me longer than prompting the agents did. I put reading files, searching and running the test suite on allow. Writes go on ask, and so do shell commands that touch anything shared and anything inside a connected account. On ask, the run pauses and shows me the exact call before it happens.

A tool on deny is not available to the agent at all, which is what I want for anything a project should never touch.

The delivery agent branches, commits, pushes and opens a pull request against the default branch, then stops. No agent merges its own work, so that pull request is my review gate. The backlog planning agent holds back too. It presents the whole proposed backlog and waits for an explicit go-ahead before it creates a single ticket in the tracker.

Levi9's guardrail list has the same items as mine: no destructive actions, no production deployment without a human, permissions scoped per role. Levi9 and I got there separately, and that makes me trust the list more than either of us alone.

The delivery agent paused mid-run on the exact dispatch it wants approved, handing ticket ALD-42 to the backend build agent

Review stays human, and so does the accountability

Every diff an agent produces gets a careful read from a person before it merges, and that policy is easy to state and hard to keep.

Agents produce plausible work quickly, and plausible work invites skimming. A review gate you skim stops filtering anything.

For a while my end-to-end suite kept getting dismissed as flaky, and the easy response was to agree, retry and move on.

When I finally investigated, I found two real defects. One was a race in test teardown, and the other was waits sized wrong for the environment they ran in. The agents' code was fine.

The bug was the shared assumption that an intermittent failure is harmless. That is why the gate has to be real. A person who owns the outcome has to be there to make calls like that one.

Accountability works the same way. When an agent ships a bug, the responsible party is the person who approved the pull request. I keep that rule because it is the only arrangement that keeps review honest. The moment blame can be routed to a model, nobody reads a diff carefully again.

The review gate: an agent produces a diff and opens a pull request, a person reads every diff and approves before it merges, and the approver is responsible when an agent ships a bug

What failed while I built this way

Building Aldena this way produced four failures worth writing down, and a practice report that leaves its failures out reads like an ad.

  • Agents declare done too early. I got green builds with half the acceptance criteria met and a summary full of confidence. I write the acceptance criteria into the ticket and add a reviewer whose only job is the diff.
  • Parallel projects fought over shared state. Two projects had separate checkouts but pointed at one development datastore, and the failures looked random for longer than I want to admit. They stopped once every checkout got its own key namespace. Separate checkouts are not enough on their own when agents run in parallel, and anything two agents both reach has to be split as well.
  • Confident diagnosis without evidence. An agent blamed a CI crash on memory pressure, in a paragraph that read beautifully. Measuring showed memory was fine and the cause was somewhere else. Agents learn this habit from people, because a plausible story feels like a finding. I now ask for the measurement before the story.
  • Overnight autonomy has a size limit. Small, well-scoped tickets can run unattended from start to finish. Anything with real ambiguity needs a human answering questions during the run, not just signing off at the end. Levi9 reports the same limit. I have stopped trying to work around it, and I aim for autonomy with limits rather than a team that runs with nobody watching.

What it costs, and where the spend actually goes

A dollars-per-feature number for aldena's own backlog would be fake, so I am not going to give you one. The structure of the bill is more useful anyway.

Model choice per agent is the biggest single factor in what an agent costs. My code review agent runs on Claude Opus 5.5 at high reasoning effort, because a missed defect costs more than the tokens. The project setup agent runs on something cheap and fast, and I don't lose sleep over it.

In Aldena I pick the model per agent, and the per-model list rates are on the model pricing page, so I price a swap before I make it.

aldena settings for the code review agent with its own LLM model set to Claude Opus 5.5 and reasoning effort set to high

Most of the token spend goes to reading, not writing. That surprised me. Investigation, review passes, and test output cost far more than producing the diff itself. Budgeting by lines of code generated misses most of the bill.

Compute never shows up on Aldena's bill. Each conversation's sandbox runs on the sandbox provider my team connected, that provider bills the machine time to my team's account, and Aldena adds nothing on top. The plan prices are on the pricing page.

Levi9 warns that usage-based billing climbs fast without measurement discipline, and I agree. The team plan is the only thing Aldena bills, so the platform side of my bill stays flat. Token cost I track per shipped ticket rather than per month, because ticket types vary too much for a monthly average to mean anything.

How this works in aldena

Aldena is both the product I build and the place I build it, so I hit its rough edges before any customer does.

A project holds its own credentials, integrations and memory, and each conversation in it, one per ticket in my setup, gets its own sandbox. Nothing crosses between projects, and that is the property I would give up last.

Into the project I hire agents from a roster of eleven prebuilt agents, among them requirements, architecture, delivery, the build agents, code review and bug fix, and I pick each one's runtime and model.

aldena Hire an agent catalog listing prebuilt agents including Requirements, Architecture, Delivery, Backend Build, Frontend Build, Code Review and Bug Fix

I arrange them in a hierarchy on the org chart, a live canvas where work travels down delegation links and results come back up. An agent hands work only to the agents it delegates to and replies to whoever delegated to it.

An agent and every agent it delegates to share one conversation's sandbox and its one checkout, so sandbox isolation can't stop two of them colliding. The delivery agent works strictly one delegate at a time instead, so two agents never edit that checkout at once. Parallel work runs as separate conversations, each in its own sandbox.

Agents keep what they learn in memory. Every agent in the project reads the shared project memory, each agent also keeps private notes only it reads, and both outlive the chat that wrote them.

Asking a person a question is itself a tool in Aldena's human-in-the-loop setup, and it is the one tool that can never be switched off. An agent that hits an ambiguity stops and asks, and its pull requests sit open until a person merges them.

Integrations such as GitHub, Linear and Slack connect per project, so code arrives as pull requests and the backlog lands in your tracker.

aldena project canvas with the delivery agent linked to three agents it delegates to, and work moving along the lit link to the frontend build agent while it works on a task

Still comparing individual coding agents before running a team of them? I keep a separate guide to the coding agents themselves, and I would start there. A team only pays off once one agent stops being enough.

Questions I keep getting

Is this fully autonomous software development?

No, and I have stopped chasing that. AI-assisted means agents do the production work inside a structure of tickets, roles, and gates. The autonomy is sized to the risk of each tool call.

Full autonomy holds up for small scoped tickets and fails beyond that.

Who is responsible when an agent ships a bug?

The person who approved the pull request. I say that rule out loud on my team.

Is AI-assisted development replacing developers?

It is replacing the typing. Specification, architecture, review, and the judgment about what should exist at all did not go away. They moved up.

My days now hold far more writing and reading than keystroke-level coding. A developer who can specify and review well ships more in this setup than one who types fast.

Start with one ticket

AI-assisted development starts best with one ticket, a well-scoped bug or one small feature, written so a stranger can finish it with no follow-up questions. I would skip the grand rollout. Give the agent ask on everything that writes.

Then read the pull request as carefully as if a person had opened it. Keep a note of everything you had to correct in review. That list is your next round of ticket templates and guardrails.

Promote a tool from ask to allow only after a long run of approvals where nothing went wrong. The loop of ticket, run, review and adjust is the whole practice, and I still run it on every ticket.

ready when you are

spin up your first project.

one project per client, product, or piece of work, staffed with intake, requirements, build and code review agents.