A Title in Rainbow Gradient

Some parts of this essay are imagined; yet the feelings and events it depicts are not conjured out of thin air. As for the “friend” in the story, he is no single individual, but an amalgam of several companions whose words and deeds have been woven together.

That afternoon, a message arrived on my screen.

“Come, have a look at my website!” My friend’s exuberant text was followed by a link. The moment I clicked, a rainbow struck my retinas—an unbroken sweep from red to violet, across which the four bold words “Quantum Physics Research Group” gleamed as though they might burst free of the monitor and take flight.

He is a doctoral candidate in physics, his days consumed by equations, simulations, and data analysis. In his universe, every parameter carries a physical meaning; yet in the realm of code, he is like an explorer clutching a map he cannot read.

“AI wrote it for me,” he declared with pride. “Pretty cool, isn’t it?”

I fell silent before the 1,800‑line TSX file onscreen. In some parallel cosmos, perhaps there exists a programming creed that deems placing all code in a single file the height of elegance. In ours, it is catastrophe.

The tale begins months earlier. Their laboratory possessed a venerable computational code, reputedly written long ago by a researcher now departed. Its variables—XX1, XXX, XXXX2—were hieroglyphs; altering a single digit rendered the simulation unrecognisable. He alone still maintained that code—or, more precisely, was the only one who dared touch it.

“I asked Gemini to explain the script,” he told me. “It suggested it might be a modified TEBD algorithm.”

“Suggested?”

“Then I asked Claude to rewrite it in Python. It ran ten times slower.”

Thus, he persisted with the code no one understood, occasionally pondering the AI’s exegesis like an archaeologist gazing at pictograms, divining ancient intent.

We approach AI in diametrically opposite ways. He grants the model free rein, as though giving an eager assistant limitless room to improvise. I, by contrast, resemble a meticulous conductor intent on controlling every note.

“Write a function to compute the distribution of a physical field,” he will say. Then he waits serenely while the AI unfurls an entire simulation framework—from file I/O to 3D visualisation, nothing omitted.

My prompt sounds more like this: “Given a parameter fields of type Array<PhysicsField>, return a DistributionMap. Provide only the function body: no declaration, no comments, no error handling.”

The terminal’s most frequent message is not code but a line in red:

⎿ Interrupted by user

I strike Esc so often that the keycap has grown loose. The instant the AI begins to scaffold a project, I interrupt it; when it thoughtfully appends error handling, I interrupt again; when it tries to install dependencies with pip, my third Esc reminds it I specified uv.

“Why do you keep stopping it?” my friend once asked, baffled.

“Because it keeps doing things I didn’t ask for.”

“But it’s helping you.”

“I don’t need that kind of help.”

The contrast pervades our workflows. He is disarmingly direct: conceive an idea, tell the AI, await the miracle. If the model says Three.js is needed, he installs Three.js; if it recommends three vector databases, he installs all three. He trusts each suggestion as implicitly as he trusts physical law.

Mine is far more circuitous. I begin with an hour‑long architectural debate, interrogating every design decision: “Why this pattern?”, “Is there a simpler approach?”, “Doesn’t this verge on over‑engineering?” When the discussion ends, I spend another hour pruning the generated design document, excising all superfluity. In actual coding, the only AI feature I fully rely on is doc‑string autocompletion.

Then his adviser set him a new task: build a website to showcase their research. “Make it modern,” the professor said, “and integrate ChatGPT so visitors can ask questions.”

Naturally I offered help. “Use React,” I suggested. “TypeScript, Next.js, Tailwind CSS—these are the stacks AI knows best.” I even congratulated myself for not recommending my own recent favourites—Bun, Preact, Astro, UnoCSS. AI’s scant acquaintance with those tools would have driven it back to the old npm rituals.

A month later, he sent me the code.

The first file was 1,800 lines. I assumed that was everything, until he added, “That’s just the troublesome component—the main file exceeds 3,000.”

In that moment, silent is Cambridge tonight¹.

Within his code I glimpsed the other face of AI‑assisted programming. Every question received a solution; every solution accreted hundreds of lines. The code multiplied like bacteria in a petri dish. He integrated three vector databases, not from necessity but because “Claude suggested trying them all.” He implemented a full RAG pipeline without knowing what RAG stands for.

Were it me, I would spend three days disputing with the AI whether a vector database was needed at all, then another week reviewing the generated code line by line, excising abstractions I judged gratuitous. The final system might be minimalist, but the process would resemble Sisyphus eternally managing minutiae.

“chunk_size—what value should I set?” he once asked.

“What’s a chunk?” came his next question.

I recalled a network‑theory course in which we were forced to use an illustrious lab’s ancient Python‑2 package—tending a v2.7 environment in 2023. We have all, in some measure, suffered the same agony: wrestling with tools beyond our discipline. He chose trust; I chose control.

Yet he seemed delighted. Whenever the AI produced a new component, he would eagerly show it to me. Those high-saturation palettes, misaligned text, and restless animations were, to his eyes, the very emblem of modernity; to mine, a visual catastrophe.

Once I tried to demonstrate my method. We sat together as I opened the terminal and typed a carefully honed prompt. The AI began to respond, and I instantly hit Esc. A second attempt—Esc again. A third—still Esc.

“What is it you actually want?” he asked, exasperated.

“I want it to do only what I say.”

“But you haven’t let it finish anything.”

“Because it keeps doing more than I ask.”

He looked at me exactly as I looked at his 3,000‑line component—utterly perplexed.

“Try shadcn/ui,” I pleaded. “Just don’t let the AI keep writing.”

“But it looks so plain,” he protested. “Can we add some colour?”

A week later, he duly bestowed a gradient upon the shadcn components.

Perhaps this is the lot of our generation of researchers. None of us are professional programmers, yet all must wrestle with code. He treats AI like an impromptu jazz session—replete with surprise and mishap. I treat AI like a precision experiment—each variable is tightly governed. His code is a Tower of Babel: grand, but trembling; mine, a delicate instrument: efficient, yet bereft of imagination.

In the end, the site went live. The rainbow gradient remained, though at least the font was no longer grotesquely bold. The page displayed data correctly, and visitors could query the AI, though its replies were often wholesale excerpts from papers. The professor pronounced himself pleased: “Very high‑tech.”

And I? I was still sparring with the model. Yesterday I spent two hours convincing it to use fd instead of find. “I spelled it out,” I muttered to the screen, fingers hovering once more above Esc.

Deep into the night, we continue to trade tales of meltdown over chat. When he sends a fresh screenshot of his code, I have learned to breathe first. When I complain that AI has again ignored my instructions, he says, “Why not let it improvise?”

“No,” I answer firmly. “That way lies your 3,000‑line component.”

“What’s wrong with 3,000 lines? It runs, doesn’t it?”

“Running and maintainable are two different things.”

“No one’s going to maintain it anyway.”

To that, I have no reply.

In this era, when AI can write code, we each interpret technology in our own fashion. His approach may be too permissive, mine too controlling, but what of it? We have both completed our research, both satisfied our advisers, and both still brood over code at midnight.

After all, somewhere in a parallel universe, there may exist a perfect way to use AI. In ours, there is only the rainbow‑gradient title, and an Esc key that can never be pressed enough.

As for the AI, it is doubtless pondering in some distant server rack: between the human who forever says “just write whatever” and the one who forever says “write it again,” which of them is harder to serve?