July 6, 2026

aicognitionai-code-assistant

AI is making me faster for sure but I feel empty and sad afterwards.

Sometimes I feel sad that I am not using my cognitive power to the extent that I used to. Not because I suddenly became less intelligent. Not because I stopped working o…

Sometimes I feel sad that I am not using my cognitive power to the extent that I used to.

Not because I suddenly became less intelligent.

Not because I stopped working on difficult problems.

Actually, I am probably building more things and solving more real world problems than I used to do earlier.

But somthing still feels different.

Ever since I started using AI regularly, the need to remember information has gone down drastically.

The need to properly arrange my thoughts has also gone down.

Sometimes I feel like I am working at a very abstract level where I only have some vague idea of what I want.

Instead of forcing my brain to convert that vague idea into something meaningful, I just vomit whatever is currently running inside my head into an LLM.

Then I wait for it to do the things that my cognition should probably have done.

And I am saying this honestly… Most of the time it works… the output often looks clean… code runs… the document sounds professional. The tickets that I receieved gets shaped into something that I understand or just I feel like I understand.

In reality everything looks fine from outside.

But somewhere between my vague thought and the AI-generated result, I feel like I skipped an important mental process.

And I almost always know that in the long run it will create a gap.

To make more sense of what I am talking about I will use an example.

Let’s take a simple example of writing code which I do everyday with the help of AI.

Suppose I need to implement an API endpoint.

The requirement is something like:

Create an endpoint that returns a paginated list of users, supports filtering by status, and sorts the result by creation date.

Before AI, I would probably do something like this:

Read the requirements carefully.
Think about the request parameters.
Decide how pagination should work.
Think about the edge cases.
Check the existing project structure.
Write a rough implementation.
Get an error.
Search the error.
Get two more errors and solve them as well.
Understand why my approach failed.
Fix it.

And we all know all of this process takes time and cognitive ability to nagvigate through the existing knowledge on the internet. It might feel sometimes irritating.

Sometimes I would spend 30 minutes because I forgot the exact syntax of something very simple that my mind is not allowing to search on internet.

But during this process, my brain was continously building connections.

I had to remember where the controller was.

I had to understand how the servive layer worked.

I had to think about whether filtering should happen before or after pagination.

I had to decide what should happen when the page number is invalid.

Even when I made mistakes, those mistakes were forcing me to understand the system more and more.

But, Now the process can look like this:

“Here is my controller, servive, repository and database schema. Add pagination, filtering by statusand sorting by created_at. Follow the existing project pattern.”

And that’s it. AI generates the implementation.

I read it (sometimes we even don’t read it).

It looks reasonable.

I run it.

It works.

Greatttt. Task completed.

But what exactly did I learn?

Maybe something.

But definitely less than what I would have learned by arranging the implementation inside my own head first.

Let me make something clear… The problem is not that AI writes the Code.

I don’t think using AI to write code is automatically bad.

That would be a very easy and incorrect conclusion of the what I am feeling.

I say this because I think we have always used tools. We use compilers instead of writing machine code. We use frameworks instead of implementing HTTP servers from scratch.

We use Google instead of remembering every method name that a particular language, module provides.

We use Stack Overflow, documentation, autocomplete, linters and code generators.

Nobody says:

“A real programmer should remember the exact syntax of every standard library function”.

That would be straight stupid.

The job of a developer is not to win a memory competition. The problem starts when we outsource not only the syntax but also the thinking.

There is a difference between:

“What is the syntax for sorting this slice?”
“Here’s the task. Think about everything and give me the final implemenation.”

In the first case, the tool fills a small information gap.

While in the second case, the tool might replace the entire reasoning process and make a information gap instead of filling it.

And this is where me and probably you also make mistakes. Because it is very easy to ignore the difference between first one and second one.

And both of the above use feels like “using AI”.

There are different levels of Abstraction

Let’s imagine that I want to build a notification system.

At a low level, I might think about:

How the notification is stored
What the database schema looks like
How retries work
What happens when the email provider fails
Whether the operation should be synchronous or asynchronous
How duplicate notifications are prevented

At a higher level, I might only think:

“Users should receive an email after registration.”

There is nothing wrong with thinking at a higher level. Infact Senior engineers often work at the higher level itself, They don’t manually write every loop or remember every API.

But they can usually move down the abstraction layers when required. They have enough context and knowledge gathered from experience that they understand what might exist below.

They know which questions to ask.

They know what and where can be the failure.

And that’s the important part.

The danger is when we start operating at a high level of abstraction not because we understand the lower levels, but because AI is hiding them from us.

That is not abstraction.

That is dependence with a nice user interface.

“But I reviewed the generated code”

This is something very common that I often found myself thinking.

I did not blindly copy it.

I reviewed it.

So it should be fine, right?

Maybe. (I don’t think so).

But reviewing a solution and producing a solution are different cognitive activities.

When the answer is already present, our brain easily convinces us that we understood it.

We read the generated function and think:

“Yeah, obviously. I could have written that.”

But could you? Could I?

Could we write it again tomorrow without generated answer in front of us?

Could we identify what assumptions the AI made?

Could we modify it when the requirements change slightly?

Could we debug it confidently when it breaks only in production at 2AM?

That is where the difference became visible to me.

I know reading code creates familiarty. But we all can agree that writing and debugging the written code creates understanding.

They kind of overlap but they are not the same thing.

It is similar to watching someone solve a Leetcode problem.
When you see the solution, everything looks ovbious. Then you close the video, open the editor and suddenly all the ovbiousness left the chat.

The Missing Struggle

There is a type of struggle that is completely useless. For example, spending three hours because you forgot a library name is probably not making you a better engineer. And I am happy that AI is removing that struggle. But there is another kind of struggle that is important and good.

The struggle to define the problem, to break a large task in smaller ones, to compare two approaches, to notice that your understanding is incomplete, to explain your idea clearly enough that another person can understand it.

I beleive this is the type of struggle where a lot of learning happens.

When AI immedietly transforms an unclear thought into a clean answer, it can hide the fact that the thought was unclear in the first place. The output becomes well structured. But my brain never performed the structuring.

Very convinient but scary.

I Noticed this while writing too

Earlier, when I wanted to write something, I had to sit with the idea. I would start with one sentence. Delete it. Write another paragraph. Realise that my second point should actually come before my first point. Then I would discover that I did not understand my own argument properly.

Writing was not just a method of presenting my thoughts. Writing was the process through which I discovered what my thoughts actually were. Now I can give an LLM five broken sentences and ask:

“Arrange these ideas into a well-structured article.”

And it will.

The result might even be better than what I would have written manually. But if I repeatedly do this, I wonder whether I am slowly losing my ability to take a messy thought and make sense of it myself.

Again, the concern is not the final output.

The final output can be excellent.

The concern is what did not happen inside my head while producing it.

Memory is also part of Thinking

I don’t think we need to remember everything. Remembering random syntax just to prove that we can remember it does not make much sense. But memory is not only a storage system.

The things we remember are also the things our brain can quickly connect.

Suppose I remember:

How database indexes work
Why network calls fail
How transactions behave
What race conditions look like
How caching can crate stale data

When i see a new production issue, mt brain can combine these pieces and form possible explanations.

Maybe the slow API is missing an index, maybe the cache is returning old data, maybe two requests are updating the same resource.

These connenctions happen because some knowledge is already avaiilable inside my head. If every piece of information lives ourside my brain and I retrieve it only when required, I may still be able to complete task.

But forming new connections might become harder and harder for me.

You cannot easily connect ideas that you don’t actually carry with you.