Step-by-Step Instructions

1. Pick Your Two Code Assistants
   
   

   • Decide which two AI tools you’ll compare (e.g., GitHub Copilot + Cursor, or Tabnine + CodeWhisperer).

   • Make sure both assistants support your chosen language or framework (e.g., Node.js, Python, etc.).

2. Set Up Your Single Dev Environment
   
   

   • Example: VS Code

     • Click the Extensions icon (left sidebar).

     • Search for your first AI assistant (e.g., “GitHub Copilot”) and click Install.

     • Search for your second assistant (e.g., “Cursor” or “Tabnine”) and click Install as well.

     • Confirm both extensions are enabled.

   • For JetBrains (IntelliJ, PyCharm, etc.), open Settings → Plugins and similarly install both plugins.

   • Restart your IDE if prompted.

3. Create a Small Demo Project
   
   

   • In your IDE, create a folder named something like user-login-demo.

   • Initialize a file, e.g.:

     • login.js (for Node/Express)
       or

     • login.py (for Python Flask/FastAPI)
       or whichever language you prefer.

4. Implement the Small Feature With Assistant #1
   
   

Sketch the requirements in code comments, e.g.:

javascript
CopiarEditar
// Let's create a simple user login function:

// - Takes a username & password

// - Checks against a hardcoded list of users (for now)

// - Returns "Login successful" or "Invalid credentials"

Type out a partial function signature:

javascript
CopiarEditar
function userLogin(username, password) {

  // ...

}

Observe the suggestions from your first assistant. If none appear, prompt it explicitly in comments:

javascript
CopiarEditar
// Could you generate a basic login check?

// If username='alice' and password='secret', return "Login successful"

// else "Invalid credentials"

Accept or refine the AI’s code. By the end, you should have something like:

javascript
CopiarEditar
function userLogin(username, password) {

  if (username === 'alice' && password === 'secret') {

    return "Login successful";

  }

  return "Invalid credentials";

}

• 
  

• (Optional) Add a quick test or console logs to see if it behaves as expected.
  
  

5. Refactor/Extend With Assistant #2
   
   

   • Disable or pause the first assistant’s plugin (to ensure you’re now only using the second one).

In your code, comment or outline how you want to extend the feature, e.g.:
javascript
CopiarEditar
// Next, I'd like to store user data in an array or object.

// Also, I'd like to add basic password hashing or session generation.

Let your second assistant propose changes or a new function. For example:
javascript
CopiarEditar
let users = [

  { username: 'alice', password: 'secret' },

  { username: 'bob', password: 'pass123' }

];

function userLogin(username, password) {

  // ...

}

Accept suggestions for session handling (if you indicated wanting session management), or password hashing approach. You might see something like:
javascript
CopiarEditar
// For example:

const bcrypt = require('bcryptjs');

// ...

async function userLogin(username, password) {

  // find user in users array

  // compare hashed password

  // ...

}

• 
  

• If you see incomplete or incorrect logic, prompt the tool more specifically or add partial code to guide it.

6. Compare the Two Experiences
   
   

   • Note how Assistant #1 handled initial code generation vs. how Assistant #2 performed on refactoring or advanced tasks.

   • You might observe differences in style suggestions, docstring generation, or error handling.

7. Test the Combined Result
   
   

If you’re using Node.js, run:
bash
CopiarEditar
node login.js

•  or incorporate a quick Express route to test the logic in an actual endpoint.

• Confirm both the initial login logic (Assistant #1) and the new additions (Assistant #2) work as intended.

8. Reflect on Strengths and Weaknesses
   
   

   • Did one tool excel at initial generation but struggle with advanced features?

   • Did the other do better at refactoring or adding security layers?

   • Which felt more aligned with your coding style?

9. Wrap Up
   
   

   • You now have a minimal user login system created by two distinct AI assistants.

   • This direct comparison reveals how different AI solutions approach code generation and refactoring steps.

Step-by-Step Instructions

1. Revisit Your Existing Project
   
   

   1. Open the same repo or folder you used in the Hands-On (Module 2, Lesson 1), which already has two endpoints/features created—one with the first assistant, one with the second.

   2. Ensure both code assistants (e.g., Copilot and Cursor, or Tabnine and CodeWhisperer) are installed/enabled.

   3. Confirm you have a working setup (the endpoints or features from the Hands-On are still functional).

2. Plan a Third Functionality or Endpoint
   
   

   1. Decide on a new feature that’s somewhat distinct from the first two:

      • Example A: “Forgot password” route—performing an email send or token generation.

      • Example B: “Data analytics” function that aggregates user data, returning stats.

   2. If your project is a Node.js Express app, you might add a new route; if it’s Python, maybe a new function or Flask endpoint.

3. Use Both Assistants, Switching as Needed
   
   

   1. Assistant A for new code generation:

      • Start writing or comment your intended functionality.

      • Let Assistant A propose the initial skeleton or logic.

   2. Assistant B for refactoring or specialized tasks:

      • Temporarily disable or pause Assistant A’s plugin (so the suggestions don’t clash).

      • Let Assistant B refine or add advanced logic, like security checks, error handling, or performance improvements.

   3. You can toggle between them in the same session:

      • If your IDE allows you to pick which assistant is active, do so.

      • If not, you may need to disable one plugin and enable the other.

4. Keep Notes on Observations
   
   

   1. Throughout the process, note:

      • Who did the faster initial generation? (Assistant A or B)

      • Which suggestions felt more robust or correct on the first try?

      • Any conflicts or confusion in your IDE if both tried to suggest code simultaneously.

   2. Consider aspects like:

      • Syntax: Did one assistant produce more accurate code for your chosen language?

      • Style: Did they follow your code style or introduce differences?

      • Refactoring: Which assistant gave more creative or effective improvements?

5. Finalize the Third Feature
   
   

   1. Once you’re satisfied that the new code compiles/runs, do a quick test:

      • If it’s an endpoint, hit it with curl or Postman.

      • If it’s a function, do a quick unit test or console log.

   2. Confirm everything is stable and integrated into the existing app or library.

6. Document Findings in COMPARISON.md
   
   

Create a file COMPARISON.md at the root of your project:
markdown
CopiarEditar
# Comparison of Multiple Code Assistants

**Third Functionality**: "Forgot password" (example)

- **Assistant A**:

  - Quick at generating basic route scaffolding.

  - Had trouble with advanced email library usage.

- **Assistant B**:

  - Provided better security suggestions (e.g., recommended hashing tokens).

  - Slower to propose code if environment variables not declared.

## Observations

- Speed of New Code:

  - Assistant A was faster at completing basic scaffolding.

  - Assistant B took longer but offered more thorough docstrings.

- Refactoring / Enhancements:

  - Assistant B consistently gave better improvements around error handling.

  - Assistant A rarely introduced advanced checks without prompting.

- Conflicts or Oddities:

  - While both assistants were active, sometimes overlapping suggestions occurred.

  - Disabled Assistant A to let B do final refactor steps.

## Conclusion

- For quickly spinning up routes, Assistant A seems best.

- For deeper logic or robust checks, Assistant B was more reliable.

1. 
   

2. Summarize your overall recommendation or preference for each scenario. For example:

   • "Use Copilot for scaffolding basic endpoints."

   • "Switch to Cursor for detailed refactors or complex domain logic."

7. Commit and Share
   
   

If your project is in Git, commit your changes:
bash
CopiarEditar
git add .

git commit -m "Add third endpoint using both AI assistants. Document findings in COMPARISON.md"

git push

If you prefer, invite teammates to review the repo or the COMPARISON.md file.