Connecting Agile Origins to Modern AI Collaboration
AI as the realization of the old dream of pair programming, as written by Bryan DinaPair Programming, Reimagined
When I was studying Computer Science in the late 1990s as a twenty-something, pair programming was the hot new idea: two developers sharing one keyboard. The concept promised a revolution in collaboration but it never really scaled. Most teams couldn't justify doubling their headcount just to write code together. And just like that, as quickly as college ended for me, so did pair programming.
Two decades later, I am pair programming again -- this time with AI -- and I am loving it. It feels like having a partner who's always available and never needs a coffee break (though I sure still do!).
This is the story of how that happened, not all at once but through an evolution.
Chapter 1: Finding Answers Together
My story begins about three years ago. When ChatGPT first came out and I saw stories of people using it with their software projects, I wondered if it could help me with some exploration I was doing with Scala Native and GraalVM for systems programming. My build tool of choice was Gradle and, at the time, these technologies were not well-integrated into the Gradle ecosystem. Searching Stack Overflow and Reddit was difficult and slow. I had limited time outside of my professional job and a family life, so progress was intermittent.
I would ask the AI for help modifying my Gradle files to build native versions of my programs, and it would produce scripts and tweaks. Sometimes its changes were spot-on; other times it missed the mark completely. I needed to provide more context to the AI to get more reliable recommendations. More often than not, it was simply missing the right context to answer helpfully -- I had to act as a bridge to information past its static knowledge cutoff date.
AI was able to synthesize responses to my big questions quickly and at first it felt too easy. What I had come to learn however is there is an art in _prompting well_. Just as we learned how to write queries for Search Engines to return relevant results, we need to learn how to do something similar with our AI.
Gradually my workflow began to change. I stopped switching to the browser when I hit a snag. I’d stay in my editor, ask the AI, and move on. The friction of context switching — from coding to Googling to reading — started to disappear. I wasn’t just saving time; I was building continuity of thought.
Chapter 2: Building Things Together
Using AI as a fancy search assistant soon became natural, but I began to wonder if it could help me build something directly. I was working on a Monitoring plugin for OpenSearch Dashboards that required more extensive testing. I fired up ChatGPT and gave it the context of what I was building.
It could produce programs that used my HTTP API to exercise my code. As I made changes I asked AI to tweak and add new tests. It could quickly mock up requests for different scenarios and expand test coverage. It could produce code to verify correctness from the specifications I shared with it. I realized I was starting to pair program with an AI! The game was changing.
This didn’t just make me faster, it also changed how I viewed my role as a developer. My job wasn’t to hand-craft every line of code; it was to define intent, review structure, and steer quality. The AI took care of the mechanical steps, which allowed me to focus on design and logic.
While reviewing the test code, I started thinking about the process with roles reversed. I imagined giving AI the ability to run and evaluate its own output without me pasting code or applying diffs. I was starting to think of my new companion like a human being.
Chapter 3: Learning Together
Over time, the collaboration matured. I wasn’t just asking AI to write or refactor code — I was asking it to evaluate mine. To make this work more effectively, I had to integrate it more directly into my workflow.
For years, I had maintained a side project: a Scala implementation of the Constant Database (CDB) specification. It was a small but elegant piece of software I used to explore performance tuning. Once it was working I set it aside, occasionally updating it to build with newer versions of Scala. When Cursor, an AI-powered IDE, came along, I gave it direct access to my code and asked for a review:
“Find memory inefficiencies and suggest ways to improve throughput on a 4GB dataset”
Up to that point, I worked on the project in isolation, but I was curious and I wanted to take my relationship with AI to the next level. I had a benchmark test that generated a 4GB database and queried all of its keys to verify the data was stored correctly. Cursor took a look and made suggestions for some tweaks. Inlining a few things, adjusting some array initialization, not blowing things up but refining them. We were able to improve throughput by about 20% and reduced memory usage.
The experiment helped me think more deeply about algorithms and code quality. Simple concepts like inlining and array initialization are subtle when it comes to identifying where they should be placed. Yet the AI identified these subtle improvements that added up. The insights helped me build my own experience more quickly by exposing patterns drawn from a wide range of examples.
That was the moment I realized I was learning from AI. This new relationship didn’t just accelerate my code — it elevated my understanding. I started asking better questions about my algorithms, not because I doubted the AI but because it helped me think more precisely about trade-offs and decisions.
Reflections and Where We Go From Here
My journey has evolved from using AI as an enhanced search tool to treating it as a collaborator and then as a learning partner. Pair programming once taught us that two minds are better than one. AI is showing that a single mind, extended through collaboration, can achieve remarkable depth.
Looking back, what has changed is not only my efficiency but also my relationship with the craft of software development.
I have taken away a few lessons from this process:
Teaching starts with prompting. Clear questions lead to better understanding on both sides.
Prompting is programming. Each interaction with AI is a small exercise in logic and iteration.
AI improves reflection. Explaining my intent to AI helps me clarify my own thinking.
AI blurred the line between thinking and doing. I now articulate my intent more clearly, review my assumptions more critically, and explain my reasoning more often — not for others, but for the model. In teaching it, I’ve become a more deliberate engineer
This is where the frontier lies today — moving from responsive assistance to continuous learning. For all its brilliance, today’s AI is amnesiac. Each session begins as if we’ve never met. It can optimize, summarize, and refactor — but it doesn’t grow with me. Every time I restart, I rebuild context from scratch. That’s not collaboration; that’s repetition. What I want next is continuity — an AI that accumulates shared understanding over time. One that remembers how I structure tests, how I name variables, how I debug, and can generalize those habits into new contexts. I want a partner that can generalize those patterns into new situations.
When that happens, AI won’t just pair with us; it’ll co-learn with us, together we'll co-evolve with our workflows. And that’s where I see the next shift coming: from agents that execute tasks to companions that evolve with your workflow, mirroring your reasoning patterns and improving through feedback. It’s the same idea Agile taught us decades ago: continuous improvement. Only now, the loop includes an intelligent collaborator that learns alongside the human.
