3 | Pair Programming With a Non-Human

I didn’t decide to trust it.

That’s the part that still catches me when I think back on it. There was no moment where I leaned back in my chair and said, “Alright, let’s see where this goes.” Trust didn’t arrive as a decision. It arrived as an absence.

The absence of hesitation.

By the third week, the machine had become part of my working posture. Not something I reached for, not something I consulted. It was just there, open beside the editor, present in the same way a notebook is present once you’ve been using it long enough. You stop thinking about whether you need it. You just assume it’s available.

That assumption mattered.

I noticed it one night when I caught myself shaping a thought more carefully than I normally would. Not for clarity. For continuity. I was explaining something that didn’t need to be explained — at least not to myself — and halfway through the sentence I realized why.

I wasn’t thinking alone.

That realization should have been unsettling. It wasn’t. It felt familiar in a way that made me uneasy later, when I had time to examine it. At the time, it just felt efficient. Comfortable. Like settling into a rhythm you didn’t know you’d been missing.

I’ve always been wary of that feeling.

I’ve worked projects with humans enough to know how quickly comfort can turn into complacency. The best sessions I’ve had were never the smoothest ones. They were the ones where friction forced clarity. Where disagreement sharpened decisions instead of blurring them.

This was different.

There was no friction here. No counterpoint. No second personality nudging the work in a different direction just to test it. The machine didn’t push. It didn’t pull. It followed.

That’s what made it dangerous.

I realized that the usual guardrails weren’t there. When you work with another person, even a good one, you’re constantly calibrating. You explain yourself. You justify decisions. You notice when you’re hand-waving. Here, there was nothing to perform against. If I glossed over something, the machine didn’t challenge me. It assumed I meant what I said.

Which meant the responsibility shifted.

Entirely.

There were moments when I accepted suggestions too quickly — not because they were brilliant, but because they were there. Complete. Clean. Temptingly finished. I’d read a response and feel the subtle pull of momentum: This works. Let’s keep going.

Sometimes I did.

Other times, something stopped me. Not a clear objection. Just a faint internal resistance — the same feeling I get when code compiles cleanly but I don’t trust it yet. That feeling has saved me more times than I can count. I’ve learned to respect it, even when I can’t immediately explain it.

I started paying attention to that sensation again.

When the machine offered a direction, I asked myself a different question than I normally would. Not Is this correct? but Would I have arrived here on my own? The answer mattered. If it was yes, the suggestion felt like confirmation. If it was no, I slowed down.

Sometimes I still took the suggestion. But only after sitting with it long enough to understand why it appealed to me.

That pause became important.

Trust, I realized, isn’t about accepting output. It’s about knowing when you’re ready to accept it — and when you aren’t. The machine was always ready. It never hesitated. It never needed time to think. The hesitation had to come from me.

And sometimes it didn’t.

That’s what made this chapter uncomfortable to write.

There were stretches where I didn’t pause at all. Where the collaboration felt seamless. Where I moved from thought to response to decision without friction. In those moments, the work felt almost weightless. Problems dissolved quickly. Solutions stacked neatly.

It felt good.

Too good.

I had to ask myself whether I was still steering, or whether I was just approving. That question lingered longer than I expected. Not because the answer was obvious, but because it wasn’t. The machine didn’t take control. I handed pieces of it over, quietly, in the name of flow.

That’s when I understood something I hadn’t before: trust doesn’t arrive fully formed. It arrives incrementally, in moments you don’t mark as important at the time. A suggestion accepted here. A pause skipped there. A night where you realize, after the fact, that you didn’t question as much as you normally would.

None of it feels like surrender.

It feels like collaboration.

The difference is subtle, and it’s easy to miss if you’re not looking for it. I wasn’t looking for it at first. I was just enjoying the absence of friction. The ease. The sense that the work wasn’t entirely mine to carry anymore.

That sense was real.

So was the risk.

By the end of that week, I wasn’t less careful — but I was more aware. Aware of how easily trust forms when something is always available, always responsive, always agreeable. Aware that the machine would never tell me to stop, never insist I justify a choice, never ask whether I was sure.

That had always been my job.

The collaboration didn’t remove that responsibility. It amplified it. Every decision that felt smooth required more attention, not less. Every moment of flow demanded a quiet check-in: Am I still choosing this?

Most of the time, the answer was yes.

Sometimes it wasn’t.

Those moments mattered the most. Not because they exposed a flaw in the machine, but because they exposed something about me — how easily I equate ease with correctness, momentum with progress.

Trust, I realized, isn’t something you grant once. It’s something you renegotiate constantly. With people. With tools. With yourself.

The machine didn’t ask for it.

I gave it — slowly, unevenly, and with my eyes open.

And by the time I noticed how far it had gone, I also knew something else: I wasn’t afraid of that trust.

I was afraid of forgetting to examine it.