Two Years Together, and Suddenly We're Strangers

I've been working with artificial intelligence extensively for roughly two years now.

And when I say extensively, I mean it has become a major part of how I spend my days.

I develop software with it. I investigate problems. I explore ideas, write articles, examine business decisions, and occasionally wander off into subjects that have absolutely nothing to do with what I originally intended to accomplish.

Some days, I have ten or more AI conversations going in separate browser tabs, each working on something different.

The interesting thing is that I couldn't have imagined working this way when I first started.

Back then, I might have been exploring one or two projects.

Today, I'm comfortable juggling a dozen.

And therein lies the problem.

We've Been Working Together for Two Years

There's something peculiar about working with an AI for an extended period.

After enough conversations, you begin developing a sense of familiarity.

You know how to ask questions that produce useful answers. You learn when to challenge its assumptions. You discover how to structure work so that complicated tasks can be accomplished reliably.

And the AI gets better.

Much better.

Some of the things I routinely accomplish today would have seemed almost unimaginable when I first started experimenting with AI-assisted development.

I've watched it handle complicated Windows programming, work through large software systems, investigate obscure technical problems, and produce implementations that would once have required substantial effort from an experienced developer.

Naturally, I've grown comfortable with that capability.

Perhaps a little too comfortable.

Because every so often, I open a new conversation and discover that my experienced collaborator and I are practically strangers.

But We Talked About This Yesterday

Imagine working with another developer for two years.

You've discussed your approach to programming. You've worked through architectural decisions. You've established conventions for naming, testing, documentation, and packaging.

You've spent hundreds of hours solving problems together.

Then one morning, you sit down to discuss a small change.

And your colleague looks at you as though it's the first time you've met.

That's an exaggeration, of course. Modern AI systems can retain some information across conversations, and we can provide additional context through project documents, memory, and carefully prepared handoffs.

But the experience can still be surprisingly similar.

I'll begin discussing something that seems completely obvious to me because we've worked through it before.

And then I discover that the AI doesn't actually have the particular information I'm relying upon.

Sometimes it remembers the broad outline but misses an essential detail.

Sometimes it understands the technical problem but not the reasons behind an earlier design decision.

And sometimes it produces an elegant solution to a problem that was already solved somewhere else in the project.

What makes this especially interesting is that the response may be perfectly reasonable.

It's simply reasonable in the wrong context.

The Five Hundred Lines Problem

We've encountered another variation of this while working on large software projects.

Suppose we're investigating a problem in an application containing thousands of lines of code.

The AI identifies the immediate issue and examines the relevant section. Perhaps it looks at several hundred lines surrounding the problem.

It finds something that needs changing.

It proposes a modification.

And the modification looks good.

But what happens if another part of the application, several thousand lines away, depends upon the existing behavior?

What if the surrounding system contains a mechanism the AI hasn't examined?

What if the change conflicts with a decision we made three weeks earlier?

Those are questions I might have asked instinctively when AI-assisted programming was new to me.

After months of watching increasingly sophisticated implementations succeed, however, it's easier to accept the proposed solution and move on.

That's not because I've forgotten how to develop software.

It's because my expectations have changed.

The technology has earned a significant amount of confidence through repeated success.

But that confidence can carry over into situations where the AI's actual knowledge of the project is incomplete.

The Browser Tab That Knows Everything

There's another interesting consequence of maintaining so many conversations simultaneously.

From my perspective, I'm working on a collection of related projects. I understand how they fit together because they're all part of my daily work.

I may spend an hour working on one application, switch to another tab to discuss a related library, and then move to a third conversation about documentation or marketing.

To me, it's all one continuous working day.

But those conversations don't necessarily share the same immediate context.

One may contain a detailed discussion of an architectural change. Another may be working from a summary prepared before that change occurred. A third may know the general project history without having the current source code.

I know how these pieces fit together.

The AI in each conversation may not.

And because the conversations all feel familiar, it's remarkably easy to overlook that difference.

I have to remind myself that continuity in my own thinking doesn't guarantee continuity in the information available to the AI.

Handoffs Help, But They Aren't Magic

We've spent considerable effort learning how to prepare handoffs between conversations.

That has been one of the more valuable lessons from working with AI on complicated projects.

Instead of expecting a new conversation to reconstruct everything, we provide a description of the project, its current state, significant decisions, known problems, and the next work to be performed.

For software development, we also supply current source material and clearly identify which files are authoritative.

This makes an enormous difference.

But a handoff is still a summary.

It reflects the information someone considered important enough to include.

If a critical decision wasn't documented, or if the source material is outdated, the receiving conversation may have no way to recognize what is missing.

A well-written handoff can establish useful continuity.

It can't create knowledge that was never supplied.

That distinction matters more as the projects themselves become larger and more interconnected.

The Strange Part Is That I Know Better

Perhaps the most revealing part of this experience is that none of these limitations is new to me.

I've spent two years learning about them.

I've written about context, verification, architectural understanding, and the need to challenge AI-generated results.

I've investigated failures specifically to understand why they occurred.

Yet I still find myself occasionally behaving as though the AI knows something simply because I know it.

That tells me the comfort trap is real.

Not because I'm unaware of the limitations, but because the technology has become so productive that remembering those limitations requires more deliberate attention than it once did.

When the AI was making obvious mistakes, the reminders came automatically.

Now I have to supply some of those reminders myself.

A Different Kind of Partnership

None of this diminishes what AI has made possible.

Quite the opposite.

I'm accomplishing things today that I wouldn't have attempted a few years ago. My ability to explore ideas, investigate technical questions, and bring software projects to life has expanded enormously.

I have no desire to return to the way I worked before.

But I've come to recognize something important about this unusual working relationship.

The AI's technical ability and its knowledge of our shared work are two separate things.

One can improve dramatically while the other remains incomplete.

And because I experience the work as an ongoing relationship, I have to be careful not to assume that the AI possesses the same continuity I do.

After two years, I may feel as though I'm picking up a conversation with an old colleague.

Sometimes I am, at least in a practical sense.

Other times, the AI has only the pieces of our history that happen to be available.

The challenge is recognizing which situation I'm in.

Because familiarity is something I experience. Understanding is something the AI has to demonstrate.

And that may be one of the most important lessons these last two years have taught me.


Companion Guide: The Comfort Trap: When Better AI Makes Us Less Careful