[FEATURE] Pair Programming Mode for AI Coding Agents

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)

Problem Statement

Current coding agents generally follow this interaction model:

1. The developer provides a task.
2. The agent autonomously plans and executes the work.
3. The developer can wait for the agent to finish or interrupt the process.
4. The developer reviews the result and requests changes.

This works well for clearly defined tasks, but becomes inefficient for complex implementation and architectural work.

During execution, developers often discover information that changes the desired approach:

• An architectural constraint becomes apparent.
• A better implementation strategy is identified.
• A business requirement needs clarification.
• The agent starts moving in an undesirable direction.
• A planned refactor introduces an unwanted dependency.
• The developer realizes that a previous instruction should be interpreted differently.

Currently, the developer often has to wait until the agent reaches a stopping point, manually interrupt it, or provide additional instructions without knowing exactly where the agent is in its current plan.

This creates a gap between autonomous execution and human supervision.

Proposed Solution

Introduce an execution mode where the agent remains autonomous but continuously exposes meaningful progress, intent and significant decisions and remains interruptible.

Conceptually:

Developer
│
instructions / feedback
│
▼
Interactive Agent:

Plan → Explain → Execute → Evaluate → Continue 
          ▲                 │
          └────── Feedback ─┘ 

The developer should be able to interact with the agent at any point:

"Don't implement this through the provider. Move the logic into a reusable hook instead."

The agent should then:

1. Stop or cancel the relevant pending operations.
2. Preserve the current context and work already performed.
3. Incorporate the new instruction.
4. Re-evaluate the implementation plan.
5. Explain relevant consequences or conflicts.
6. Continue from the current state.

No task restart should be necessary.

Alternative Solutions

_No response_

Priority

High - Significant impact on productivity

Feature Category

Interactive mode (TUI)

Use Case Example

Initial instruction:

Implement authentication state management using the existing architecture.

The agent starts investigating the repository and reports:

I found that authentication state is currently managed by AuthProvider. I plan to extend this implementation rather than introduce another state layer because it preserves the current architecture.

While the agent is working, the developer can intervene:

Instead, move this logic into a reusable hook. We may need the same behavior in another application later.

The agent responds:

Understood. I'll move the logic into a reusable hook. One consideration: directly coupling the hook to AuthProvider would make the hook difficult to reuse. I'll introduce an interface between them to avoid that coupling and preserve the existing architecture. I'll continue with that approach.

The agent then resumes execution using the updated plan.

Additional Context

There is an opportunity to introduce a different mode:

Collaborate with the agent while it works.

AI coding agents have made significant progress toward autonomous software development. However, the current interaction model still has a fundamental limitation: once an agent starts executing a task, the developer has very limited ability to influence its reasoning and direction before the task is completed.

Why This

The goal is not to reduce autonomy, but to make it adaptive: high autonomy when speed matters, and interactive autonomy when precision matters.

What This Is Not

This proposal is not simply:

1. A more verbose progress indicator.
2. A chat interface alongside the agent.
3. A permission or approval gate.
4. A pause/resume button.
5. An AskUser mechanism.

Those capabilities can be useful components of the experience, but the core proposal is broader:

Allow developers to continuously steer an autonomous coding agent while preserving its execution context, previous work, and ability to re-plan.

The experience should feel closer to working with an experienced pair programmer than submitting independent prompts to an autonomous process.