Gone. Just gone. Two weeks of work. Gone to waste? Two min­utes ear­li­er I had been per­fect­ly hap­py. The new fea­ture worked on the first try. Exact­ly the way I’d described it. I clicked through the appli­ca­tion one more time, just out of habit, and sud­den­ly stopped. Two fea­tures that had been work­ing flaw­less­ly for weeks were gone. Not bro­ken. Just gone.

So I start­ed dig­ging: com­par­ing files, trac­ing changes, restor­ing old­er ver­sions from back­ups. Prob­a­bly half an hour of extra work. It wasn’t the first time this had hap­pened. And every time I found myself ask­ing the same ques­tion: How can an AI delete some­thing it should already know exists?

The answer is sur­pris­ing­ly mun­dane. It also says a lot about what work­ing with tools like Chat­G­PT or Claude is actu­al­ly like. Most peo­ple prob­a­bly imag­ine an AI work­ing on a soft­ware project the way anoth­er devel­op­er would. It knows the cur­rent state of the code, adds new fea­tures, sug­gests improve­ments. It remem­bers what already exists, what deci­sions have been made, which mis­takes have already been fixed.

But that’s not real­ly what hap­pens. The AI isn’t work­ing on the soft­ware itself. It’s work­ing only on the slice of it it can cur­rent­ly see. There isn’t a project fold­er sit­ting open in front of it. Every response is built from what­ev­er con­text is avail­able at that moment. If an ear­li­er change isn’t part of that context—or if an out­dat­ed ver­sion of a file becomes the ref­er­ence point—the AI may imple­ment the new fea­ture with great care, but on top of an old­er foun­da­tion. It looks as if some­thing was delet­ed. In real­i­ty, that infor­ma­tion sim­ply wasn’t part of the world the AI was work­ing from anymore.

The Problem Isn’t Memory. It’s Context.

Over the past few weeks, I’ve run into sit­u­a­tions like this more times than I can count. I’ve been using Chat­G­PT to build two web apps. Both grew out of the same idea: cap­ture things before mem­o­ry qui­et­ly edits them. Dots col­lects the small sig­nals from my train­ing days—sleep, work­load, recov­ery. Shots does the same for cof­fee. Nei­ther app tries to make deci­sions for me. They help me make bet­ter ones. Plan my train­ing with more con­fi­dence. Turn my morn­ing cof­fee rit­u­al into con­sis­tent­ly bet­ter coffee.

So how do you deal with these pit­falls? How do you stop the AI from intro­duc­ing errors, remov­ing fea­tures, for­get­ting pre­vi­ous work?

Even­tu­al­ly I real­ized the real prob­lem wasn’t the code. It was the collaboration.

A few months ago, I assumed I’d sim­ply be giv­ing tasks to an AI. Instead, I had to learn how to work with one. And like any col­lab­o­ra­tion, hav­ing a shared goal isn’t enough. You also need a shared real­i­ty. Peo­ple build that almost auto­mat­i­cal­ly. We remem­ber ear­li­er deci­sions. We know the back­sto­ry. We remem­ber why that seem­ing­ly unnec­es­sary excep­tion exists. We rely on sig­nals beyond language—facial expres­sions, ges­tures, rou­tines, shared short­hand. An AI only knows what I give it, over and over again. That changed the way I work.

From Prompting to Collaboration

At first, my prompts sound­ed some­thing like, »I’ve got an idea for anoth­er fea­ture. Please add it.« Now they’re much clos­er to this: »Only change this func­tion. Every­thing else must stay exact­ly as it is. Here’s the cur­rent ver­sion of the rel­e­vant files.« I work in much small­er steps. I check inter­me­di­ate results more often. I leave less room for inter­pre­ta­tion. Not because the AI has become worse. Because I’ve become bet­ter at under­stand­ing how it works.

There was anoth­er les­son, too. Good prompts help. Good spec­i­fi­ca­tions mat­ter far more. At some point I start­ed doc­u­ment­ing the fun­da­men­tal deci­sions behind Dots and Shots. The log­ic behind indi­vid­ual cal­cu­la­tions. Why a fea­ture behaves the way it does. Which rules must nev­er be changed. The dif­fer­ence was imme­di­ate. The AI made far few­er mis­takes. Not because it knew more, but because I left it with less to guess.

The sur­pris­ing part is that the longer I worked on these two appli­ca­tions, the less it felt like pro­gram­ming. Not just because much of what they con­tain is code I couldn’t have writ­ten myself. More and more, it felt like coor­di­nat­ing a very small team. I had to doc­u­ment knowl­edge. Make deci­sions trace­able. Spot mis­un­der­stand­ings. Set pri­or­i­ties. Make sure one change didn’t qui­et­ly break some­thing some­where else. The only unusu­al thing about that team was that it had exact­ly two mem­bers: me and an AI.

That may be the biggest les­son I’ve tak­en away from the past few weeks. For me, AI isn’t pri­mar­i­ly chang­ing pro­gram­ming. It’s chang­ing col­lab­o­ra­tion. Get­ting good results has less to do with find­ing the per­fect prompt than with cre­at­ing con­text, mak­ing deci­sions explic­it, and orga­niz­ing com­plex­i­ty so that some­one new—or some­one artificial—can find their way through it.