Cortex lease

Copyright: Sanjay Basu

 

What follows is a fictional piece, narrated by an imagined product manager with the usual scars of a long career in the tech industry. The voice is invented. The questions are not.

Faster, and Possibly Stupider

Last Tuesday I shipped a PRD I had written the week before. Forty pages. Architecture decisions, tradeoff matrices, dependency graphs, the works. A colleague asked me to walk her through one of the sections. I opened the doc and read it like a stranger. The argument was mine. The voice was mine. I could not remember writing the third bullet under the second tradeoff. Not the substance. Not the framing. Not even the meeting where it would have come up.

That has never happened to me before.

I have been doing this for thirty years. TCP stacks in the 90s. Frame Relay, ATM, MPLS through the early 2000s. CCIE work that required me to hold packet flows in my head with the kind of precision you cannot fake. I used to read my own writing and feel the muscle memory of each sentence. The choices I made. The ones I rejected. The fights I had with myself before settling on a phrase.

Now there is just the output. Polished. Sharp. And weirdly foreign.

What I have actually gained

Let me put numbers on this before I get philosophical, because I owe my readers that much.

PRDs that used to take me a week now take half that time. Roughly 2x improvement, and I am not counting the ones I never would have written in the first place because the activation energy was too high. Last quarter I wrote four PRDs that I would have punted to next quarter in the old world. Two of them became real products. The agent did not write them. I wrote them. But the agent absorbed the friction that used to convince me to defer the work.

Prototypes have moved from concept to working artifact inside a single afternoon. I built a probabilistic risk simulator in three hours last month that would have taken a week of evening work before. Not because I cannot code. I can. The friction of recalling syntax, looking up library signatures, debugging the first lazy implementation, all of that used to consume time that now goes to thinking about the problem itself.

Team velocity is the part that surprised me most. My engineers ship more, but they also collaborate more. The agent absorbs the kind of low-grade friction that used to sit between people. The senior engineer no longer holds the junior hostage on syntax questions. The junior no longer waits two days to get unblocked on a Kubernetes annotation she could have figured out herself with a willing partner. The agent is the willing partner. Standups feel different now. So do reviews. The conversations have moved up the abstraction stack and the team is doing more of the work I used to think only the most senior people could do.

Coding has been democratized. I mean that without irony. A product manager on my team who has never written production code shipped a Python script last week that pulled GPU utilization data from three OCI tenancies and built a comparison dashboard. She did not need me. She did not need anyone. She had Claude.

So the productivity story is real. I am not interested in pretending otherwise.

The unease

Here is what I cannot shake.

When I write a PRD with an agent, I do not struggle. I describe what I want, I argue with the draft, I push back on three or four sections, and the artifact appears. The struggle has been outsourced. And the struggle is the thing that used to build the understanding.

I cannot remember the third bullet under the second tradeoff because I never wrote it the way I used to write. I directed it. I curated it. I did not think it into existence.

This is the difference between cooking a meal and ordering one with very specific instructions. Both end with food on the table. Only one of them teaches you how to cook.

What the research actually says

I went looking for data because I do not trust my own anecdote. What I found is more unsettling than I expected.

The MIT Media Lab ran an EEG study published in mid-2025 with 54 participants writing SAT essays in three groups. ChatGPT users. Search engine users. And a group with no tools at all. They measured neural connectivity across 32 brain regions over multiple sessions.

The ChatGPT group showed the weakest brain connectivity of all three groups. Some metrics showed up to 55 percent lower cognitive engagement compared to the brain-only group. The pattern got worse over time. By the fourth session, ChatGPT users were copy-pasting outputs they could not even paraphrase. They reported low ownership of their own essays. When asked to quote their own work back, they failed.

The most haunting finding came from the crossover. When ChatGPT users were forced to write without the tool in a later session, their brains did not snap back to baseline. They showed sustained underactivation in the prefrontal regions associated with executive function. The deficit persisted. The lead author called it cognitive debt.

Cognitive debt. That is the phrase I cannot stop thinking about.

The Microsoft Research and Carnegie Mellon paper published at CHI 2025 surveyed 319 knowledge workers across 936 real-world AI-assisted tasks. The pattern matches. Higher confidence in the AI tool predicted lower enaction of critical thinking. The work shifted from material production to critical integration. From thinking to verifying. From building to refining.

The researchers cite Bainbridge’s old irony of automation, which I had forgotten about until I read this paper. The argument goes back to 1983. When you automate the routine parts of a task and leave humans with exception handling, you remove the very practice that builds the judgment needed to handle the exceptions. The automated worker becomes less competent over time at exactly the work the automation cannot do.

On the coding side, the picture is mixed but more pointed than the cheerful press releases suggest. GitHub’s own studies show 55 percent task completion improvements and high developer satisfaction. ANZ Bank reported 42 percent productivity gains in a controlled six-week experiment. The Communications of the ACM piece confirmed the largest gains go to junior developers, which sounds great until you read the followup work. One enterprise study found that less-experienced developers showed 28 percent lower performance in algorithmic problem-solving when tested without AI support after six months of continuous Copilot use.

Twenty-eight percent. After six months. The skill did not just plateau. It receded.

The two-year question

If you took the agent away from me tomorrow, I would still ship. I have thirty years of pattern recognition in my head. I still know what a good architecture looks like. I still know how a TCP retransmission storm feels in the logs. The crutch metaphor is not quite right for me because the legs underneath are real.

But what about me in two years.

If I keep going at this rate, with the agent doing the cold start on every PRD, every code review, every architectural sketch, what happens to the part of me that used to do that work. The MIT data suggests it does not just stay quiet. It gets quieter. The neural pathways that used to fire during composition show measurably less activity in the people who lean on the tool. The brain does what biology rewards. It conserves energy. The pathways you stop using are the pathways you lose.

I do not know if I will still be able to write a PRD from scratch in 2028. I think I will. I am not sure. That uncertainty did not exist two years ago.

There is also a different question buried here, which is about the engineers I am training right now. My twenty-five year old solutions architect has never written a non-trivial system without an agent in the loop. He is excellent at the work he does. He ships. He thinks well at the level he operates. When I ask him to debug something at the level below the abstraction the agent presents, he stalls in ways I did not stall at his age. He is not less intelligent than I was. The opportunity to develop those reflexes simply did not exist in his environment.

I am not nostalgic about the suffering of learning the old way. I do not want my engineers to memorize the OSI model the way I did, byte by byte, on physical Cisco gear in a freezing lab. But I am watching a topology shift in how skills form, and the people at the bottom of the new topology will not develop the same kind of structural understanding the people at the bottom of the old one did.

That is not a feature problem. That is a topology problem.

My own honest take

I asked Claude to give me an opinion here, in my voice. It said something that landed harder than I wanted it to.

The productivity gains are real and the cognitive debt is also real and both things can be true at the same time. Whether to use the tool is the easy question. What the tool is replacing in you is the harder one. The answer is different on different days. For me it is different on different tasks.

When I use the agent to work on a domain I already understand, I learn faster and retain more. The agent is a partner. When I use it on a domain I do not understand, I sometimes finish the task with the illusion of understanding and no actual model in my head. The illusion is dangerous because it travels with confidence. I sound smart in the meeting. I write a convincing memo. I cannot answer the second question.

The Microsoft paper picked this up too. The workers with high confidence in the AI did less critical thinking. The workers with high confidence in themselves did more. Self-confidence in this context is not arrogance. It is the willingness to suspect the output and push back on it. That muscle is the one that atrophies fastest when you stop using it.

I am pushing back less than I used to. That is the part that scares me.

What I am doing about it

I have started doing what I think of as cold writes. One PRD a month, by hand. No agent. No autocomplete. Just me and the empty page. The first one I did was painful. I had forgotten how slow I actually am. The second one was better. The third one felt like it always used to feel, which is to say, hard but mine.

I am also imposing what some teams are calling Copilot-free Fridays for myself on Tuesdays, because Friday is for shipping. One full day a week where I write code the slow way. Debug the slow way. Read documentation the slow way. The output of those days is worse. The retention is better. I remember the failure modes I encountered. I remember the dead ends. I remember why I made the choice I made.

I do not know if this is enough. I do not know if it scales to my team without becoming theater. I am running it as an experiment on myself for the next quarter and we will see.

The closing question

I keep coming back to one finding from the MIT paper. The ChatGPT group reported the lowest ownership of their own work and one of the highest satisfaction scores. They felt good about output they could not even remember writing. They were pleased with words that had passed through them without leaving a mark.

Am I enjoying the lobotomy with a monthly fee?