In this article

Keep the purpose in one continuing conversation

A request such as adding spoken notes spans several responsibilities. The interface needs recording controls and clear feedback. The backend needs to retain the audio and transcription. The accepted note must still pass through the examination’s recording rules. Splitting those responsibilities can help, provided everyone is building the same workflow.

PROFAS uses one continuing coordinator conversation with bounded specialist assignments. The coordinator retains the user’s purpose, resolves shared decisions, integrates the work and owns the result. Usually two specialists work alongside it. The user can discuss the product in one place while those assignments happen internally.

Reusable briefs make the responsibilities explicit: backend operations, user flows and controllers, research evidence, and focused verification. A brief supplies an approach and relevant constraints. The actual assignment still needs its own source context, owned files, expected result and authority. The specialist should know what it can complete and where a decision returns to the coordinator.

Agree what the implementations must share

The useful unit of parallel work begins with a small shared contract. For a recorded observation, that may include the source identity, payload shape, expected revision, accepted receipt and errors the interface must handle. If those meanings remain undecided, separate implementations can each appear reasonable while disagreeing at their boundary.

The task brief therefore identifies the owning application and approved source base, points to the relevant design and actual callers, and assigns file ownership. It also states the acceptance condition. “A note remains editable while saving, and later edits survive the earlier response” gives both sides something more concrete than a request to build a note component.

A discovered contract change returns to the coordinator. That is a useful interruption: it prevents two agents from independently resolving the same ambiguity in incompatible ways. Routine choices within the agreed responsibility can proceed without another user decision. The distinction keeps the conversation concerned with product meaning while implementation continues.

ENGINEERING NOTE

A bounded three-agent assignment

  1. Coordinator agrees the contract

    User outcome, owning app, shared data shape, file ownership and acceptance.

  2. Two specialists implement owned packets

    Separate worktrees; direct source reading; shared questions returned to the coordinator.

  3. Coordinator integrates the result

    Reconcile interfaces and callers, reuse applicable evidence and check the combined change.

  4. Deliver the authorised outcome

    Retain source and limits; publish only to the application and destination named in the task.

This describes the working coordination pattern. Task scope and available authority determine what each assignment can actually execute.

Separate edits while preserving shared context

Each independently editing agent uses its own task branch and worktree. That keeps its files and index separate while sharing repository objects and history. A known starting commit makes the eventual comparison meaningful: the coordinator can identify what a packet changed and whether unrelated ancestry came with it.

The worktree does not carry an application’s ignored environment or installed dependencies automatically. Nor does it grant backend access. A task that writes website prose has no reason to acquire examination credentials, and a business task does not gain examination authority because both live in the same repository. Editing isolation and operational permission are different responsibilities.

The repository provides navigation documents and source examples, but agents still read the actual implementation and relevant design. For Convex work that means following a client reference into its registered function, access checks and shared helpers. A convenient map locates that chain; its omissions cannot establish that a dependency or constraint does not exist.

Return a packet that supports integration

A useful handoff is short enough to inspect and precise enough to act on. It identifies the source branch and commit, delivered behaviour, changed paths, evidence, unresolved points and integration needs. Source review, a behavioural test and a browser observation answer different questions, so the packet names what actually happened.

The coordinator compares the delivered files, imports and configuration with the checked packet. A different commit identifier after integration does not, by itself, invalidate evidence for unchanged code. Conversely, editing a shared permission helper may affect callers beyond the component that motivated the task. The relevant dependency change determines what needs another check.

This matters when time and agent usage are finite. Repeating a successful build because a caption changed spends resources without addressing a new uncertainty. Accepting a backend rule from a screenshot leaves a material gap. Focused checks follow the changed behaviour and its risks, with one owner responsible for the final combined result.

Choose parallel work that can converge

Some divisions are natural. An agreed backend command can be implemented alongside its interface, or independent article packets can follow one content contract. Other changes revolve around a shared invariant that has not yet been resolved. In those cases, a short coordinated investigation can be more useful than increasing the number of simultaneous edits.

The agent team also needs a stopping point. An assignment to improve a controller does not authorise a redesign of the workflow. A source review does not imply permission to deploy. Delivering the requested behaviour includes respecting what the user has already decided and returning a concrete conflict when the implementation cannot preserve it.

PROFAS is a practical case study in that method. It does not isolate the contribution of a particular model or agent count, and it supplies no universal delivery multiplier. What it does provide is a repeatable working discipline: explicit purpose, a small contract, owned changes, usable evidence and deliberate integration. That discipline gives parallel implementation a route to a coherent product.