Delegate independent work with a clear contract

Understand the approach

Delegation is useful when independent work can proceed against a clear shared contract. The capstone has two implementation files: starter/normalize.cjs converts status strings, while starter/report.cjs aggregates already normalized records. Package B does not need to wait for A's implementation because CONTRACT.md defines B's input in advance. The parent retains integration and the final decision about whether the combined result meets the contract.

Read the actual starter before assigning roles. normalizeStatus currently lowercases without trimming; buildReport currently sums every task's minutes. The supplied four-record dataset therefore produces done=1 and doneMinutes=80. The intended result is total=4, done=2 and doneMinutes=55. These distinct causes justify two bounded packages with separate owned files. Assigning both workers the whole lab would introduce an unnecessary collision.

A useful brief names its input, owned file, interface, expected evidence and exclusions. Give A the normalization boundary cases and B the normalized-record requirements. Ask each to return its diff and actual checks. Then run the combined candidate and boundary tests yourself. Sequential implementation is a valid comparison; the local simulation is explicitly not agent activity. State which method actually produced the candidate instead of inferring delegation from a tidy ledger.

native-agent-guide.md supplies the actual client walkthrough: open the disposable capstone project in the app, send the exact two-owner prompt, inspect each subagent thread from its activity and keep the combined check with the main agent. CLI uses /subagents; the IDE can show a background-agent panel. A and B receive CONTRACT.md plus their exact starter paths, not an unbounded fix-everything assignment. Return actual paths, diffs and observed checks. Current releases document subagents by default; this exercise needs no invented experimental team flag.

Practice and acceptance

Parallelism is justified by independent inputs and disjoint ownership; the final result depends on both packages.

Try it step by step

1. Run the capstone starter and read its actual failed checks before assigning work.
2. Read CONTRACT.md and identify the independent normalization and report interfaces.
3. Assign A only starter/normalize.cjs and B only starter/report.cjs; reserve integration for the parent.
4. Implement the packages sequentially or use actual Codex subagents in the disposable copy, preserving the frozen contract.
5. Run the combined starter after edits, inspect both files and reconcile actual output with the target; identify unrun client behavior.

A useful starting example

Illustration · adapt before use.

In a disposable copy of labs/delegation-capstone, read CONTRACT.md and work-packages.json. Establish the broken baseline first. Delegate A to own starter/normalize.cjs and B to own starter/report.cjs; neither may edit the other's file, runner, fixtures or tests. Each returns its changed file, observed boundary checks and remaining gaps. Keep integration with the parent. After both return, inspect the combined diff and run node labs/delegation-capstone/run.cjs starter and node --test labs/delegation-capstone/candidate.test.cjs from the extraction root. Report actual agent activity and actual results.

Check your result

• A and B own different implementation files against the same frozen interface.
• The edited candidate returns total=4, done=2, doneMinutes=55 and preserves source inputs.
• The report identifies actual sequential, simulated or Codex-delegated work without inventing agent activity.

Common mistakes

• Splitting a tiny sequential task into many agents without a time or quality benefit.
• Assuming separate agent threads automatically provide separate copies of project files.