Effective Learning Methods Using AI Tools: A Practice Guide Based on Scientific Evidence

Overview

AI tools like ChatGPT, Claude, GitHub Copilot, and Cursor have the potential to dramatically improve learning efficiency. However, passive use also carries the risk of cognitive decline and “skill hollowing.”

This article explains how to apply the findings from 14 peer-reviewed research papers introduced in the previous article “Evidence-Based Effective Learning Methods” to learning with AI tools. We present practical approaches for maintaining and improving cognitive abilities while utilizing AI, based on scientific evidence.

Target Audience: IT engineers, developers, and students learning with AI tools Prerequisites: Basic experience using AI tools like ChatGPT, Claude, GitHub Copilot, etc. Reading Time: 20 minutes

---

Challenges and Opportunities of Learning in the AI Era

Changes in Learning Brought by AI Tools

AI tools have fundamentally changed the learning process:

Opportunities:

• Instantly resolve questions
• Generate code examples and documentation immediately
• Get explanations from multiple perspectives
• Build personalized learning paths

Risks:

• Passive learning: Asking AI before thinking
• Shallow understanding: Copy-paste that works but don’t understand the principles
• Lack of metacognition: Can’t grasp what you don’t know
• Decreased memory retention: Flowing information without active processing

The purpose of this article is to present methods for maximizing the advantages of AI tools while avoiding these risks, based on scientific evidence.

---

Learning Environment Settings When Using AI Tools

Online Learning Environment Optimization: Self-View in Zoom/Video Calls

Tien, Imundo, & Bjork (2023) ¹ showed that viewing your own image during online learning increases appearance anxiety and decreases memory performance.

Application to AI Tools:

Many engineers use AI tools (Claude, ChatGPT, etc.) while pair programming or doing code reviews via Zoom or Google Meet in remote environments.

Practical Methods:

❌ To avoid:
- Always watching your own image while pair programming on Zoom
- Having AI tools and video conferences open simultaneously with self-view in your field of vision

✅ Recommended methods:
1. Use Zoom/Teams "Hide Self View" feature
2. Minimize your image during screen sharing
3. Center the AI tool (Claude, ChatGPT) screen
4. Place video window in corner of view
5. Reduce appearance anxiety and concentrate cognitive resources on learning

Specific Setting Example:

# Zoom settings
Settings > Video > "Hide Self View" ON

# Recommended layout for multi-display
[Display 1]            [Display 2]
- VSCode + Copilot     - ChatGPT/Claude
- Terminal             - Documentation
                       - Zoom (small window, self-view off)

Lighting and Color Optimization: Environment Settings to Enhance Concentration

From Choi & Suk (2016) ² and Al-Ayash et al. (2016) ³ introduced in the previous article, we know that color temperature of lighting and environmental colors affect cognitive performance.

Application When Using AI Tools:

1. Lighting Adjustment Based on Task

Recommended lighting by task with AI tools:

High-difficulty tasks (6500K - cool tone):
- Learning new frameworks
- Discussing architecture design with AI
- Implementing complex algorithms

Standard tasks (5000K - neutral tone):
- Normal coding
- Code review with AI
- Documentation creation

Light work (3500K - warm tone):
- Reading AI-generated code
- Review and refactoring
- Nighttime study (circadian rhythm protection)

2. Editor and Browser Theme Settings

Applying research ³ that vivid colors improve performance:

VSCode + GitHub Copilot settings:
- Dark theme as base
- Use vivid colors for syntax highlighting
- Calm background color, clear keywords
- Recommended themes: "One Dark Pro", "Monokai Pro"

ChatGPT/Claude settings:
- Dark mode or sepia mode
- Clearly distinguish code blocks with different backgrounds
- Consider eye fatigue for long-term use

Strategic Use of Sensory Stimulation: Music, Coffee, and Scent

Fekri Azgomi et al. (2023) ⁴ showed that music, coffee, and scent regulate cognitive arousal and performance.

Application When Using AI Tools:

1. Music Selection

Recommended music by task:

Deep dialogue with AI (deepening understanding):
- Classical music (no lyrics)
- Ambient, Lo-fi Hip Hop
- Reason: Doesn't interfere with language processing

Code generation and implementation:
- Upbeat instrumentals
- Electronic, Jazz
- Reason: Maintain arousal while concentrating

Debugging and problem solving:
- Quiet environment or light background noise
- White noise
- Reason: Focus on deep thinking

2. Strategic Coffee Intake

Coffee intake timing in AI tool learning sessions:

✅ Effective:
- Intake 30 minutes before session start
- During morning focused learning
- Before learning new concepts

❌ To avoid:
- After 4 PM (impact on sleep)
- Multiple consecutive intakes (tolerance formation)
- Depending on coffee before depending on AI

---

Effective Dialogue Methods with AI

Interactive Approach: Deeper Understanding Through Discussion with AI

Zavala & Kuhn (2017) ⁵ showed that interactive approaches promote deeper processing.

Application to AI Tools:

Many users use AI in a “one-way” manner, just asking questions and receiving answers. However, by taking an interactive approach, deeper learning becomes possible.

❌ Passive use:

User: "Explain Rust's ownership system"
AI: [explanation]
User: "Thanks" → Copy-paste and move on

✅ Interactive use:

User: "Is my understanding of Rust's ownership system correct?
      My understanding: Ownership is a concept where a variable has
      the sole reference to heap data to guarantee memory safety.
      When a move occurs, the original variable becomes invalid.
      However, borrowing allows temporary access."

AI: [feedback and corrections]

User: "So how is it different from C++'s RAII?
      What is the fundamental difference between ownership and RAII?"

AI: [comparative explanation]

User: "Please show me concrete examples. Show ownership violation code
      and the corrected code."

AI: [code examples]

User: "In this code, why doesn't the borrow checker throw an error?
      [present code]"

Interactive Learning Patterns:

1. Hypothesis presentation type

   "I understand that ○○. Is this correct?"
   → Have AI verify your understanding
   

2. Socratic questioning

   User: "Why is XXX designed this way?"
   AI: [explanation]
   User: "Then wouldn't the alternative YYY work?"
   AI: [trade-off explanation]
   User: "In case ZZZ, which is more suitable?"
   

3. Debugging dialogue

   User: "This code isn't working as expected.
         I predict ○○ is the cause. Am I right?"
   AI: [analysis]
   User: "Then should I try △△? Or □□?"
   AI: [suggestion]
   User: "I implemented the suggested fix. Please explain why this works,
         the internal mechanism."
   

Specific Prompt Examples (GitHub Copilot Chat):

# Interactive Learning Prompts

## Understanding Verification
"Please verify my understanding of the following code:
[code]

My understanding:
1. [understanding point 1]
2. [understanding point 2]
3. [understanding point 3]

Is this understanding correct? Please point out any mistakes or missing points."

## Socratic Questioning
"Please answer the following questions about this API design:
1. Why was this design chosen?
2. What other options were there?
3. What are the trade-offs of each?
4. In what situations would a different design be better?"

## Prediction and Verification
"I predict this code will produce ○○ result.
Before execution, please verify my prediction.
If I'm wrong, please explain why I'm wrong."

Utilizing Curiosity and Prior Knowledge: Think Before Asking AI

Wade & Kidd (2019) ⁶ showed that curiosity and prior knowledge play important roles in learning.

Application to AI Tools:

Problem: The immediacy of AI tools causes you to skip the process of thinking yourself.

Solution: “3-Step Thinking Process”

## 3-Step Thinking Process

Step 1: Activate prior knowledge (before using AI)
- Write out "what do I know?"
- List known similar concepts
- Time required: 2-3 minutes

Step 2: Predict and hypothesize (before using AI)
- Form hypothesis "probably ○○"
- State reasons why you think so
- Time required: 2-3 minutes

Step 3: AI verification and recording surprises (using AI)
- Ask AI and verify hypothesis
- Record points different from prediction
- Dig deeper into why it was different

Concrete Example: Learning Rust Lifetimes

[Step 1: Prior Knowledge]
What I know:
- Rust has an ownership system
- Borrowing creates references
- Drop happens when exiting scope

Similar concepts:
- C++ smart pointers (unique_ptr, shared_ptr)
- Java garbage collection (automatic memory management)

[Step 2: Prediction]
Lifetimes probably indicate the period during which a reference is valid.
Reason: Since borrowing exists, need to track "how long can you borrow."

Predictions:
- Compiler infers automatically?
- Some cases need explicit annotation?
- Related to scope?

[Step 3: AI Verification]
→ Ask ChatGPT/Claude

Actual answer:
- Mostly as predicted!
- Surprise: There are lifetime elision rules
- Surprise: Need to explicitly state lifetime parameters in function signatures

Next questions:
- What exactly are the lifetime elision rules?
- Why are some cases elidable and others not?

Notion/Obsidian Template:

# Learning Template: Think Before Asking AI

## Topic
[topic to learn]

## Prior Knowledge (fill out without using AI)
- What I know:
  -
  -
- Similar concepts:
  -
  -

## Predictions/Hypotheses (fill out without using AI)
Probably ○○.

Reason:


## AI Verification (use AI here)
Question:


Answer:


## Surprises and New Discoveries
Points different from prediction:
-
-

Why it was different:


## Next Questions
-
-

Utilizing Surprise and Prediction Violations: Bugs Are the Best Learning Opportunities

Frank, Kafkas, & Montaldi (2022) ⁷ showed that surprise (prediction violations) strengthens memory encoding.

Application to AI Tools:

Bug-Driven Learning

## 4 Steps of Bug-Driven Learning

1. Make prediction explicit
   "This code should behave like ○○"

2. Verify actual behavior
   → Bug occurred! Prediction violation!

3. Record surprise
   Write out "why was it different from prediction?"

4. Deep dialogue with AI
   Use AI to understand root cause

Concrete Example: JavaScript’s this Binding

// Prediction: This code should display username
class User {
  constructor(name) {
    this.name = name;
  }

  greet() {
    console.log(`Hello, ${this.name}`);
  }
}

const user = new User("Alice");
const greetFunc = user.greet;
greetFunc(); // Prediction: "Hello, Alice"
             // Actual: TypeError: Cannot read property 'name' of undefined

// Surprise! Why?

AI Dialogue Example:

User: "In this code, why is this undefined?
      I predicted that since greetFunc is a reference to user.greet,
      this would point to user."

AI: "In JavaScript, this is determined by how the function is called.
     When called alone like greetFunc(), this becomes undefined
     (strict mode) or the global object."

User: "So if I use user.greet.call(user) or user.greet.bind(user),
      can I explicitly bind this?
      What happens when using arrow functions?"

AI: "That's correct. You can fix it as follows: [example shown]"

User: "Then does the same problem occur with React event handlers?"

Creating a “Surprise Notebook”:

# Surprise Notebook

## Date: 2025-11-09
## Topic: JavaScript's `this` binding

### Prediction
greetFunc is a reference to user.greet, so this should point to user.

### Actual
TypeError: Cannot read property 'name' of undefined

### Why It Was Different
- JavaScript's this is determined by how the function is called
- When assigning a function reference to another variable, connection to original object is lost
- When calling function alone, this is undefined (strict mode)

### Solutions
1. Use bind(): const greetFunc = user.greet.bind(user);
2. Wrap in arrow function: const greetFunc = () => user.greet();
3. Use call()/apply(): greetFunc.call(user);

### Related Concepts
- Function.prototype.bind()
- Arrow functions (lexical this)
- The this problem in React event handlers

### What to Research Next
- Arrow function definition in class fields
- TypeScript's this type annotation

Active Learning: Strategy to Avoid Over-relying on AI

Buchan et al. (2020) ⁸ showed the effects and limitations of active learning.

Application to AI Tools:

Problem: AI tools risk promoting passive “teacher-centered” learning.

Solution: “70/30 Rule”

## 70/30 Rule

Learning time allocation:
- 70%: Hands-on work, trial and error yourself
- 30%: Ask AI questions, verify

Concrete examples:
- Learning a new library
  - 70%: Read official documentation, write code yourself
  - 30%: Ask AI about parts you don't understand

- Bug fixing
  - 70%: Debug yourself, check logs, trace code
  - 30%: Consult AI when stuck

- Algorithm learning
  - 70%: Implement yourself, create test cases
  - 30%: Discuss optimization and alternatives with AI

Implementation Example: “Wait Time” Setting in Cursor

## Self-Discipline When Using Cursor

1. When encountering a problem, first think for 5 minutes yourself
   - Set a timer
   - Search documentation
   - Trace with debugger

2. Before asking AI after 5 minutes, write out the following
   - What you tried
   - What you don't understand
   - Predicted cause

3. Ask AI (specifically)
   "I tried ○○ but got △△ result.
    I predict □□ is the cause. Am I right?"

4. Don't take AI answer at face value, verify
   - Understand the proposed code
   - Check if you can explain why it works
   - Consider if there are other methods

---

Breaks and Memory Retention in AI Learning

Strategic Breaks: Brain Replay Time After AI Sessions

Buch et al. (2021) ⁹ showed that the brain replays learning content during breaks, causing memory retention.

Application to AI Tools:

Problem: The immediacy of AI tools promotes continuous learning without breaks.

Solution: “AI Learning Pomodoro”

## AI Learning Pomodoro (Improved Version)

Traditional Pomodoro:
25 min work → 5 min break

AI Learning Pomodoro:
15 min AI dialogue/learning → 5 min break (completely offline) → 10 min practice/implementation → 5 min break

Reasons:
- AI dialogue has high information volume and cognitive load
- Break into shorter sessions
- Don't look at smartphone during breaks (don't interfere with brain replay)
- Retain learned content in implementation phase

Specific Timetable Example:

## When Learning a New Framework (Next.js)

9:00-9:15   ChatGPT dialogue: Learn basic concepts of Next.js
9:15-9:20   Break: Close eyes and recall learned content
9:20-9:30   Implementation: Try creating a simple page
9:30-9:35   Break: Stretch, drink water

9:35-9:50   ChatGPT dialogue: Learn routing and data fetching
9:50-9:55   Break: Look out window, deep breaths
9:55-10:05  Implementation: Try API routes
10:05-10:10 Break

10:10-10:25 Claude dialogue: Deep dive into Server Components
10:25-10:30 Break: Bullet point learned things in notes
10:30-10:40 Implementation: Implement Server Components
10:40-10:50 Longer break (15 minutes)

Recommended Activities During Breaks:

✅ Recommended:
- Close eyes and do nothing
- Reflect on learned content in your head (speaking aloud is OK)
- Light stretching
- Drink water
- Look out the window

❌ To avoid:
- Looking at smartphone (Twitter, HackerNews, Slack, etc.)
- Starting another coding task
- Checking email
- Watching YouTube

“Recall Test” After Break:

## What to Do Immediately After 5-Minute Break

Immediately after break, try without looking at AI:
1. List 3 things "what did I learn just now?"
2. Speak out loud as if explaining what you learned to someone
3. Try to recall and write key code examples

If you can't recall:
- That's proof it hasn't been retained
- Ask AI again and learn from a different angle

Sleep and Memory Retention: Review the Day After Learning

Greco et al. (2023) ¹⁰ showed that sleep quality affects learning.

Application to AI Tools:

## 24-Hour Cycle of AI Learning

Day 1:
- Evening: Learn new topic with AI
- Before bed: Brief review of what you learned today (5-10 min)
- Sleep: Use eye mask, complete blackout

Day 2 (Morning):
- Recall yesterday's topic without AI
- Check parts you couldn't recall with AI
- Implement to confirm retention

Reason:
- Memory consolidation occurs during sleep
- Transfer to long-term memory with next-day review

Implementation in Notion/Obsidian:

# Learning Log Template

## Day 1: 2025-11-09
### Topic: Kubernetes Operators

### AI Learning Session
- What I learned:
  - Basics of Operator pattern
  - Custom Resource Definitions (CRD)
  - Reconciliation loop

- What surprised me:
  - Difference between Controller and Operator

### Implementation
- [link to GitHub repo]

### Pre-bed Review (5 min)
- Operator is...
- CRD is...
- Reconciliation is...

---

## Day 2: 2025-11-10
### Morning Review (no AI)
- What I could recall:
  - [ ] Purpose of Operator pattern
  - [ ] Role of CRD
  - [ ] Flow of Reconciliation loop

- What I couldn't recall:
  - [ ] Details of Controller-runtime

### AI Re-learning
- Re-learn parts I couldn't recall

### Implementation/Retention
- Try implementing a simple Operator

---

AI Tools and Long-term Learning Habits

Reading Habits: Read Books Not Just AI

Sun et al. (2023) ¹¹ showed that reading habits have positive effects on cognitive ability and brain structure.

Application to AI Tools:

Problem: AI tools provide fragmented knowledge but are unsuited for systematic understanding.

Solution: “AI and Book Hybrid Learning”

## Weekly 12-Hour Reading Plan (AI Era Version)

12-hour weekly allocation:
1. Technical books (6 hours)
   - Build systematic understanding
   - Example: "Designing Data-Intensive Applications"

2. AI dialogue (3 hours)
   - Ask AI about parts not understood from books
   - Explain book content in your own words and have AI verify

3. Implementation/experiments (3 hours)
   - Implement what learned from books and AI

Reasons:
- Books: Deep systematic knowledge
- AI: Immediate question resolution, multiple perspectives
- Implementation: Knowledge retention and verification

Specific Workflow:

## Example: Reading "Clean Architecture"

[Reading Phase] (30 min daily × 7 days = 3.5 hours weekly)
- Read book and highlight important concepts
- Sticky note parts not understood

[AI Dialogue Phase] (weekend concentrated: 2 hours)
Saturday:
1. List parts not understood from reading
2. Dialogue with Claude/ChatGPT about each topic
   - "About Clean Architecture's dependency rule,
      I understood ○○. Is this correct?"
   - "The book explains △△, but
      what does that specifically mean?"

Sunday:
3. Explain book content to AI in your own words
   - "I'll explain Clean Architecture to a beginner.
      Is the following explanation accurate? [explanation]"
4. Ask AI for opposing opinions
   - "What are criticisms or limitations of Clean Architecture?"
   - "In what situations is Clean Architecture unsuitable?"

[Implementation Phase] (weekend: 3 hours)
- Implement learned architecture patterns in a small project
- Use GitHub Copilot but think about design yourself

Synergy Effects of Reading and AI:

Books only:
+ Systematic, deep understanding
- Can't resolve questions immediately
- Only author's perspective

AI only:
+ Immediate answers, multiple perspectives
- Fragmented, lacks systematization
- Difficult to achieve broad understanding

Books + AI:
+ Learn systematically with books, resolve questions with AI
+ Verify book content from multiple angles with AI
+ Utilize both while implementing

Creative Activities: Activities Beyond Coding

Ishiguro, Ishihara, & Morita (2023) ¹² showed that extracurricular activities in music and visual arts are associated with improved academic performance.

Application to AI Tools:

Problem: AI tools focus engineers only on coding, reducing opportunities to use other brain regions.

Solution: “Weekly Creative Activities”

## Creative Activities for Engineers (4-6 hours weekly)

1. Visual Design (2 hours weekly)
   - UI/UX design with Figma
   - 3D modeling with Blender
   - Vector art with Inkscape

   Combination with AI tools:
   - Midjourney/DALL-E: Idea generation
   - ChatGPT: Learning design principles
   - Claude: Color palette consultation

2. Music/Sound (2 hours weekly)
   - Music production with DAW (Ableton, Logic Pro)
   - Algorithmic composition with SuperCollider

   Combination with AI tools:
   - MusicLM: Inspiration
   - ChatGPT: Learning music theory

3. Writing (2 hours weekly)
   - Technical blog writing
   - Documentation creation

   Combination with AI tools:
   - Claude: Structure consultation, review
   - ChatGPT: English proofreading
   - (Note: Don't use AI-generated text as-is)

Concrete Example: Generative Art × Programming

// Generative art with p5.js
// Fusing coding skills and creativity

function setup() {
  createCanvas(800, 800);
  background(20);
  noLoop();
}

function draw() {
  // Parametric design
  for (let i = 0; i < 100; i++) {
    let x = random(width);
    let y = random(height);
    let size = random(5, 50);
    let hue = map(x, 0, width, 0, 360);

    colorMode(HSB);
    fill(hue, 80, 90, 0.6);
    noStroke();
    circle(x, y, size);
  }
}

// In the process of writing this code:
// - Algorithmic thinking (programming)
// - Visual design (art)
// - Mathematics (parametric design)
// are used integratively

Creative Dialogue with AI:

User: "I want to create fractal patterns with generative art.
      What's the difference between using L-systems and
      using recursive functions?"

Claude: [explanation]

User: "Now look at this code.
      What parameters should I adjust to make it look more
      organic and natural?"

Claude: [suggestions]

User: "I implemented with the suggested parameters.
      Now I want to extend this shape to 3D.
      Which do you recommend, Three.js or Shaders (GLSL)?"

Mindfulness: Attention Control When Using AI

Dumontheil et al. (2023) ¹³ showed that mindfulness training improves attention reorientation.

Application to AI Tools:

Problem: AI tools scatter attention and interfere with deep concentration.

Solution: “Mindful AI Use”

## Practice of Mindful AI Use

### 1. Mindfulness Before Session Start (2 min)
1. Take 3 deep breaths
2. Clarify what you're learning today
3. Direct awareness to "this moment, now"

### 2. Mindfulness During AI Dialogue
Awareness checklist:
- [ ] Am I really trying to understand now?
- [ ] Or am I just trying to copy-paste?
- [ ] Am I feeling rushed or anxious?
- [ ] Am I taking AI's answer at face value?

### 3. Handling When Attention Wanders
Steps:
1. Notice: Recognize "I'm not concentrating now"
2. Don't judge: Don't blame yourself
3. Return: Gently return attention to learning subject
4. Deep breath: Take 1-2 deep breaths to reset

### 4. Reflection After Session End (3 min)
- What was the most important thing I learned today?
- Where did I struggle?
- What will I learn tomorrow?

Mindfulness During Debugging:

## Mindful Practice When Facing Bugs

Traditional reaction:
"Damn, why is this bugging out!" → Frustration → Dump on AI

Mindful response:
1. Deep breath (3 times)
2. Recognize emotion
   - Notice "I'm frustrated now"
   - Recognize "I'm anxious"
3. Objective observation of current state
   - "This code returns △△ output for ○○ input"
   - Observe only facts without involving emotions
4. Attitude of curiosity
   - Have curiosity: "Why is this happening?"
   - View bug as "learning opportunity" not "problem"
5. Ask AI
   - Specific and constructive questions, not emotional

Mindfulness During Code Reviews:

## Mindful Code Review When Using AI Tools

❌ Non-mindful method:
1. GitHub Copilot generates code
2. Test if it works
3. If it works, commit → Done

✅ Mindful method:
1. GitHub Copilot generates code
2. Pause (deep breath)
3. Read code line by line
   - "What is this code doing?"
   - "Why was this implementation chosen?"
   - "Are there other methods?"
4. Ask AI (Copilot Chat)
   - "Please explain each line of this code"
   - "Why this implementation? Alternatives?"
5. Commit after understanding

8-Week Mindfulness Program (for AI Learners):

## Week 1-2: Basic Awareness
- 10-minute breathing meditation daily
- Practice noticing emotions when using AI

## Week 3-4: Attention Control
- Gently return when attention wanders during AI dialogue
- Avoid multitasking (don't do AI and other tasks simultaneously)

## Week 5-6: Non-judgmental Observation
- Non-judgmentally observe bugs and errors
- "What's happening now" not "good/bad"

## Week 7-8: Integration
- Practice in all AI learning sessions
- Reflect on effects and adjust

---

Concrete Practice Examples: By Language/Framework

Example 1: Learning Rust (Beginner)

## Learning Rust Scientifically: 4-Week Program

### Week 1: Ownership System

[Monday]
9:00-9:15   Pre-study: Read "The Rust Book" Ch.4
9:15-9:20   Break
9:20-9:35   ChatGPT dialogue: Basic ownership concepts
            "My understanding: Ownership is ○○. Is this correct?"
9:35-9:40   Break (close eyes and reflect on learned content)
9:40-9:55   Implementation: Write simple ownership examples
9:55-10:00  Break

10:00-10:15 Bug-driven learning: Deliberately cause ownership violation
10:15-10:20 Break
10:20-10:35 Claude dialogue: Deep dive into why error occurred
10:35-10:40 Break
10:40-10:55 Implementation: Fix and solidify understanding
10:55-11:00 Break

[Tuesday morning]
8:00-8:15   Review yesterday's topic (no AI)
8:15-8:30   Re-learn parts couldn't recall with AI

[Wed-Friday]
Same cycle to learn borrowing, lifetimes

[Weekend]
- Read "Programming Rust" (3 hours)
- Dialogue with AI about content read (1 hour)
- Mini project implementation (2 hours)

Example 2: Learning Next.js (App Router) (Intermediate)

## Learning Next.js App Router Effectively

### Learning Approach

[Phase 1: Concept Understanding (Day 1-2)]

Day 1 Morning:
1. Read official documentation (30 min, no AI)
2. Write out your understanding in Notion
   - What are Server Components?
   - What are Client Components?
   - Why is this distinction needed?
3. Verify with ChatGPT (15 min)
   - "Is the following understanding correct? [your understanding]"
4. Break (5 min)
5. Deep dive into surprise points (15 min)
   - "Why are Server Components the default?"
   - "How is it different from traditional SSR?"

Day 1 Afternoon:
1. Implement simple app (1 hour, no AI)
   - Turn off GitHub Copilot
   - Build on your own while looking at documentation
2. Break (10 min)
3. Improve with Copilot on (30 min)
   - Look at Copilot's suggestions
   - Ask Copilot Chat "Why this implementation?"
4. Break (10 min)
5. Refactoring (30 min)

[Phase 2: Deep Dive (Day 3-5)]

Daily themes:
- Day 3: Data fetching and caching
- Day 4: Routing and layouts
- Day 5: Server Actions and Mutations

Each day's cycle:
1. Official documentation (no AI)
2. Write out prior knowledge and predictions
3. Verify with AI dialogue
4. Intentionally cause bugs to learn
5. Implement to solidify

[Phase 3: Integration (Week 2)]

- Mini project: Build blog system
- Use AI as "consultant"
  - Design consultation: "Is there a problem with this design?"
  - Code review: "Can this code be improved?"
  - Best practices: "What to watch out for in production?"

Example 3: Algorithms and Data Structures (LeetCode)

## Learning LeetCode Effectively with AI Tools

### Basic Approach
❌ Ask AI for answer → Copy-paste → Next problem
✅ Think yourself → Dialogue with AI → Learn optimization

### Workflow Per Problem

[Step 1: Think On Your Own (20 min)]
1. Read problem
2. Check constraints
3. Trace examples by hand
4. Write out algorithm on paper
5. Predict time complexity and space complexity
6. Implement (OK if it doesn't work)

[Step 2: AI Dialogue (10 min)]
- Explain your solution
- Have AI verify

```markdown
User: "For this problem, I thought of the following approach:
      [my solution]

      Time complexity: Predicted O(n²)

      Is this solution correct? Is there a more efficient method?"

ChatGPT: [feedback]

User: "About the proposed O(n) solution, why is using
      a hashmap more efficient? What are the trade-offs?"

[Step 3: Break (5 min)]

• Close eyes and replay learned algorithm in your head

[Step 4: Optimized Implementation (15 min)]

1. Implement after understanding AI’s suggestion
2. OK to use GitHub Copilot but understand line by line
3. Verify with test cases

[Step 5: Learn Variations (10 min)]

User: "How should I modify this solution if the following constraints changed?
      1. If input is sorted
      2. If input has duplicates
      3. If memory is extremely limited"

[Step 6: Explore Similar Problems (5 min)]

User: "Please give me 5 problems with similar patterns to this problem.
      Explain how this algorithm can be applied to each."

Weekly Plan

Mon-Fri: 2-3 problems daily (above workflow) Sat: Weekly review

• Summarize learned algorithm patterns in Notion
• Deepen understanding through AI dialogue Sun: Creative coding (p5.js, etc.)
• Visualize algorithms
• Use different parts of the brain ```

---

Summary

This article explained how to apply the findings from 14 peer-reviewed research papers to learning with AI tools (ChatGPT, Claude, GitHub Copilot, Cursor, etc.).

Key Practice Points

1. Optimizing the Learning Environment

• Online environment: Turn off self-view to reduce appearance anxiety ¹
• Lighting: Adjust color temperature based on task (3500K-6500K) ²
• Sensory stimulation: Strategically use music, coffee, and scent ⁴

2. Effective Dialogue Methods

• Interactive approach: Discuss with AI, not one-way ⁵
• Utilize curiosity: Predict yourself before asking AI ⁶
• Utilize surprise: Turn bugs and prediction violations into learning opportunities ⁷
• 70/30 Rule: 70% yourself, 30% with AI ⁸

3. Breaks and Memory Retention

• AI Learning Pomodoro: 15 min learning → 5 min break cycle ⁹
• Go offline during breaks: Don’t look at smartphone, secure brain replay time ⁹
• 24-hour cycle: Review the morning after learning ¹⁰

4. Long-term Habits

• Hybrid learning: Combine AI and books ¹¹
• Creative activities: Stimulate brain with activities beyond coding ¹²
• Mindfulness: Improve attention control when using AI ¹³

5 Principles for Learners in the AI Era

1. Maintain agency: AI is “dialogue partner” not “teacher”
   • Discuss rather than passively receive answers
   • Explain your understanding and have it verified
2. Prioritize understanding: “Understood code” over “working code”
   • Before copy-paste, check if you can explain why it works
   • Don’t take GitHub Copilot suggestions at face value
3. Design breaks: Avoid continuous learning
   • 5-minute break every 15-25 minutes
   • Don’t look at smartphone during breaks
4. Systematic learning: Don’t rely only on AI
   • Learn systematically with books, resolve questions with AI
   • Aim for structured understanding, not fragmented knowledge
5. Maintain metacognition: Constantly check your understanding level
   • Periodically ask yourself “what do I know now?”
   • Be careful of “thinking you understand”

3 Actions You Can Start Today

Level 1: Start Now (5 min)

1. Turn on Zoom's "Hide Self View"
2. Set timer app for 15 min + 5 min break
3. Create "Learning Log" page in Notion

Level 2: Start Today (30 min)

1. Create "Think Before Asking AI" template
2. Review GitHub Copilot settings, turn off excessive suggestions
3. Plan 12 hours of weekly reading

Level 3: Start This Week (2 hours)

1. Download mindfulness meditation app (Headspace, Calm, etc.)
2. Adjust learning environment lighting (consider smart lights)
3. Choose and start one creative activity (p5.js, Figma, music production, etc.)

Finally: AI Is a Tool, Learners Are Human

AI tools are very powerful, but the subject of learning is always human.

The methods introduced in this article are all based on scientific research, but there are individual differences. Find methods that work for you and adjust continuously.

By using AI tools as “training equipment” rather than “crutches,” you can efficiently learn while maintaining and improving cognitive abilities.

Combining evidence-based learning methods with the power of AI tools, aim for continuous growth.

---

References

---

Related Articles

• Evidence-Based Effective Learning Methods: Optimizing Environment, Methodology, and Habits - Detailed explanation of research papers underlying this article
• Evidence-Based Learning in the AI Era: A Daily Schedule Example - Concrete schedule examples for practicing the methods in this article

---

On Citation Accuracy:

The research cited in this article has been verified through the following methods:

• Confirmation in academic databases (PubMed, Google Scholar, ScienceDirect, Nature, Wiley Online Library, etc.)
• Verification of paper information on official journal websites
• Cross-verification through multiple independent sources (academic media, official research institution announcements, etc.)

Full PDF access may be restricted for some papers, but abstracts, DOIs, author information, and key findings have been confirmed through official academic databases and reliable secondary sources.

1. Viewing oneself during synchronous online learning increases appearance anxiety and decreases memory for lecture content - Ingrid S. Tien, Megan N. Imundo, Elizabeth Ligon Bjork (2023). Applied Cognitive Psychology. [Reliability: High] ↩︎ ↩︎²

2. Dynamic lighting system for the learning environment: performance of elementary students - Kyungah Choi, Hyeon-Jeong Suk (2016). Optics Express. [Reliability: High] ↩︎ ↩︎²

3. The Influence of Color on Student Emotion, Heart Rate, and Performance in Learning Environments - Aseel Al-Ayash, Robert T. Kane, Dianne Smith, Paul Green-Armytage (2016). Color Research & Application. [Reliability: High] ↩︎ ↩︎²

4. Regulation of brain cognitive states through auditory, gustatory, and olfactory stimulation with wearable monitoring - Hamid Fekri Azgomi et al. (2023). Scientific Reports. [Reliability: High] ↩︎ ↩︎²

5. Solitary Discourse Is a Productive Activity - Julia Zavala, Deanna Kuhn (2017). Psychological Science. [Reliability: High] ↩︎ ↩︎²

6. The role of prior knowledge and curiosity in learning - Shirlene Wade, Celeste Kidd (2019). Psychonomic Bulletin & Review. [Reliability: High] ↩︎ ↩︎²

7. Experiencing Surprise: The Temporal Dynamics of Its Impact on Memory - Darya Frank, Alex Kafkas, Daniela Montaldi (2022). Journal of Neuroscience. [Reliability: High] ↩︎ ↩︎²

8. A RCT for assessment of active human-centred learning finds teacher-centric non-human teaching of evolution optimal - Loredana Buchan, Momna Hejmadi, Liam Abrahams, Laurence D. Hurst (2020). npj Science of Learning. [Reliability: High] ↩︎ ↩︎²

9. Consolidation of human skill linked to waking hippocampo-neocortical replay - Ethan R. Buch, Leonardo Claudino, Romain Quentin, Marlene Bönstrup, Leonardo G. Cohen (2021). Cell Reports. [Reliability: High] ↩︎ ↩︎² ↩︎³

10. Wearing an eye mask during overnight sleep improves episodic learning and alertness - Viviana Greco, Damiana Bergamo, Paola Cuoccio, Karen R. Konkoly, Kike Muñoz Lombardo, Penelope A. Lewis (2023). Sleep. [Reliability: High] (Note: A reanalysis paper in August 2023 has raised questions about some results) ↩︎ ↩︎²

11. Early-initiated childhood reading for pleasure: associations with better cognitive performance, mental well-being and brain structure in young adolescence - Yun-Jun Sun, Barbara J. Sahakian, Christelle Langley, Anyi Yang, Yuchao Jiang, Jujiao Kang, Xingming Zhao, Chunhe Li, Wei Cheng, Jianfeng Feng (2023). Psychological Medicine. [Reliability: High] ↩︎ ↩︎²

12. Extracurricular music and visual arts activities are related to academic performance improvement in school-aged children - Chiaki Ishiguro, Toru Ishihara, Noriteru Morita (2023). npj Science of Learning. [Reliability: High] ↩︎ ↩︎²

13. A preliminary neuroimaging investigation of the effects of mindfulness training on attention reorienting and amygdala reactivity to emotional faces in adolescent and adult females - Iroise Dumontheil, Kristen E. Lyons, Tamara A. Russell, Philip David Zelazo (2023). Journal of Adolescence. [Reliability: High] ↩︎ ↩︎²