The Re-Soloing

AI-assisted development can make it practical for one engineer to attempt a broader slice of an implementation. A person can ask an agent to explore unfamiliar code, draft a change, generate test cases and explain alternatives while retaining responsibility for the result.

That possibility is useful without implying that every individual now replaces a team. Project outcomes also depend on requirements, domain knowledge, access, review and operations. The question is where independent work helps and where coordination remains essential.

Give independent work a clear boundary

A well-defined task is a good candidate for a focused handoff. Identify the intended behavior, relevant constraints, authorized actions and acceptance criteria. Provide the context the agent needs to work within the existing system.

The boundary might be a bug with a reproducible example, an interface implementation under an agreed contract or a migration with a verified rollback plan. It should be possible to inspect the result without reconstructing an entire project’s assumptions.

Broader implementation reach increases the value of scope control. An agent that can change several layers of a system should not infer permission to redesign all of them. Record discoveries that require a decision and resolve them before expanding the work.

Coordination changes form

Working alone on a bounded task can reduce handoffs during implementation. It does not eliminate coordination over shared interfaces, data ownership, release timing or changes that affect other teams.

A useful workflow moves some coordination into explicit artifacts: a specification, an interface contract, a decision record and a reviewable patch. These make assumptions available before coding and leave evidence after the session ends.

Asynchronous collaboration works best when a question has enough context and a clear owner. When participants disagree about the problem itself, a focused conversation may resolve the uncertainty more effectively than repeated written exchanges.

Keep review independent of generation

An agent can suggest tests and review a patch. Those contributions still need evaluation against the actual requirement. Generated code and generated tests can share the same mistaken assumption.

Use established checks, known examples and relevant domain review. For consequential changes, follow the project’s independent review process. Verify that tests ran against the final artifact and that the review covered what will actually be deployed.

An individual’s ability to generate more code can create a larger review burden. Account for that work when assessing speed. A patch is not complete merely because the agent has finished writing it.

Preserve shared understanding

A team needs enough knowledge to maintain a result after its original author moves to another task. Capture important decisions, operational expectations and unusual constraints in the approved project documentation.

This is especially important when an agent helped implement unfamiliar components. The responsible engineer should be able to explain how the change works, where it can fail and how its behavior was checked.

Mentoring and collaboration remain useful even when a task can be implemented independently. Reviewing a design together can expose assumptions that neither the developer nor the agent recognized. Shared understanding also reduces dependence on any one person or tool.

Measure the whole task

If evaluating an AI-assisted workflow, compare similar work and record the limits of the comparison. Include implementation, review, correction and operational follow-through rather than timing only the first draft.

Useful observations include whether acceptance criteria were met, how much rework was needed, whether defects escaped and how easily another engineer could maintain the result. Do not infer a fixed productivity multiplier from an isolated successful task.

Choose the right unit of autonomy

The practical opportunity is to make bounded work easier to complete without unnecessary interruption. Use an agent to extend implementation capacity while keeping decisions, authority and verification explicit.

One person may complete more of a task independently. A team still decides which problems matter, reconciles competing constraints and owns the system over time. Design the workflow to support both.