DEV Community

Cover image for AI Agents in Software Development
Tomasz Klapsia
Tomasz Klapsia

Posted on Originally published at icetique.dev

AI Agents in Software Development

One Board, Two Jobs

Most multi-agent demos share one failure mode.

Two agents talk to each other. They sound productive. They agree on a plan.

Nobody asked whether both agents were allowed to invent product facts.

In a real backlog, that distinction matters. A card is not only text. It is a promise about behavior, scope, and priority. If the wrong agent fills in the gaps, you do not get faster delivery. You get confident wrong cards that people spend a week unwinding.

On a client marketplace program where I was technical lead, we ran two agents with different front doors and one shared backlog on Trello. They had different jobs:

  • Clara did business analysis and intake over Discord DM. She turned a vague idea into a structured card through a conversation.
  • Cody did product and implementation analysis from engineering triggers—pull requests, card questions, anything that needed the repo, staging, linked docs, and other recorded evidence. He did not "live" on the board; he wrote sourced answers onto cards when product truth was required.

They shared the backlog as the contract artifact—not the same runtime or inbox.

They did not share the right to assert product reality.

That boundary was the architecture. Everything else was plumbing.

Why Not One Agent?

The obvious design was a single agent that does intake, looks up how things work, and writes the card.

It failed for a boring reason: context and temperament mix badly in one session.

Intake needs patience. One question at a time. Short replies. Willingness to leave fields empty until the human answers.

Product analysis needs skepticism. Check the card against what is already built and what is in flight. Check linked sources. Cite where the answer came from.

When we merged those into one agent with one prompt, the pilot was mediocre at both. Worse, it smoothed over gaps because completion felt like success.

Splitting the roles was not anthropomorphism for its own sake. It was separation of duties.

Clara was tuned for a complete-enough specification.

Cody was tuned for ground truth.

Humans still owned prioritization and the final word. The agents competed for clarity, not for authority.

Where the Work Happened

Clara's front door was Discord DM.

That was deliberate. Intake is interrupt-driven. A founder or PM should not need to open a dashboard to answer "who is affected?" or "what does done look like?"

We constrained the conversation on purpose:

  • One question per message. No questionnaire walls.
  • Structured output at the end, not free-form prose stuffed into the card description.
  • Explicit unknowns. If the human did not know, the card said unknown. Clara did not guess.

Cody's front door was different. He was triggered when someone needed verified facts: a change under review, a question on a card, anything where guessing would be expensive. He ran as a service on a server, with durable state, not as a chat companion on someone's laptop. I described Cody's deeper review workflow separately in Agent or Workflow? The Loop Has to Earn Its Keep. Here the focus is role split, not runtime.

Both agents wrote to the same Trello board, but they wrote different kinds of truth.

The Evidence Boundary

This was the rule Clara was not allowed to break:

Clara may not state how the product behaves today unless Cody or a human has said so with evidence.

She could capture intent:

  • "We want vendors to see X."
  • "This journey is broken on mobile."
  • "Acceptance criteria: …"

She could not quietly upgrade that to:

  • "The back end already returns Y."
  • "That screen is hidden behind a switch we turned on last quarter."
  • "We shipped this in Q2."

Those sentences belonged to Cody, or to a human who accepted the liability.

In practice, the boundary showed up in three places:

Card fields

Intent lived in the description and acceptance criteria.

Product claims lived in a separate section — Product reality (sourced) — with a line for source: Cody's run reference, link to the change under review, doc link, or human name.

If the section was empty, the team treated the card as unspecified, not as "probably fine."

Handoffs between agents

When Clara needed product truth, she did not invent an answer. She opened a question for Cody on the card (or triggered a Cody job). The card stayed in a To Specify column until sourced fields were filled or someone explicitly waived them.

That column was not shame. It was a governance state. "Ready to build" meant the claims were sourced, not that the prose sounded confident.

What Cody was allowed to refuse

Cody's job was not to be helpful in the chat sense. His job was to be accurate.

If the question was ambiguous, he returned insufficient evidence, not a plausible story.

If the evidence contradicted the card, he flagged the contradiction on the card. He did not negotiate in prose.

Helpful agents lie politely. Analyst agents fail loudly.

What Each Agent Did

Clara: intake as business analysis

Clara's output was a Trello card a human could sanity-check in two minutes.

She pushed on:

  • User and journey (who, where in the product)
  • Problem vs request (symptom vs proposed solution)
  • Acceptance criteria (testable, not slogans)
  • Constraints (compliance, languages or markets, platforms, deadlines)
  • Dependencies (other cards, data or policy changes, design)

She did not size the work, pick how to build it, or promise dates.

When the human went quiet, she stopped. A half-finished card with honest gaps beat a finished card with invented detail.

Cody: product reality from evidence

Cody answered questions that required looking at the system, not remembering it:

  • Does this capability exist today? Who can use it?
  • What happens on staging?
  • Is there an automated check that already covers this?
  • Is someone else already changing the same area?

When a code change was in review, Cody went much deeper: structured checks, recorded proof, a draft review for a human to publish. That depth was why he was a controlled pipeline, not a chatbot with file access.

On the board, a lighter mode was enough: short answers with pointers — links, screenshots, doc references — so a human could verify without spelunking.

Failure Modes We Hit

Multi-agent systems fail in repeatable ways. These are the ones that actually happened on that program, not theoretical risks.

The confident card

Clara once produced a crisp acceptance section that implied an admin feature already behaved a certain way. Cody had never run on that card. The team started estimating against fiction.

Fix: hard rule — no Product reality section without a source line. Cards without it could not leave To Specify.

Cody as bottleneck

When every intake question triggered a full Cody run, latency killed the conversation. Humans stopped answering Clara because "it will ask the robot anyway."

Fix: batch product questions. Clara collected unknowns during the DM thread, then one Cody job answered the set. Intake stayed synchronous; evidence stayed asynchronous.

Two truths on one card

Clara edited the description while Cody appended a sourced block. Someone read only the description in a stand-up.

Fix: visual separation in the template, and a team norm: read the sourced block before estimating.

Agent flattery

Both models wanted to close the loop. Clara would suggest acceptance criteria that sounded thorough but were untestable. Cody would soften contradictions to avoid embarrassing the card author.

Fix: prompts that rewarded empty fields and hard failures. Clara's prompt literally preferred "Unknown" over inference. Cody's review workflow already treated "insufficient evidence" as a valid outcome; the same discipline applied on the board.

The human bypass

The fastest workaround was always: "I'll just explain it in the hallway."

That recreated the bottleneck we were trying to remove.

Fix: Clara was optional for tiny work, but not optional for cross-team or compliance-touching work. The board stayed the contract.

How It Fit Delivery

This was not "AI project management" in the abstract. It was intake and evidence on a real program.

Ship decisions still needed humans. Cody drafted; a human published. Clara did not mark work done or ship changes without a person.

The board lined up with how the team already worked:

  • The engineering backlog stayed the system of record.
  • Cards linked to in-flight changes and back.
  • Reviews referenced Trello; Cody used the card when judging what a change claimed.

What made it stick was boring team hygiene: named columns, source lines, and handoff rules the whole team could follow without re-litigating every card.

Context engineering — what the agents are allowed to know and when — is the same problem I wrote about in AI Can Write the Code. Who Gives It the Context?. Two agents on one board was context partitioning with a human-visible audit trail.

A Checklist If You Try This

You do not need my exact stack. You need the same separations.

  1. Name the roles. Who is allowed to capture intent? Who is allowed to assert current behavior?
  2. One shared artifact. If agents do not share a board, ticket, or doc, coordination reverts to chat logs.
  3. Source lines. Every product claim needs provenance. No provenance, no estimate.
  4. A waiting state. "Unspecified" is a column, not a failure.
  5. Async evidence. Do not block human conversation on a slow fact-finding job.
  6. Human publish gates. Agents propose; people commit to dates and releases.

If you skip (1) and (3), you built a pair of chatbots, not a divided labor system.

When This Is Worth Building

This paid off for us when:

  • Intake was frequent and fuzzy (founders, PMs, compliance, many markets).
  • The product was large enough that nobody held full product truth in their head.
  • We were already paying the cost of wrong cards in rework and review churn.

It would not pay off when:

  • The team is two people in one room.
  • Backlog items are uniformly small and already well understood.
  • Leadership wants "AI magic" without tolerating empty fields and hard contradictions.

The interesting part is not that two models can cooperate.

The interesting part is that you draw a line between belief and evidence, and make the backlog enforce it.

Top comments (0)