The New Mantra

The ceiling fan above my desk has settled into a loose, uneven rhythm, fast enough to move the monsoon air but not fast enough to make it lighter. It is the first day of July, 2026, in Calcutta. The rain has come down with that particular confidence it gets after the city has already surrendered. The balcony rail is wet. The laptop is warm. My fingers leave a faint dampness on the keys, and on the screen Claude Code is thinking through a problem that, ten years ago, would have kept me pinned to the chair for half a day.

The interface is cheerful about it. Too cheerful, perhaps. It tells me what file it is reading, what test it is considering, what change it proposes to make. Sometimes it uses a strange little verb for its internal activity, as if the machine is not calculating but bustling around the room with papers in its hand.

I watch it work.

This is the part that still feels wrong.

Three years ago, I used GitHub Copilot mostly as an autocomplete with occasional ambition. It would finish a line, suggest a helper, guess the shape of a function. Sometimes it was useful. Sometimes it was confident nonsense. But it stayed in its place. I was still the person holding the map. I still had to know what the function was for, where the data entered, what could break, and how a small mistake in one file could turn into a large inconvenience somewhere else.

That older arrangement suited my vanity, but it also suited the work. Programming was not merely producing text in a formal language. It was the slow formation of a mental model. You held the system in your head badly at first, then less badly, then well enough to know which part of it would complain when touched. The craft was not glamorous. It was reading, tracing, testing, forgetting, remembering, and occasionally staring at a block of code until the mistake rose from it like a submerged object.

Now the tools no longer behave like suggestions. They behave like junior colleagues who have read the whole repository faster than you can make tea.

They search. They plan. They edit. They run commands. They explain their own changes. They apologize when they misunderstand and then misunderstand in a more sophisticated way. They are useful in a manner that is difficult to dismiss and difficult to accept without unease. A model can find a missing import, untangle a broken test, propose a migration, draft documentation, and refactor a file with the clean patience of something that does not feel the afternoon heat.

The new mantra is not “learn to code.” It is “learn to tell the machine that codes what to do.”

That sentence sounds efficient. It also sounds like a trap.

I do not mean this as nostalgia for hardship. I have no moral attachment to typing boilerplate by hand. I do not miss hunting through documentation for a method name I almost remembered. I do not miss brittle build systems or silent dependency failures or the particular humiliation of spending forty minutes on a bug caused by one wrong character. If an assistant can do the boring work, let it. If it can catch a typo, write a test, or suggest a cleaner interface, I will not stand in the doorway defending drudgery as character formation.

But the boring work was never only boring.

Repetition is one way the mind learns texture. You write the same kind of query enough times and eventually you notice what an awkward schema is trying to hide. You debug enough state management and you begin to sense when the application is lying about where truth lives. You trace enough errors through a stack and the stack becomes less like a tower and more like a neighborhood. There are shortcuts, bad roads, familiar corners, and one lane you avoid unless absolutely necessary.

AI coding tools threaten that texture by making the surface too smooth.

A prompt can now leap over the friction where understanding used to grow. I can ask for a feature and receive a plausible implementation before I have fully decided what the feature means. I can ask for tests and get a neat file of assertions that look sensible in the quick light of the editor. I can ask for a performance improvement and receive a confident patch with the rhythm of expertise. The code may even work.

That is the difficulty. Bad tools are easy to resist. Good tools enter the bloodstream.

I have begun to notice the change in myself. When I ask the agent to write a function, I can usually read the result. I can follow it. I can nod. But the knowledge is thinner. It has not passed through the hand. It has not acquired the memory of false starts. I know what the function does in the same way one knows a building by looking at its front gate. Enough to enter. Not enough to know which wall is carrying weight.

This is not a spiritual objection. It is practical.

Software breaks at the point where no one has a living model of it. Documentation helps, but only up to a point. Tests help, but tests are also written from assumptions. Architecture diagrams help, but diagrams age faster than buildings. Somewhere, a human being still has to understand why this module exists, why this edge case matters, why an apparently ugly piece of code was left ugly because the clean version broke something important.

If the human gives up that duty too early, the system may continue to grow while the understanding of it shrinks.

Calcutta is a good city in which to think about this because nothing here lets you forget infrastructure. In the rain, every hidden decision becomes public. Drains reveal their politics. Roads remember their repairs. A low patch of pavement becomes a map of municipal compromise. The city works not because it is cleanly designed but because a million small adjustments keep it from stopping altogether.

Old software is like that. A codebase accumulates patches, workarounds, conventions, quiet prohibitions, and comments written by people who have long since moved on. It has alleys. It has private weather. It has parts everyone uses and parts everyone fears. When an AI agent enters such a system, it sees text, patterns, imports, tests, names, and probable intention. That is powerful. It is not the same as institutional memory.

The agent can be astonishingly good at local correctness. It can make the small neighborhood tidy. The danger is global amnesia. A change can be beautiful inside one file and foolish across the life of the product. A refactor can make a function read better while weakening an old guarantee no one had written down. A test can pass because it proves the wrong comfort.

In the older style of programming, slowness forced a little humility. You had to sit with the problem long enough to become irritated by your first idea. That irritation was useful. It made you ask whether the variable name was hiding a concept, whether the abstraction was premature, whether the request itself was badly formed. With AI, the first idea arrives dressed as a completed patch. It is harder to feel the gap between request and understanding when the screen is already full of answers.

There is a new social shape forming around this. Some people call it vibe coding. Some call it agentic engineering. The names keep changing, as names do when an industry is trying to convince itself it has found the future and not merely a faster way to create new classes of maintenance. The underlying movement is clear enough: the programmer becomes less like a bricklayer and more like a director, less like a writer of lines and more like an editor of machine-generated possibility.

That may be the correct direction. I am not pretending otherwise.

There are days when the new arrangement feels like freedom. A dull migration becomes manageable. A test suite stops being a moral burden. A half-remembered API can be explored without opening twenty tabs. The machine is tireless, and tirelessness has value. It lets a tired human stay with the larger question. Sometimes it even restores energy by removing the gravel from the road.

There are also days when it feels like a quiet deskilling disguised as power.

I think of the programmers who are entering the field now. Their first experience of code may not be the blank file, the error message, the small victory of making a loop behave. It may be a chat box that turns intention into implementation. They may become fluent in orchestration before they become fluent in the material. Perhaps that is enough. Perhaps the material is changing. Perhaps a future programmer will look at my concern the way I look at someone worrying that high-level languages ruined the nobility of assembly.

That possibility keeps me cautious. Every generation mistakes its habits for fundamentals.

Still, there is a difference between moving up a level of abstraction and losing contact with consequence. SQL did not remove the need to understand data. Garbage collection did not remove the need to understand memory pressure. Frameworks did not remove the need to understand the request lifecycle. AI assistance will not remove the need to understand software. It will only make misunderstanding easier to ship.

So I am trying to develop a smaller, less dramatic discipline.

I let the agent help. I also make myself read the patch line by line. I ask why a change is necessary, then check whether the explanation matches the code. I write small things by hand when I feel myself becoming lazy in the wrong way. I keep notes. I run the tests myself. I distrust summaries. I treat generated code as a clever draft, not as a verdict. None of this is heroic. It is maintenance of the self as much as maintenance of the system.

There is no clean boundary here. On one side, useful assistance. On the other, dependency. The line moves depending on fatigue, money, deadlines, curiosity, and fear. Anyone who says the answer is obvious is probably selling something, even if the product is only certainty.

The rain has softened now. The fan continues its uneven circles. On the screen, the assistant has finished proposing a change that is, annoyingly, better than the version I had in mind. I will read it. I will test it. I may use most of it.

But before I do, I put my hands back on the keyboard and type one small function myself, slowly, almost unnecessarily, just to remember the weight of the keys.