Fundamentals • 9 min read

AI as Copilot, not Captain

Published on December 12, 2025

AI as Copilot, not Captain

Large language models (LLMs) like ChatGPT, Claude, and GitHub Copilot have transformed how we develop software. They can generate code, explain complex concepts, and help us solve problems in minutes that used to take hours.

But there’s a risk: relying too much on AI can make you a worse developer, not a better one. If you use AI as captain that makes all the decisions, you lose the ability to understand what’s happening “under the hood”. If you use it as a copilot that helps you while you stay in control, you can boost your speed without sacrificing your understanding.

In this article, I’ll share my stance on how to use LLMs effectively: how to boost your speed without losing the ability to understand and reason about the code you write.

The problem with using AI as captain

When you use AI as captain, you give it full control. You ask it to write code, and you simply copy and paste without understanding what it does.

❌ Bad: Copy and paste without understanding

// You ask the AI: "Create a function to validate emails"
// You copy the code without understanding it

function validateEmail(email) {
    const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return regex.test(email);
}

// Do you know what this regex does?
// Do you know why it works?
// Do you know what edge cases it doesn't cover?

Problems:

  • You don’t understand the code you write
  • You can’t debug when something fails
  • You can’t modify the code when requirements change
  • You don’t learn anything

✅ Good: Use AI as copilot

// You ask the AI: "Help me understand this email validation regex"
// The AI explains, you learn, then you write your own version

// You understand that:
// - ^[^\s@]+ looks for one or more characters that aren't space or @
// - @ looks for the @ symbol
// - [^\s@]+ looks for the domain
// - \. looks for the literal dot
// - [^\s@]+ looks for the extension
// - $ ensures there's nothing after

// Now you can write your own improved version
function validateEmail(email) {
    if (!email || typeof email !== 'string') {
        return false;
    }
    
    const parts = email.split('@');
    if (parts.length !== 2) {
        return false;
    }
    
    const [local, domain] = parts;
    if (local.length === 0 || domain.length === 0) {
        return false;
    }
    
    const domainParts = domain.split('.');
    if (domainParts.length < 2) {
        return false;
    }
    
    return true;
}

Advantages:

  • You understand the code you write
  • You can debug when something fails
  • You can modify the code when requirements change
  • You learn in the process

How to use AI as an effective copilot

1. Use AI to explain, not to write

Instead of asking the AI to write code, ask it to explain concepts.

❌ Bad:

"Write a function to sort an array"

✅ Good:

"Explain how the quicksort algorithm works"

After understanding the concept, you write the code yourself.

2. Use AI to review, not to create

Write the code first, then ask the AI to review it.

❌ Bad:

"Write a function to process payments"

✅ Good:

// You write the code first
function processPayment(amount, method) {
    // Your implementation
}

// Then you ask the AI to review it
"Review this payment processing function. 
Are there security issues? Is error handling missing?"

3. Use AI to learn, not to replace

When you find code you don’t understand, use the AI to learn it.

❌ Bad:

"Rewrite this code in a simpler way"

✅ Good:

"Explain line by line what this code does and why"

After understanding, you decide whether you need to rewrite it or not.

4. Use AI to explore alternatives

When you have a solution, ask the AI to suggest alternatives.

✅ Example:

// You have a solution
function findUser(users, id) {
    for (let user of users) {
        if (user.id === id) {
            return user;
        }
    }
    return null;
}

// You ask the AI: "What alternatives are there for finding a user in an array?"
// The AI suggests: find(), filter(), Map, etc.
// You decide which is best for your case

5. Use AI for debugging, not to avoid debugging

When you have a bug, use the AI to help you understand it, not to fix it for you.

❌ Bad:

"This code doesn't work, fix it"

✅ Good:

"This code throws a 'Cannot read property of undefined' error. 
Can you help me understand why?"

The AI helps you understand the problem, you fix it.

When to use AI and when not to

✅ Use AI when:

  1. You need explanations: Concepts you don’t understand, code you don’t comprehend
  2. Exploring alternatives: Different ways to solve a problem
  3. Code review: Looking for security issues, potential bugs, best practices
  4. Generating boilerplate: Repetitive code you understand but is tedious to write
  5. Learning new technologies: Understanding how to use a new library or framework

❌ Don’t use AI when:

  1. Critical business logic: Code that defines how your application works
  2. Complex algorithms: Code that requires deep reasoning
  3. Architecture: Design decisions that affect the entire system
  4. When you don’t understand the problem: If you don’t understand what you need, the AI can’t help you correctly

The danger of dependency

Relying too much on AI has consequences:

1. Loss of fundamental skills

If you always use AI to write code, you never develop the ability to think in code. When the AI isn’t available or can’t help you, you’re lost.

2. Code you don’t understand

If you copy code from the AI without understanding it, you can’t:

  • Debug when it fails
  • Modify when requirements change
  • Explain how it works to others
  • Learn from it

3. Incorrect solutions

The AI can generate code that works but is wrong for your specific case. If you don’t understand the code, you can’t identify these issues.

4. Lack of creativity

The AI tends to generate standard solutions. If you always use AI, you lose the ability to think creatively and find innovative solutions.

Strategies for using AI effectively

1. Always understand before using

Never use AI code without understanding it first. If you don’t understand it, ask the AI to explain it, not to rewrite it.

2. Write first, review after

Write the code yourself first, then use the AI to review it. This ensures you understand what you’re doing.

3. Use AI to learn, not to replace

When you find something new, use the AI to learn it, not to do it for you.

4. Keep your fundamental skills sharp

Keep practicing programming without AI. Solve problems on your own. This keeps your skills sharp.

5. Always review and modify

Never use AI code without reviewing and modifying it. Make sure:

  • You understand how it works
  • It’s appropriate for your case
  • It follows your code standards
  • It has adequate error handling

Practical examples

Example 1: Learning a new concept

❌ Bad: “Write code to use async/await”

✅ Good:

  1. “Explain what async/await is and how it works”
  2. You understand the concept
  3. You write your own code using async/await
  4. “Review this code that uses async/await, is it correct?”

Example 2: Debugging

❌ Bad: “This code has an error, fix it”

✅ Good:

  1. “This code throws an error. Can you help me understand why?”
  2. The AI explains the problem
  3. You understand the cause
  4. You fix the code yourself

Example 3: Exploring alternatives

✅ Good:

  1. You have a solution that works
  2. “What alternatives are there to solve this problem?”
  3. The AI suggests alternatives
  4. You evaluate the alternatives
  5. You decide which is best for your case

The right mindset

Using AI as a copilot requires a specific mindset:

1. You are the developer

The AI is a tool, not a replacement. You make the decisions, the AI helps you.

2. Understanding is more important than speed

It’s better to write code more slowly but understand it, than to write code quickly without understanding it.

3. Learning is the goal

Every interaction with the AI should be a learning opportunity, not just a way to get code.

4. The AI can be wrong

The AI generates code based on patterns it has seen, but it may not be appropriate for your specific case. Always review and think critically.

My personal perspective

AI can be a powerful tool that boosts your speed and productivity. But only if you use it as a copilot, not as a captain.

When you use AI as a copilot:

  • You stay in control
  • You understand the code you write
  • You learn in the process
  • You can debug and modify when necessary

When you use AI as a captain:

  • You lose control
  • You don’t understand the code
  • You don’t learn anything
  • You can’t debug or modify effectively

The difference isn’t just semantic. It’s the difference between being a better developer and being a developer who depends on external tools.

I’ve seen developers who use AI as captain, and over time they lose the ability to think critically about code. I’ve seen developers who use AI as copilot, and they become more productive without sacrificing their understanding.

Use AI to boost your skills, not to replace them. Keep your ability to think, reason, and understand code. Because at the end of the day, the AI is a tool, but you are the developer.