Multi-Agent Collaborative Development: Task Card-Driven Practices for Medium-to-Large AI Projects

Use task cards, PM orchestration, multi-Agent parallelism, and repository docs to turn AI from a chat assistant into a collaborative dev team.
The article addresses the real dilemma that AI coding remains stuck at small projects and struggles with medium-to-large commercial projects, arguing the root cause isn't AI capability but missing collaboration structure. The author proposes a local-first multi-Agent collaboration model built on four pillars: role-specific conversations (e.g., 201 Architect, 203 QA Engineer); task cards that constrain AI within clear objectives, modification scope, and acceptance criteria; PM conversations that orchestrate and maintain the single source of truth; and depositing docs, task cards, branches, and commits in the code repository rather than chat logs. Structured reports close the loop, letting any Agent tool take over anytime. The article also acknowledges the upfront standards cost but notes that for continuously iterating products, it saves substantial chaos cost.
Why Can't a Single Conversation Handle Medium-to-Large Projects?
Using AI to write code is nothing new, but there's an awkward reality: most of the impressive AI coding work we see is still limited to pure frontend or lightweight local-persistence projects. Very few people can actually use AI to push forward commercial-grade project development.
The problem isn't that AI isn't capable enough — it's the lack of a collaborative structure. A medium-to-large project involves multiple stages: requirement breakdown, architecture design, module division, interface contracts, testing and acceptance, documentation sync, and more. If you just keep one conversation open and pile requirements into it, you'll easily fall into the "super-long context quagmire" — the AI's attention drifts, and developers themselves get lost in the conversational fog, unable to say clearly where the project actually stands.
The Bilibili creator says it plainly in his sharing: small projects can be carried along on inspiration and a single conversation, but medium-to-large projects require a different approach. His proposed solution can be summarized as: task card-driven, PM unified orchestration, multiple Agents developing in parallel by role, with repository documents and structured reports as shared state in a local-first collaboration model. Simply put, it's about breaking AI from a chat assistant into a virtual development team with roles, tasks, boundaries, and delivery standards.
Core Framework: Four Pillars Supporting the Collaboration System
The core of this model consists of four things: task cards, PM orchestration, parallel multi-conversation development, and repository documents plus structured reports.

Role-Based Conversations: Giving Each Agent a Workstation
During the project kickoff phase, the creator first works with AI to assess the overall project landscape: what modules are needed, how roles should be divided, what risk points exist. Then separate conversations are opened per position — one for architecture and contracts, one for the data layer, one for testing and acceptance, plus possibly iOS development, Android development, and so on. Each conversation is a virtual project team member.
A key detail is the naming convention: label each conversation with "number + role name," such as 201 Architect, 202 Backend Engineer, 203 QA Engineer. This lets you quickly identify which conversation a task card should go to when it's circulating, preventing multi-conversation collaboration from degenerating into chaos.

When running multiple conversations in parallel, context isolation is an engineering problem that's easy to overlook. Each conversation maintains its own independent context window, and they don't automatically share memory with each other. This means that interface details discussed in the architect's conversation won't be naturally known to the backend engineer's conversation. That's exactly why key decisions need to be externalized into repository documents, so each conversation actively reads them before starting work. Another practical constraint comes from the tool side: sessions in different Agent products (like Claude Code, Cursor, Codex, etc.) are not interconnected, and even within a single tool, overly long conversations trigger truncation or compression. Naming conversations with numbers is essentially building a manual addressing system for this naturally isolated context, so the PM can assign tasks by number the way a real team is dispatched — without relying on some single "all-knowing conversation" to remember everything.
Task Cards: Locking AI Capabilities Inside Controllable Containers
The development phase doesn't rely on vague instructions like "help me keep pushing forward" — it's driven by task cards. A task card is a clear work order the PM sends to a specific Agent conversation, typically including: the objective, the allowed scope of modification, restricted contracts, acceptance criteria, branch naming rules, and the completion report format. The PM can also recommend what tier of model to use for each card — when tasks are broken down finely enough and the card content is clear enough, non-architect and non-QA positions may not need high-reasoning models; executing per card can save a lot of quota.
This design solves AI's most typical loss-of-control scenario: free improvisation when boundaries are unclear. You ask it to fix a bug, and it might casually change a bunch of things it shouldn't touch. The value of task cards is to constrain AI capabilities within a controllable task container — each card solves only one clear problem, has independent acceptance criteria and an independent branch, and requires a structured report upon completion so the PM can accept it and other conversations can carry on.
Task cards are used in tandem with a Git branching strategy. Each card corresponds to an independent branch, delivered through commits and merge requests upon completion, which brings two benefits: first, changes are traceable — if a branch has a problem, you can pinpoint the corresponding task card; second, during parallel development, different Agents' changes won't step on each other, and merge conflicts are resolved under the PM's controlled orchestration. Branch naming rules are written into task cards so that the PM and any subsequent Agent can tell from the branch name alone which module and role the card belongs to. Additionally, the "restricted contracts" item deserves special understanding: contracts refer to cross-boundary protocols such as inter-module interface agreements, data structures, event formats, etc. Task cards explicitly forbid Agents from modifying contracts without authorization, because once a contract changes, all other conversations that depend on it will collectively fail — this is the most insidious chain risk in multi-Agent collaboration.
PM Orchestration: Maintaining the Project's "Single Source of Truth"
The PM is also a dedicated conversation (number 20) and the core hub of the entire collaboration system. Its job isn't to write code but to maintain the project's truth: what's done, what's been accepted, what's in development, which contracts have changed, and which task card should be assigned next.

This decision is crucial. What multi-Agent collaboration fears most isn't an Agent writing bad code — every task card has an acceptance step as a safety net — but rather the project's true state being imperceptible. Therefore the project state is deposited throughout in repository documents: the PM's state decision records, task card acceptance records, and so on. Every new conversation doesn't need verbal explanation before starting work — it just reads the repository documents directly.
Local-First: The Repository Is the Shared State
This is what "local-first" means. Chat records get disconnected, lost, overflow their context, or may be unable to interoperate due to tool limitations; but a code repository won't. Documents, task cards, branches, commits, and test results all live in the local project, and AI conversations are only responsible for reading, executing, and reporting back. This means that as long as the local project exists, any Agent tool can take over and continue at any time, without dependence on any single conversation.
Structured reporting is the final link in the closed loop. After completing a task, an Agent can't just say "done" — it must report in a fixed format: status (complete/partially complete/blocked), current branch and commit, which files were changed, whether each acceptance criterion passed, whether it deviated from the task card, and whether any contracts changed.
Cost and Benefit: Is This Approach Worth Using?
The creator doesn't shy away from the cost of this approach: in the early stage you need to establish task card standards, maintain documentation, define report formats, and break down task boundaries — it's not a small workload.

But he believes that once project complexity rises, these costs are absolutely worth it — what you save is a large amount of downstream chaos cost. Especially when the goal is to build a continuously iterable product rather than a one-off demo, this approach is more robust and more maintainable.
He himself is using this model to develop a local-first AI Agent conversation management project tentatively named Agent Desk, which aims to solve exactly the problems of conversation management, multi-Agent state synchronization, remote notifications, authorization, and task re-assignment, covering collaboration between Agents on different platforms. In other words, this project may in the future support his own development model in turn, automating the handoff of task cards too.
From an input-output perspective, this model is better judged by "project lifespan" than "project scale." A one-off demo is discarded once done, and the standards cost can't be recouped; but as long as the product needs continuous iteration and multi-person (or multi-Agent) relay, the task card standards and repository documents accumulated early on will continuously compound — the cost of onboarding a new conversation approaches zero, and historical decisions don't need to be verbally repeated. Another hidden benefit is quality front-loading: acceptance criteria are written into the task card, so the Agent aligns on "what counts as done" before starting, reducing rework. The risk lies in the maintenance burden of the standards themselves: if task card granularity is too fine, the PM's orchestration overhead will backfire on development efficiency; if too coarse, it falls back to the old path of vague instructions. Finding the right card granularity often requires the trial-and-error of one or two real projects.
From Chat Assistant to Team Member
The value direction of AI programming has long moved past the stage of "let AI help write a piece of code or fix a bug" into an era of integrating AI into manageable, collaborative, and verifiable software engineering processes. Small projects rely on inspiration; medium-to-large projects rely on systems. The essence of this practice is to advance AI from a chat assistant to a collaborative development team member — letting any Agent tool take over the project at any time, without being held hostage by any single conversation.
According to the creator, he plans to organize this model into a general skill to share later, so that interested developers can apply it directly.
Related articles

Cursor vs Copilot vs Claude Code: How Laravel Developers Should Choose
Compare Cursor, GitHub Copilot, and Claude Code for Laravel development: an AI-first editor, a plugin for existing editors, and a terminal agent for multi-file tasks and testing — plus workflow-based recommendations.

AgentScope Java Edition: A Practical Guide to Enterprise-Level Agent Frameworks
An in-depth analysis of Alibaba's AgentScope Java enterprise agent framework: contrasting client-side AI and server-side AI, explaining Java's natural advantages in high concurrency and distributed state management, and outlining a complete learning path from core principles to multi-agent collaboration.

LangChain in Practice: Hand-Writing a Multi-Tool Agent and Execution Loop
Based on a Bilibili tutorial, this article explains how LangChain unifies model interfaces, manages context and tool calling, and how to hand-write a multi-tool Agent.