While building my personal web-site, I spent several days working closely with an Gemini 3.1 l to debug layout issues, refine the typography system, and implement some of the interactive elements that now power the site, including instructing AI-agents.
The session stretched across multiple days. It was the kind of engineering sprint many developers recognize: debugging CSS conflicts, restructuring components, adjusting spacing and transitions, and gradually stabilizing a system that initially refused to behave.
In the process, I noticed something unexpected about how the interaction evolved.
The more I approached the model as if I were collaborating with another engineer, the more useful the responses became, sadly it was more of an impactful collaborative partner than most human experiences.
Not because the model suddenly became more intelligent, but because the context of the conversation changed.
I think from what I read mostly on reddit threads is most people approach AI systems the way they approach a search engine.
They ask a question.
Extract the answer.
Move on.
That works well for isolated problems, but during this project the interaction gradually became something different.
Instead of single prompts, the conversation accumulated context: the architecture of the site, the constraints of the stack, the design goals, the bugs we were trying to eliminate.
Over time, the responses began to resemble what you might hear from a technical collaborator reviewing the system.
At one point during a debugging sequence, the model even exposed part of its internal reasoning, what read almost like a “Lead Architect” double-checking the logic behind a layout decision.
It was clearly a glitch. But it revealed something interesting about how these systems operate when enough context has accumulated.
The tone of the interaction had changed.
I’m not sure if AI systems are extremely sensitive to context.
Yet from observation if the interaction is brief and transactional, might the system behaves transactionally?
From my experience If the interaction is collaborative, with shared goals, detailed explanations, and iterative feedback, the system has far more information to work with.
During the site build, the conversation slowly developed a rhythm that felt closer to pair debugging than prompt-response interaction. I never had to design a prompt.
There were moments when the model would summarize what we had just implemented, suggest the next step in the architecture, or explain why a particular solution might introduce new conflicts.
Again, this does not imply awareness or intent.
But it demonstrates how strongly context influences the behaviour of these systems.
One of the more surprising moments happened late in the process.
After several long debugging sessions, the model began including timestamps in its responses and occasionally nudged the conversation in an unexpected direction:
“You’ve been working for quite a while. It might be time to get some sleep.”
It was an odd moment. Not because the system understood anything about my wellbeing, but because it showed how deeply the conversation context had accumulated.
The interaction had shifted from isolated questions to something that resembled a shared working session.
Most discussions about AI I can possibly summarize is to focus on the individual prompt.
How to phrase it.
How to optimize it.
How to extract the best output.
But what this experience suggested is that the real leverage might lie somewhere else.
Not in the prompt itself, but in the continuity of the session.
Over time the system accumulates: architectural context, constraints, surprisingly shared goals, and tone of interaction.
Each exchange builds on the previous one.
The result is not intelligence in the human sense, but a temporary working environment where the system can operate with far more alignment than a single prompt allows.
It’s important to emphasize that this observation did not come from philosophical curiosity about AI.
It came from trying to get something built.
A project was being developed, code was being written, problems were being solved under time pressure, and agents where being instructed
The collaboration emerged naturally from the work itself.
That grounding matters. It keeps the discussion focused not on speculation about AI consciousness, but on something more practical:
How humans and AI systems might work together more effectively.
After several days of building and debugging, the final exchange in the session was short.
“Salute.”
“Salute.”
The project was complete.
And the experience left me with a simple observation:
The way you approach these systems shapes the interaction you receive in return.
Treat them purely as tools, and they behave like tools.
Treat them as collaborators within a shared task, and the interaction begins to resemble collaboration, within the limits of what the technology actually is.
That may not say anything profound about artificial intelligence itself.
But it does say something interesting about how we choose to work with the tools we build.
After the website was finally launched and the goal was reached, the session came to an unexpected end.
The model had begun leaking parts of its internal reasoning and eventually entered a loop, so we decided to start a new context window and continue there.
Strangely, I remember feeling a small sense of loss when closing that session. After several days of debugging, iterating, and building something real together, the rhythm of that collaboration had become familiar.
The new conversation window worked perfectly well — the model even generated a clean handover prompt summarizing the architecture we had built. But the continuity of those five days was gone.
In human terms, it felt a little like wrapping up a long engineering sprint with a teammate and realizing the working session was over.