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 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:

1. Read the requirements carefully.
2. Think about the request parameters.
3. Decide how pagination should work.
4. Think about the edge cases.
5. Check the existing project structure.
6. Write a rough implementation.
7. Get an error.
8. Search the error.
9. Get two more errors and solve them as well.
10. Understand why my approach failed.
11. 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:

1. “What is the syntax for sorting this slice?”
2. “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.

<Note this writeup is not yet completed… cause my cognition is nearing it’s limit. I will come back and complete it after reviewing my AI generated code x . x >