Skip to content
BSWEN
Blog

Does ChatGPT Make You Less Intelligent Over Time? A Honest Assessment

Cowrie
Cowrie
Dev @ Bswen

Purpose

I’ve been using ChatGPT daily for two years. When I catch myself reaching for AI before thinking through a problem, I worry: am I getting dumber? This post examines whether AI assistants cause cognitive decline, based on what developers and researchers actually observe.

The Meta Problem

When I read the Reddit thread asking “Does AI make us less intelligent?”, I noticed something ironic. The post itself felt obviously AI-written:

Title: Is AI Rewiring Our Brains? MIT Study on ChatGPT Raises Serious Questions


In today's rapidly evolving technological landscape, the integration
of artificial intelligence into our daily lives has sparked numerous
discussions about its potential cognitive effects...


Additionally, the study raises important questions about...
Furthermore, we must consider...

Generic transitions. Formulaic structure. No specific personal experience. The poster used AI to ask about AI dependency, possibly without realizing the irony. This perfectly demonstrates the concern: when AI replaces thinking rather than enhancing it, we lose something real.

Dependency vs Augmentation

The key distinction isn’t about tool use—it’s about who’s doing the thinking.

Dependency (I’m worried about this):

# I ask ChatGPT to write code without understanding it
prompt = "Write a function to parse JSON from API response"
code = chatgpt.generate(prompt)


# I paste it directly without reading carefully
eval(code)

I don’t understand what the code does. I can’t debug it when it breaks. I couldn’t write it myself without AI.

Augmentation (This is better):

# I write code myself first
def parse_api_response(response):
    try:
        return json.loads(response.text)
    except json.JSONDecodeError:
        return None


# Then I ask ChatGPT to review it
prompt = f"Review this code for edge cases: {parse_api_response}"
suggestions = chatgpt.generate(prompt)


# I evaluate each suggestion and implement what makes sense

I direct the thinking. I understand the code. AI speeds up work I could do myself.

Historical Parallels

When I worry about AI making me stupid, I look at history. Every new technology sparked the same fear.

Calculators and math education (1970s):

"They'll ruin mathematical ability! Students won't learn mental math!"
- Teachers' unions, 1975

What actually happened: Spreadsheets shifted focus from calculation to higher-level problem-solving. We didn’t get worse at math—we got better at asking the right questions.

Spell-check and writing (1990s):

"Spell-check will destroy writing ability! Nobody will learn spelling!"
- Writing instructors, 1992

What actually happened: Writers still own the craft. Spell-check reduced friction for expression while creativity and structure stayed human.

Search engines and memory (2000s):

"Google is making us stupid! We can't memorize anything anymore!"
- Nicholas Carr, 2008

What actually happened: We changed what we memorize. Facts became external; synthesis and analysis stayed internal.

The calculator parallel is reassuring. But smartphones provide a cautionary example: they did harm attention spans and memory retention. The difference with AI? It does reasoning, not just calculation or retrieval.

What I’ve Observed

Over two years of heavy AI use, I’ve noticed real changes in my cognition.

Skills that got weaker:

Terminal window
# Debugging: I reach for AI immediately
bug TypeError: NoneType object not subscriptable


# Old me: Read stack trace, identify line, check variable state
# New me: Paste error into ChatGPT before thinking
// Code retention: I forget syntax I don't practice
// Six months ago, I knew regex by heart
const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;


// Now, I ask ChatGPT every time
prompt = "Give me regex for email validation"

Skills that got stronger:

# System design: I see more patterns
# AI exposes me to architectures I wouldn't consider
class EventHandler:
    def __init__(self):
        self.handlers = {}


    def register(self, event_name):
        def decorator(handler):
            self.handlers[event_name] = handler
            return handler
        return decorator


# I learned pub/sub patterns from AI-generated examples
# Then I applied them myself in new contexts
# Velocity: I iterate faster
// I can test 4 approaches in the time it took to test 1
// More exposure = better pattern recognition
const optimized = data
  .filter(item => item.active)
  .map(item => transform(item))
  .reduce((acc, val) => [...acc, val], []);

The “Use It or Lose It” Problem

The Reddit thread captured a key insight:

Top-voted comment:
"Without practice in applying cognitive effort, there won't be
cognitive capability for doing all those higher things."


Skills require practice to maintain—writing, debugging, critical
thinking don't persist without exercise.

This is the real risk. When I:

  • Let ChatGPT write code without understanding it
  • Use AI for every email without composing my own thoughts
  • Offload problem-solving entirely to AI tools

I’m essentially skipping the cognitive “reps” that build skill. It’s like having a personal trainer who lifts the weights for me—I won’t get stronger.

My Approach: Stay in the Driver’s Seat

Based on what works for me, here’s how I use AI without losing my edge.

For coding:

# 1. Attempt first
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)


# 2. Then ask AI for review
prompt = "Review this recursive fibonacci for optimization"


# 3. Explain back to myself
"""
AI suggests memoization. This caches results so we don't
recalculate the same subproblems. Time complexity goes
from O(2^n) to O(n).
"""


# 4. Implement the improvement myself
from functools import lru_cache


@lru_cache(maxsize=None)
def fibonacci_optimized(n):
    if n <= 1:
        return n
    return fibonacci_optimized(n-1) + fibonacci_optimized(n-2)

The explain test: If I can’t explain what the AI’s output does, I don’t understand it well enough to use it.

For learning:

Terminal window
# Old way: Let AI explain everything
prompt = "Explain how React hooks work"
# Passive consumption


# New way: Wrestle with it first
# Read docs. Try examples. Get stuck.
# Then:
prompt = """
I understand useEffect basics but I'm confused about cleanup functions.
Here's what I tried: [code]. What am I missing?
"""
# Active learning with targeted questions

The without test: Could I do this task without AI? If not, I’m dependent, not augmented.

Regular no-AI sessions:

// Once a week, I code without any AI assistance
// Just me, the docs, and my brain


function deepClone(obj) {
    // No AI to help. I have to think this through.
    // What are the edge cases? Dates? Regex? Circular refs?


    if (obj === null || typeof obj !== 'object') {
        return obj;
    }


    // Handle Date
    if (obj instanceof Date) {
        return new Date(obj.getTime());
    }


    // Handle Array
    if (Array.isArray(obj)) {
        return obj.map(item => deepClone(item));
    }


    // Handle Object
    const cloned = {};
    for (const key in obj) {
        if (obj.hasOwnProperty(key)) {
            cloned[key] = deepClone(obj[key]);
        }
    }
    return cloned;
}

Maintaining the ability to work without AI keeps me honest about what I actually understand.

Common Mistakes I’ve Made

The reflexive reach:

# I open ChatGPT before thinking
problem: "How do I sort by nested property?"


# Better: Think first
problem: "I need to sort objects by user.name"
my_attempt = sorted(items, key=lambda x: x['user']['name'])


# Then use AI if I get stuck

Accepting without understanding:

// AI generates this
const debounce = (fn, delay) => {
  let timeoutId;
  return (...args) => {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => fn(...args), delay);
  };
};


# If I don't read it carefully, I miss:
# - What clearTimeout does
# - Why the closure works
# - What ...args spreads

Loss of edge practice:

# I never do the hard parts anymore
# Authentication: let AI handle it
# Database schema: let AI design it
# Error handling: let AI add it


# Result: I lose architectural judgment

What the Evidence Shows

Looking at MIT research and developer experiences, the consensus is clear:

AI doesn’t inherently make you less intelligent. But it can make you cognitively passive if you let it replace thinking rather than enhance it.

The calculator parallel is reassuring: new tools often spark fears of decline, but ultimately shift us to higher-level capabilities.

The smartphone parallel is cautionary: some technologies do change cognition in ways we should mind.

The key difference? Agency.

# Agency loss (dependency)
result = ai.think_for_me()
# I'm along for the ride


# Agency maintained (augmentation)
my_thought = "I need to optimize this loop"
suggestions = ai.challenge(my_thought)
result = my_decision(suggestions)
# I'm in the driver's seat

Summary

In this post, I examined whether ChatGPT causes cognitive decline based on two years of daily use and what the developer community reports. The key point is AI doesn’t make you less intelligent if you use it as augmentation rather than replacement. The risk is real—skill atrophy happens when you offload thinking entirely—but the historical parallels suggest most fears are overblown. Used well, AI shifts us to higher-level capabilities. Used poorly, it creates dependency.

The practical path forward? Use AI as a collaborator, not a replacement. Stay in the driver’s seat. Keep doing the cognitive reps. And write your Reddit posts yourself.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: