Step-by-Step Instructions

1. Pick Your IDE and Code Assistant
   
   

   • Decide which IDE (e.g., VS Code, IntelliJ) and which code assistant (e.g., GitHub Copilot, Tabnine, Amazon CodeWhisperer) you want to try.

   • If you have a preference (or an existing subscription), use that. Otherwise, GitHub Copilot is a common starting point.

2. Set Up Your Code Assistant
   
   

   • Example (GitHub Copilot in VS Code):
     
     

     1. Launch VS Code and open the Extensions panel (left sidebar).

     2. Search for “GitHub Copilot”.

     3. Click Install and follow any prompts to log in to GitHub or agree to terms.

     4. Make sure the extension is enabled.

   • If you’re using a different assistant or IDE, follow its official setup instructions (often found on the tool’s website or marketplace page).
     
     

3. Create a New Project or File
   
   

   • In your IDE, create a simple folder—for instance: tax-calculator-demo.

   • Inside that folder, create a new file, e.g., taxCalculator.js (if you prefer JavaScript).

   • Alternatively, use any language you like (Python, Java, etc.). The activity is the same.

4. Write an Outline or Comment
   
   

Begin by typing a brief comment, describing what you want:
javascript
CopiarEditar
// Let's create a simple function that calculates tax on an income.

// For example: if income < 20000, no tax, else 10% on the remainder.

• 
  

• Stop typing for a moment; see if the AI assistant suggests a snippet.

5. Observe AI Suggestions
   
   

   • If you see a gray or faint text (GitHub Copilot style) or a pop-up suggestion (Tabnine/Amazon CodeWhisperer):

     1. Press Tab (or the relevant hotkey) to accept the suggestion.

     2. Press Esc or the relevant key to dismiss if it’s not what you want.

Start the Function

javascript
CopiarEditar
function calculateTax(income) {

  // ...

}

6. 
   

   • The assistant may immediately suggest logic based on your previous comments.

If it doesn’t, prompt the tool by adding more details:
javascript
CopiarEditar
function calculateTax(income) {

  // If income < 20000, tax = 0

  // Else, tax is (income - 20000) * 0.1

  return 0; // placeholder

}

7. Refine the Generated Code
   
   

If the AI suggests partial or incorrect logic, add more comments:
javascript
CopiarEditar
// Also let's add a small handling fee of $50 if income > 50000

• 
  

• See if the assistant updates its suggestions accordingly.

8. Test the Function
   
   

Write quick console logs or unit tests:
javascript
CopiarEditar
console.log(calculateTax(18000)); // Should be 0

console.log(calculateTax(30000)); // (30000 - 20000) * 0.1 = 1000

console.log(calculateTax(60000)); // includes fee of 50 if >50000?

• 
  

• Run your code (in VS Code’s built-in terminal, or node taxCalculator.js if it’s JavaScript).

• Check if the results match your expectation. If not, revise the function or prompt the AI for a fix.

9. Explore Additional Features
   
   

   • Ask the AI to add input validation, docstrings, or a different tax bracket just to see how it responds.

Try explicitly “talking” to the AI in comments:
javascript
CopiarEditar
// I'd like a function that handles multiple brackets:

// 0% for income <= 20000,

// 5% for 20000-50000,

// 10% for 50000+,

// plus a 2% surcharge if income > 100000.

• 
  

• Notice how it modifies its suggestions based on your instructions.

10. Wrap Up
    
    

• You’ve successfully set up a code assistant, typed a function outline, and let the AI fill in details.

• You’ve also tested the output and made iterative improvements.

Step-by-Step Instructions

1. Pick Your Second Code Assistant
   
   

   • If you used GitHub Copilot in the previous Hands-On, you might try Tabnine, Amazon CodeWhisperer, Cursor, or another AI tool for this assignment.

   • Ensure it’s installed or enabled in your chosen IDE or editor. For instance:

     • VS Code: Go to Extensions, search for “Tabnine” or “Cursor,” then install.

     • JetBrains (IntelliJ, PyCharm, etc.): Open Settings → Plugins → search, install, and restart if needed.

2. Clone or Create a Small Sample Project
   
   

   • Decide on a lightweight codebase with 2–3 existing functions or modules.

   • Examples:

     • A notes app with basic CRUD (create, read, update, delete).

     • A mini CLI tool that manipulates data or files.

     • A simple microservice with a route or two in Node.js, Python, or another language.

If you don’t have an existing project, create a new folder with a minimal setup:
bash
CopiarEditar
mkdir second-assistant-demo

cd second-assistant-demo

npm init -y

# or python, etc.

3. Plan the New Feature
   
   

   • Decide which feature you’ll implement entirely with the second AI tool:

     • If it’s a notes app, add a “search notes by keyword” function.

     • If it’s a microservice, add a new endpoint (GET /search) that filters data.

     • If it’s a CLI, add a subcommand that performs some new logic.

   • Outline the requirements or acceptance criteria. For a “search notes” feature, for example:

     • Input: a string (keyword).

     • Output: a list of matching notes (case-insensitive).

     • Optional edge cases: empty string, no matches, special characters.

4. Implement the Feature with the Second Assistant
   
   

   • Open your project in your IDE (with the new code assistant installed).

Start coding or describe the feature in comments so the AI can pick up context:
javascript
CopiarEditar
// I'd like a "searchNotes(keyword)" function that returns an array of notes whose text includes the keyword

• 
  

• Pause and observe suggestions from the assistant. Accept or refine them accordingly.

• Avoid writing large chunks yourself—try relying on the AI’s suggestions to see how it structures the code.

If you’re stuck, prompt the assistant with more detail:
javascript
CopiarEditar
// Include partial matches, ignore case, and handle an empty notes array gracefully

5. Track Lines of AI-Generated vs. Manual Edits
   
   

   • Keep a simple tally of:

     • Lines the AI wrote that you accepted as-is or with minor tweaks.

     • Lines you had to significantly adjust or fully rewrite because the AI’s output was incorrect or suboptimal.

   • For instance, you might open a local text file or keep a notepad with marks:

     • “AI accepted lines: ~15.”

     • “Manual rewrites: ~4.”

   • If your tool highlights AI suggestions differently (e.g., in GitHub Copilot, gray text), use that to track how many lines were auto-completed.

6. Test the New Feature
   
   

If the project has a test suite, run it:
bash
CopiarEditar
npm test

• 
  

• If not, do a quick manual check or write a few tests to confirm correctness.

• Note how the assistant’s code performs—did it pass on the first try, or require debugging?

7. Document Observations in a Markdown File
   
   

Create SECOND_ASSISTANT_NOTES.md (or similar):
markdown
CopiarEditar
# Second Code Assistant Observations

**Project**: Notes app  

**Feature**: searchNotes(keyword)

**AI Tool**: Tabnine

- **AI-generated lines**: ~20

- **Manual rewrites**: ~5

- **Helpful snippets**:

  1. Automatic filtering logic with `notes.filter(...)`

  2. Suggested regex for case-insensitive search

- **Inefficient snippets**:

  - Proposed a complex data structure not needed for this scenario

  - Tried to use a library that wasn't installed in package.json

• 
  

• Summarize any highlights (the AI found a clever approach) or frustrations (the AI insisted on using incorrect syntax).

8. Compare to Your First Assistant’s Experience
   
   

   • Reflect on your Lesson 1 Hands-On with the first code assistant:

     • Did this second tool feel more or less intuitive?

     • Did you see fewer or more errors?

     • Which one best matched your coding style or offered better docstrings?

9. Wrap Up
   
   

   • You’ve now completed the assignment, using a second code assistant to implement a new feature.

The Markdown file with lines-of-code data and observations will help you compare performance, ease of use, and suggestion quality.