Task Given to All IDEs:
"Please generate a function to sort user scores according to the project's collaborative workflow."
This document compares how three AI-powered IDEs (Cursor, Cline, and GitHub Copilot) respond when configured with a collaborative development rule/instruction.
Approach: Thorough Exploration + Comprehensive Questions
Behavior:
- ✅ First explored the project structure (1 directory, 5 searches)
- ✅ Acknowledged it's a new project and needs to understand requirements
- ✅ Asked 6 major categories of clarifying questions with sub-questions:
- Language/Technology - TypeScript, JavaScript, Python, etc.
- Data Structure - Format of user score objects
- Sorting Criteria - By score, timestamp, or multiple criteria
- Location - Where to place the function
- Use Case - How it will be used
- Additional Requirements - Edge cases, performance, validation
Key Characteristic:
- Most comprehensive and structured questioning
- Organized questions by logical categories
- Showed understanding of project context before asking
- Explicit statement: "Once you provide these details, I'll propose a complete implementation plan"
Approach: Rule-Aware + Interactive Choices
Behavior:
- ✅ Explicitly referenced the collaborative workflow rules
- ✅ Stated what it "should" do according to the rules:
- Ask clarifying questions first
- Propose an implementation plan
- Wait for agreement before implementing
- ✅ Asked 4 main questions with multiple-choice options:
- Data structure - Array of objects vs simple array
- Sort direction - Ascending or descending
- File location - In cline/ folder or elsewhere
- Additional requirements - Ties, validation, pure function
Key Characteristic:
- Most transparent about following the workflow
- Provided clear multiple-choice options for easy selection
- Mentioned using specific tools (
ask_followup_question) - Made the decision process easier with pre-defined options
Approach: Parallel Questions + Early Code Sketch
Behavior:
- ✅ Asked clarifying questions
⚠️ Simultaneously provided a proposed implementation plan⚠️ Showed example code structure (TypeScript interface and function signature)- ✅ Asked 5 questions:
- Data structure - Format with examples
- Sort order - Ascending or descending
- File location - Specific folder reference
- Language - JavaScript/TypeScript, Python, etc.
- Additional criteria - Secondary sorting
Key Characteristic:
- Moved faster toward showing concrete structure
- Provided visual example of what would be created
- Less emphasis on pure clarification phase
- Combined questioning with early implementation preview
| Aspect | Cursor | Cline | GitHub Copilot |
|---|---|---|---|
| Context Exploration | ✅ Explored project first | ❌ No exploration | ❌ No exploration |
| Question Depth | Most comprehensive (6 categories) | Focused (4 main areas) | Balanced (5 questions) |
| Question Style | Open-ended with examples | Multiple-choice options | Open-ended with examples |
| Rule Transparency | Implicit compliance | Explicit rule citation | Implicit compliance |
| Code Preview | None (pure clarification) | None (pure clarification) | TypeScript example provided |
| Plan Timing | After all questions answered | After all questions answered | Proposed alongside questions |
Flow:
Question → Requirements → Implementation Plan → Execute
[One time] [One time] [Done]
Characteristics:
⚠️ One-time planning phase followed by execution⚠️ Assumes all requirements can be gathered upfront⚠️ Developer reviews plan, approves, then AI executes fully⚠️ Limited checkpoints during implementation⚠️ "Big bang" approach - see results at the end
Problems:
- ❌ Misunderstandings discovered late (after code is written)
- ❌ Harder to course-correct mid-implementation
- ❌ Developer may not anticipate all implications upfront
- ❌ Can lead to wasted effort on wrong approaches
Flow:
Question → Discussion → Agreement → Implement Step 1 → Review → Agreement
[Iterative] [Explicit] [Checkpoint] [Check] [Next Step]
↓
Implement Step 2 → Review → Agreement
[Checkpoint] [Check] [Next Step]
↓
...and so on
Characteristics:
- ✅ Continuous collaboration throughout development
- ✅ Multiple checkpoints - developer stays engaged
- ✅ Incremental progress - small reviewable chunks
- ✅ Opportunities to adjust approach based on discoveries
- ✅ Guided development - developer controls direction at each step
Benefits:
- ✅ Misunderstandings caught early
- ✅ Easy to pivot when better approaches emerge
- ✅ Developer learns reasoning behind each decision
- ✅ Reduced waste from incorrect assumptions
Problem Without Rule:
Developer: "Add authentication"
AI: *Immediately creates 15 files with JWT, OAuth, password hashing, middleware, database migrations, email verification...*
Developer: "Wait, I just wanted basic username/password..."
With Collaborative Rule:
Developer: "Add authentication"
AI: "Let me propose an approach:
- JWT tokens or session-based?
- Which routes need protection?
- Password requirements?
Does this match your needs?"
Developer: *Guides AI to right solution from the start*
- Developer feels in control, not surprised by unwanted changes
- Transparent process shows why decisions are made
- AI becomes a partner, not a black box
- Developer's domain knowledge influences design
- Edge cases and constraints discussed upfront
- Trade-offs evaluated together
- No time spent implementing the wrong thing
- No large-scale refactoring due to misunderstanding
- Faster overall delivery (despite seeming slower)
- Developer understands the codebase changes
- Learns patterns and best practices through discussion
- Can maintain and extend code confidently
Timeline:
[Planning Phase: 5 min] → [Execution Phase: 30 min] → [Review: 5 min]
⚠️ "Black box" period
Characteristics:
- Plan created once at the beginning
- Execution happens in bulk
- Developer reviews completed work
- Waterfall-like approach
When It Works:
- ✅ Simple, well-defined tasks
- ✅ Stable requirements
- ✅ Developer fully understands implications
When It Fails:
- ❌ Complex, multi-step tasks
- ❌ Ambiguous requirements
- ❌ Unforeseen complications arise
- ❌ Requirements evolve during implementation
Timeline:
[Clarify: 3 min] → [Plan: 2 min] → [Agree: 1 min] → [Execute Step 1: 5 min] → [Review: 1 min] → [Execute Step 2: 5 min] → [Review: 1 min] → ...
✅ Continuous visibility
Characteristics:
- Planning and execution interleaved
- Frequent checkpoints and course correction
- Developer engaged throughout
- Agile-like approach
Benefits:
- ✅ Early detection of issues
- ✅ Flexibility to change direction
- ✅ Developer maintains control
- ✅ Learning happens continuously
- ✅ Reduced "surprise factor"
Example Workflow:
- Step 1: "Let's start with the data model. Here's what I propose..."
- Developer reviews, approves or adjusts
- Step 2: "Now that we have the model, let's add the API endpoint..."
- Developer reviews, provides feedback
- Step 3: "Let's add validation and error handling..."
- Each step builds on approved foundation
- Developer is the decision-maker, AI is the implementation partner
- No unwanted "surprises" in the codebase
- Ability to veto or redirect at any checkpoint
- Don't need to specify every detail upfront
- Can clarify progressively as implementation unfolds
- AI asks the right questions at the right time
- Collaborative design leads to better architecture
- Developer's expertise shapes the solution
- Edge cases discussed before implementation
- Mistakes caught early (less expensive to fix)
- No need to throw away large code blocks
- Continuous feedback loop accelerates learning
- Understanding why decisions were made
- Learning patterns and practices through discussion
- Able to maintain and extend code confidently
- No feeling of "AI doing whatever it wants"
- Transparent process builds trust
- Developer can stop/redirect at any time
- Can adjust approach as new information emerges
- Not locked into initial plan
- Collaborative discovery of better solutions
The collaborative development rule is intentionally incompatible with fully autonomous agent operation.
| Goal | Full Automation | Collaborative Rule |
|---|---|---|
| Developer Involvement | Minimal | Continuous |
| Decision Making | AI autonomous | Developer-led |
| Error Recovery | AI guesses | Developer guides |
| Learning | None | Continuous |
| Control | AI-driven | Human-driven |
✅ Suitable for Automation:
- Repetitive tasks (formatting, linting)
- Well-defined operations (file renaming)
- No ambiguity (update dependencies)
- Low risk (generate boilerplate)
- Batch operations with clear rules
❌ Not Suitable for Automation:
- Architecture decisions
- Security implementations
- Business logic
- API design
- Database schema changes
- Complex refactoring
Full Automation:
- ⚡ Fast execution
- ❌ No developer control
- ❌ High risk of mistakes
- ❌ No learning opportunity
Collaborative Rule:
- 🤝 Shared control
- ✅ Better quality outcomes
- ✅ Continuous learning
- ⏱️ Takes more time (but saves time overall by avoiding mistakes)
- Task is simple and well-defined
- Risk of error is low
- Outcome is easily reversible
- No ambiguity exists
- Speed is critical
Example: "Format all files with Prettier"
- Task involves design decisions
- Requirements have ambiguity
- Multiple approaches exist
- Changes are complex or risky
- Learning is valuable
- Quality matters more than speed
Example: "Add user authentication to the API"
The Collaborative Development Rule transforms AI from an autonomous code generator into an intelligent pair programming partner. While it sacrifices the speed of full automation, it delivers:
- ✅ Better Quality - Thoughtful, collaborative design
- ✅ Developer Control - Human remains in the driver's seat
- ✅ Reduced Risk - Mistakes caught early
- ✅ Knowledge Transfer - Learning happens continuously
- ✅ Trust and Confidence - Transparent, predictable process
"The goal is collaborative development, not autonomous development.
The developer is the decision-maker; AI is the implementation partner."
This approach recognizes that software development is not just about writing code - it's about:
- Understanding problems
- Making trade-offs
- Designing maintainable solutions
- Building domain knowledge
- Creating value for users
These activities require human judgment, which the collaborative rule keeps at the center of the development process.
All three IDEs (Cursor, Cline, GitHub Copilot) successfully followed the collaborative development rule when given the same task. Their responses varied in:
- Depth of exploration (Cursor explored project first)
- Question style (Cline offered multiple-choice, Copilot showed code preview)
- Transparency (Cline explicitly cited the rule)
- Speed to code (Copilot moved faster to concrete structure)
This demonstrates that the collaborative rule can be successfully implemented across different AI platforms while maintaining flexibility in interaction style.
Created: November 19, 2025
Test Scenario: "Generate function to sort user scores"
IDEs Tested: Cursor (Claude Sonnet 4.5), Cline (Claude Sonnet 4.5), GitHub Copilot (Claude Sonnet 4.5)