# Move a Claude Code task without sharing a login

An unfinished coding task needs more than a prompt before another teammate can pick it up. The next person needs the actual code state, the expected behavior, permission to work on the repository, and a reviewer who can judge the result.

Here is a proposed handoff pattern for a small startup. The example and names below are illustrative; they are not a report of a completed implementation or measured productivity gain.

## Separate the brief, execution, and acceptance

Suppose Maya starts a CSV export fix with Claude Code. She understands the bug but cannot finish the task today. Leo can continue using his own authorized AI tools. Priya owns review.

Maya prepares the brief and preserves the relevant work. Leo inspects that state, implements the bounded change, and collects evidence. Priya evaluates the exact revision submitted for acceptance.

The handoff does not transfer Maya's AI subscription, authenticated session, or repository identity. Leo needs his own repository permissions and his own approved provider access. If either is missing, the task waits for access to be granted through the team's normal process.

The useful unit of transfer is a versioned work package: source state, requirements, observations, and next action.

## A reusable handoff record

Copy this YAML into the task and replace the angle-bracket fields before assigning it. The identity labels describe separate accounts; they are not credentials.

```yaml
task: csv-export-quoted-fields
goal: "delegate AI task without sharing account access"
scenario: illustrative

people:
  preparer: Maya
  runner: Leo
  acceptance_reviewer: Priya

identities:
  preparer_tools: "Maya's authorized Claude Code account"
  runner_tools: "Leo's independently authorized AI account"
  repository_access: "Each person uses their own repository identity"
  shared_credentials: none

source:
  repository: "<authorized repository URL>"
  base_commit: "<full commit SHA>"
  work_branch: "<branch containing preserved work>"
  handoff_commit: "<full commit SHA>"
  uncommitted_work: "<none, or explicit files and transfer method>"

request:
  outcome: "CSV exports preserve commas, quotes, and line breaks in cells"
  allowed_changes: "CSV serializer and focused regression tests"
  excluded_changes: "Authentication, dependencies, deployment"
  setup: "<repository-specific install and setup instructions>"
  reproduce: "<exact command and synthetic input fixture>"
  next_action: "Reproduce the reported failure before changing code"

evidence:
  baseline_result: "not yet verified by runner"
  verification_command: "<actual repository test command>"
  submitted_commit: "<fill after implementation>"
  test_output: "<attach actual output; state failures explicitly>"
  remaining_limits: "<list untested cases>"

permissions:
  runner_may: [inspect_code, edit_allowed_files, run_local_tests]
  runner_may_not: [deploy, change_access, accept_own_delivery]
  stop_if: "Missing access, unclear expected output, or scope expansion"

acceptance:
  checks:
    - "A comma stays inside its original cell"
    - "An embedded quote is escaped correctly"
    - "A line break stays inside its original cell"
    - "Unrelated export behavior remains covered"
  decision: "pending reviewer assessment"
```

## Verify the starting point before continuing

Leo first checks that the recorded commit is available and that the working tree matches the handoff. A branch name alone is insufficient because its contents can change. Uncommitted work must be accounted for separately; a clean checkout cannot recover edits that were never preserved.

Next, he runs the documented reproduction with synthetic data. If the failure differs from Maya's description, he records the discrepancy before asking the agent to patch anything. This prevents an old explanation from becoming an unquestioned requirement.

The new agent session receives the scoped brief and relevant files. A complete chat transcript is optional context, not proof of correctness. Remove credentials and unrelated private data from anything being handed over.

## Make the review small enough to perform

For this example, Priya should receive the submitted commit, a short explanation of the serializer change, and actual test output. She checks both the new cases and the intended compatibility boundary. If the implementation changes again, the review must identify which revision the evidence covers.

Keep the outcomes separate: implementation delivered, checks executed, and change accepted. A confident agent response establishes none of these by itself.

[Wagglet's discussion of AI task handoffs](https://wagglet.com/blog/close-team-skill-gaps-with-ai-task-handoffs) provides context for separating expert preparation, a runner's contribution, and qualified acceptance. The YAML here is a standalone team template, not a Wagglet API schema or a claim that the product enforces every field.

## Where this pattern stops helping

A written brief cannot supply missing access, undocumented local state, or specialist judgment. Different tools may also approach the same task differently. The receiving person must reproduce the starting conditions rather than assume the original session resumes elsewhere.

Try the template on one reversible change. Record preparation time, clarification requests, review effort, and whether the reviewer accepted the result. Those observations can show whether the handoff helped your team; this example supplies no measured savings.