Multi-Tool Strategies

┌─────────────────┐
│  Chat Interface │  ← Planning & design
│  (Claude/GPT)   │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│    CLI Tool     │  ← Implementation
│  (Claude Code)  │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  IDE Assistant  │  ← Polish & refinement
│    (Copilot)    │
└─────────────────┘

┌─────────────────┐
│    Web Search   │  ← Research
│  (Perplexity)   │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Chat Interface │  ← Prototype
│    (Claude)     │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│    IDE + CLI    │  ← Full implementation
└─────────────────┘

┌────────────────────────────────────┐
│            You Write Code          │
└────────────────┬───────────────────┘
                 │
    ┌────────────┴────────────┐
    │                         │
    ▼                         ▼
┌─────────┐             ┌─────────┐
│  IDE    │             │  Chat   │
│ Suggest │             │ Review  │
└────┬────┘             └────┬────┘
     │                       │
     └───────────┬───────────┘
                 │
                 ▼
         ┌─────────────┐
         │   You Fix   │
         └──────┬──────┘
                │
                ▼
         ┌─────────────┐
         │   Commit    │
         └─────────────┘

// Function that validates email using regex
// Returns true for valid email, false otherwise

// Generate a React hook that:
// - Fetches user data from /api/users/:id
// - Handles loading and error states
// - Caches results with React Query

I'm building a feature and want to think through the design.

Context: [full context]

Before we write any code, help me:
1. Identify potential challenges
2. Consider alternative approaches
3. Choose the best approach
4. Plan the implementation steps

# Let it understand context first
"Read the files in src/services/ and explain the patterns used"

# Then make coordinated changes
"Add error handling to all service methods following the pattern in UserService"

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"]
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem"]
    }
  }
}

I've planned this feature in Claude:
[paste plan summary]

Key decisions:
- Using X approach because Y
- Data structure is Z
- Pattern follows existing code in [file]

Now implementing in IDE with this context.

I'm stuck implementing this in my IDE.

What I'm trying to do:
[description]

My current code:

The error/issue:
[what's wrong]

My IDE suggested [X] but that didn't work because [Y].

## Context for Next Tool

### What was decided
- [decision 1]
- [decision 2]

### What was implemented
- [file 1]: [what was done]
- [file 2]: [what was done]

### What's remaining
- [task 1]
- [task 2]

### Known issues
- [issue to be aware of]

Need to do something...
├── Quick code completion while typing?
│   └── → IDE Assistant
│
├── Need to understand/explain code?
│   └── → Chat Interface
│
├── Planning a new feature?
│   └── → Chat Interface
│
├── Multi-file coordinated changes?
│   └── → CLI Tool
│
├── Fixing a bug?
│   ├── Simple, in one file → IDE Assistant
│   └── Complex, multiple files → CLI Tool + Chat
│
├── Research/exploration?
│   └── → Chat Interface + Web Search
│
└── Repetitive transformation?
    └── → CLI Tool

Write line → Switch to chat → Switch back → Write line → Switch...

Plan in chat (10 min) → Implement in IDE (1 hour) → Review in chat (5 min)

# Current Context

## Project: [name]
## Stack: [technologies]
## Current task: [description]
## Key files:
- [file1]: [purpose]
- [file2]: [purpose]

Team Tool Guidelines:
- IDE: All use Cursor/Copilot for consistency
- Chat: Claude for planning, decisions documented
- CLI: Claude Code for multi-file changes
- Generated code requires: Human review before merge

PR Description:
## AI Assistance Used
- Planning: Claude (conversation link if available)
- Code generation: Claude Code
- All generated code reviewed and tested by [name]