65% of Brazilian Kids Use Generative AI: What This Means for the Future of Programming

A recent study revealed a surprising fact: 65% of Brazilian children and teenagers already use generative AI tools like ChatGPT, Gemini, and Claude in their daily lives.

While many developers are still learning to use these tools, an entire generation is already growing up with them as a natural part of their learning. What does this mean for the future of programming? How will this change how we teach and learn software development?

Let's explore this phenomenon and understand its implications for the tech field.

The Impressive Survey Numbers

The research, which analyzed the digital behavior of Brazilian youth, brought revealing data:

Main Findings

65% have already used some generative AI
Majority use it for homework and study help
Exponential growth since 2023
No supervision in most cases

// Data representation
const aiSurvey = {
  totalInterviewed: 5000,
  ageRange: '10-17 years',
  location: 'Brazil',

  use_ai: {
    percentage: 65,
    total: 3250,
  },

  purposes: {
    homework: 45, // %
    school_research: 38, // %
    learn_programming: 12, // %
    general_curiosity: 28, // %
    create_content: 18, // %
  },

  most_used_tools: [
    { name: 'ChatGPT', users: 52 },
    { name: 'Google Gemini', users: 23 },
    { name: 'Copilot', users: 15 },
    { name: 'Claude', users: 8 },
    { name: 'Others', users: 2 },
  ],
};

The most interesting fact? 12% already use AI specifically to learn programming - a number that tends to grow exponentially.

How Kids Are Using AI to Program

I talked to some young developers (13-17 years old) and discovered interesting patterns:

1. Accelerated Learning

# 14-year-old showed me this conversation with ChatGPT:

# Question:
"How to create a snake game in Python?"

# AI generated complete code + explanations
# The youth then asked:
"Can you explain what each line does?"

# And continued:
"How do I add scoring?"
"How do I make the game faster with each apple eaten?"
"Can I add difficulty levels?"

# Result: in 2 hours, had a working game
# And understood HOW it worked!

In the past, this process would take days or weeks. With AI as a "24/7 personal tutor," learning accelerates dramatically.

2. Interactive Debugging

// 16-year-old shared this workflow:

// Their code with error:
function calculateAverage(grades) {
  let sum = 0;
  for (let i = 0; i <= grades.length; i++) {
    // Bug: <= should be <
    sum += grades[i];
  }
  return sum / grades.length;
}

// Error message: "Cannot read property of undefined"

// They copy and paste into ChatGPT:
// "I'm getting this error... what's wrong?"

// AI explains:
// "The problem is in the loop. You're using <= when it should be <
// This makes the loop try to access grades[5] in an array of 5 elements (indices 0-4)"

// Teen learns about:
// 1. Off-by-one errors
// 2. Array indexing
// 3. How to debug loops

This is much more educational than simply searching Stack Overflow, because the AI explains the specific context of their code.

Impact on Programming Education

Schools and programming courses are having to adapt quickly:

Paradigm Shift

// BEFORE (2020-2022):
const programmingTeaching = {
  focus: 'Syntax and memorization',
  method: 'Teacher explains -> student copies',
  speed: 'Slow and progressive',
  difficulty: 'High barrier to entry',
};

// NOW (2025):
const teachingWithAI = {
  focus: 'Logic and understanding',
  method: 'Student explores with AI -> teacher guides',
  speed: 'Fast and adaptive',
  difficulty: 'Much lower barrier',
};

Real Example of Modern Class

# Python class for beginners (2025)

# Teacher: "Today we're creating a simple chatbot"
# Students (13-15 years): "Cool!"

# Teacher: "First, ask ChatGPT:
# 'How to create a basic chatbot in Python?'"

# 5 minutes later...
# Students already have working code

# Teacher: "Now modify it to answer questions about your hobbies"
# Students experiment, AI helps with errors

# Teacher: "Why doesn't the chatbot understand question variations?"
# Discussion about natural language processing

# Teacher: "How can we improve this?"
# Students research with AI and implement solutions

# Result: In 1 class, students:
# ✅ Created functional project
# ✅ Understood input/output concepts
# ✅ Learned about strings and conditionals
# ✅ Were exposed to NLP
# ✅ Debugged real problems

This would be impossible without AI as a teaching assistant.

Concerns and Challenges

Not everything is perfect. There are important challenges:

1. Excessive Dependency

// Concerning scenario:
class ExcessivelyDependentStudent {
  constructor() {
    this.skill_without_ai = 'very low';
    this.skill_with_ai = 'apparently high';
  }

  solve_problem(problem) {
    // Never tries to solve alone first
    return this.ask_ai(problem);

    // Doesn't develop own logical reasoning
    // Doesn't learn to debug alone
    // Doesn't understand deep fundamentals
  }
}

Solution: Teach when to use AI and when not to. AI should be a learning tool, not a thinking substitute.

2. Lack of Solid Fundamentals

// Student who only uses AI may have gaps:

function example() {
  // Asks AI: "How to sort array?"
  // Copies generated code
  const numbers = [3, 1, 4, 1, 5, 9, 2, 6];
  numbers.sort((a, b) => a - b);

  // It works! But the student doesn't understand:
  // - What is a comparison function?
  // - Why "a - b"?
  // - What happens if you don't pass the function?
  // - What sorting algorithms exist?
  // - What's the computational complexity?
}

Solution: Teachers need to ensure students understand the code AI generates, not just copy it.

3. Ethics and Plagiarism

# Real ethical dilemma:

# School assignment: "Create a program that calculates BMI"

# Student A: Asks AI to generate complete code
# Student B: Uses AI to understand concept, writes own code
# Student C: Doesn't use AI, researches and learns alone

# All deliver working programs
# Who learned the most?
# What is considered "cheating"?

Opportunities for Young Developers

On the other hand, there are incredible opportunities:

1. Creating Real Projects Earlier

// 15-year-old created a real app in 3 months:

const myFirstApp = {
  name: 'StudyBuddy',
  description: 'App that helps students organize studies',
  technologies: ['React Native', 'Firebase', 'Node.js'],

  process: {
    1: 'Learned React Native with AI',
    2: 'AI helped structure architecture',
    3: 'Debugged problems with AI help',
    4: 'Published on Play Store',
    5: 'Got 500+ downloads',
  },

  total_time: '3 months',
  developer_age: 15,

  comment:
    'Without AI, this would take years to learn alone. With AI as mentor, I did it in months!',
};

2. Open Source Contribution

// 17-year-old contributing to real projects:

async function contribute_open_source() {
  // 1. Find "good first issue" on GitHub
  const issue = await searchIssue('good-first-issue');

  // 2. Ask AI for help understanding codebase
  const explanation = await ai.explain(codebase);

  // 3. Implement solution with AI guidance
  const code = await implement_with_ai(issue);

  // 4. Submit quality PR
  await create_pr(code);

  // Result: Contributing to real software at 17!
}

How Parents and Educators Can Guide

Practical recommendations for those educating young programmers:

1. Teach Critical Thinking

# Framework to use AI educationally:

def learn_with_ai(problem):
    # STEP 1: Try to solve alone first
    own_attempt = try_to_solve(problem)

    # STEP 2: If stuck, ask AI for help
    if is_stuck(own_attempt):
        ai_help = ask_ai_help(problem)

    # STEP 3: IMPORTANT - Understand the solution
    understanding = explain_in_own_words(ai_help)

    # STEP 4: Implement own variation
    variation = create_variant_solution(understanding)

    # STEP 5: Teach someone else
    consolidate_knowledge(explain_to_others())

    return real_knowledge

2. Supervise and Guide

// Checklist for parents/educators:

const healthy_monitoring = {
  questions_to_ask: [
    'Do you understand how this code works?',
    'Can you explain each line?',
    'Can you modify it to do X instead of Y?',
    'What would happen if we changed this here?',
  ],

  warning_signs: [
    '❌ Always copies code without understanding',
    '❌ Cannot explain own solutions',
    '❌ Panics when AI is unavailable',
    '❌ Never tries to solve before asking for help',
  ],

  positive_signs: [
    '✅ Uses AI to learn, not just copy',
    '✅ Asks "why" and "how" questions',
    '✅ Experiments with code modifications',
    '✅ Can solve similar problems alone',
  ],
};

The Future: AI-Native Developers

This generation will be different from all previous ones:

// Profile of 2030 developer (today 10-15 years old):

interface AINativeDeveloper {
  technical_skills: {
    programming: 'Fluent in multiple languages';
    ai_as_tool: 'Natural and efficient use';
    assisted_debugging: 'Expert in AI-assisted debug';
    collaborative_architecture: 'Designs with AI as pair';
  };

  differentiators: {
    speed: 'Builds MVPs in days, not months';
    versatility: 'Comfortable in any stack';
    learning: 'Masters new technologies quickly';
    creativity: 'Focus on solution, not syntax';
  };

  mindset: {
    ai_as: 'Natural work tool';
    attitude: 'Pragmatic and results-oriented';
    focus: 'Solve real problems early';
  };
}

These young developers won't compete with us - they'll redefine what it means to be a developer.

If you want to understand how AI tools are changing development, I recommend reading GitHub Agent HQ: How to Manage Multiple AI Agents, where we explore the future of development tools.

Let's go! 🦅

📚 Teach Programming the Right Way

If you're teaching programming to youth or want to start your journey, it's essential to have a solid foundation that goes beyond just using AI.

Complete Educational Material

Structured guide to learn programming with solid fundamentals:

Investment options:

$4.90 (single payment)

👉 Learn About JavaScript Guide

💡 Learn the fundamentals that will allow you to use AI intelligently