There is a thing that happens when you use an AI agent for long enough, and nobody really warns you about it because it sounds like something a tech evangelist would say at a conference while wearing a vest.
The agent reflects you back.
Not in a mystical way. In a very mechanical, almost boring way. The quality of what comes out is shaped, to a degree that still catches me off guard, by the quality of what you put in. And I do not mean prompt engineering. I mean the depth of thinking you bring to the session. The complexity of the problems you hand over. The precision of your language when you describe what you actually want.
Give it surface-level work and you get surface-level output. Give it the hardest thing you have, with full context, with constraints explained, with trade-offs made explicit, and something noticeably different shows up.
Two machines, two agents
I run Claude Code on two machines. One is my personal laptop, where FairwayPlan lives. The other is my work machine, where I log six-hour sessions most days on a much larger codebase with a team behind it.
The difference in how the agent feels across those two environments is striking. And I am fairly sure it has nothing to do with the model.
On the personal machine, my sessions are short. An hour here, thirty minutes there. I am adding a feature, fixing a bug, writing a blog post. The problems are real but they are bounded. I know the codebase intimately because I built all of it. When I describe what I want, I tend to be brief. The agent responds in kind. It is helpful. It is competent. It does the thing.
On the work machine, everything changes.
The sessions run five, six hours. The problems are tangled. They span multiple services, multiple teams' assumptions, multiple layers of historical decisions that made sense at the time and now create constraints you have to navigate around. When I describe what I want, I have to be precise because ambiguity in a large system compounds fast. I explain the architecture. I explain why the obvious approach will not work. I explain the second obvious approach and why that one also will not work. I lay out the constraints, the dependencies, the things that must not break.
And the agent, given all of that, produces something that feels qualitatively different from what it produces on a quick personal project session. Not just longer or more detailed. Sharper. More considered. It catches edge cases I did not mention because the context I gave it was rich enough for it to infer them. It pushes back on approaches that technically satisfy the requirement but would create problems downstream.
The model is the same. The difference is me.
The depth of thinking you bring to the session sets the ceiling for what comes back.
The research backs this up
There is a growing body of writing about this. In 2023, a team from Harvard, Wharton, and MIT ran a controlled experiment with 758 BCG consultants using GPT-4 (Dell'Acqua et al., 2023). They found that AI-assisted consultants completed 12% more tasks, 25% faster, at 40% higher quality. The interesting part: the gains were not evenly distributed. The consultants who already had strong domain knowledge were better at recognising when a task fell outside the AI's capability boundary. They knew when to trust it and when to override it. Weaker performers improved more in absolute terms, but the experts made fewer catastrophic errors. Ethan Mollick, one of the study's co-authors, calls this the jagged frontier (Mollick, 2023a): the uneven boundary between what AI handles well and what it quietly gets wrong. The people who navigate that boundary best are the ones who already understand the territory. They ask sharper questions. They provide denser context. They catch the errors that pass right through a less experienced reviewer.
Mollick has also written about how the best AI users develop personal libraries of effective prompts (Mollick, 2023b), encoding domain expertise into reusable patterns. The tool amplifies what you bring. If you bring shallow understanding, you get plausible-sounding output that you cannot properly evaluate. If you bring deep knowledge, you get output that lands closer to what you actually need, and you can tell the difference.
It makes intuitive sense when you think about it. A language model generates responses conditioned on everything in the context window. If your context is thin, "fix this bug," the model fills in the gaps with generic patterns. If your context is dense, "this function handles webhook retries but it does not account for the idempotency key rotation we added last sprint, and the downstream consumer expects at-most-once delivery," the model works within those constraints and the output lands closer to what you actually need. Research from Stanford has shown that language models do not even use long contexts uniformly (Liu et al., 2023). They attend most to information at the start and end, and lose track of what sits in the middle. How you structure your input matters as much as whether you include it at all.
You are not just prompting the model. You are setting the ceiling for what it can give you back.
A thin context produces generic patterns. A dense context produces work that surprises you.
So is it pointless to be polite?
This is the question I keep coming back to, and I think most people who use these tools regularly have an opinion on it. Is there any reason to say "please" and "thank you" to something that does not have feelings?
The pragmatic answer is no. The agent does not care. It does not feel appreciated. It does not sulk if you are curt. There is no emotional register being affected by your tone. Every "please" is, from a purely mechanical standpoint, a wasted token.
I say please anyway.
Here is why. And the agent has nothing to do with it.
The way you interact with things shapes the way you carry yourself. Clifford Nass and Youngme Moon published a study showing that humans automatically apply social rules to computers: politeness norms, reciprocity, even gendered stereotypes (Nass & Moon, 2000). People did this consistently, even when they knew the machine was not human. Their earlier book, The Media Equation, documented the same phenomenon across years of experiments at Stanford (Reeves & Nass, 1996). We are wired to treat things that respond to us as social actors, whether they deserve it or not.
That research is about what happens inside the human, not what happens inside the machine. And it maps directly to what I have observed. People who are rude to waitstaff are not just rude to waitstaff. The behaviour leaks. It creates a posture, a habit of treating the thing in front of you as something that exists purely to serve your needs as fast as possible. That posture does not stay contained to the restaurant.
When I sit down for a six-hour session with an agent, the tone I set at the start affects the entire session. Not the agent's performance. Mine. If I am impatient and terse from the first message, I stay impatient and terse. I skim the output instead of reading it. I accept the first thing that compiles instead of thinking about whether it is right. I treat the interaction as a vending machine: insert prompt, receive code.
If I take a beat. If I describe the problem carefully. If I say "thanks, that is close, but here is what I would adjust," I am slower, more deliberate, more engaged with the output. The result is better. The model did not respond to my politeness.I responded to my own politeness. The thoughtful mode produces better input, which produces better output, which makes the whole session more productive.
You are not being polite for the agent. You are being polite for yourself. The emotional posture you bring to the interaction is the one you extract from it.
Emotions do not check whether the recipient is conscious
There is something deeper here that I think matters. We like to draw a hard line between how we treat humans and how we treat tools. One deserves emotional consideration, the other does not. Clean and simple.
Except that is not how emotions work. Emotions do not check the consciousness status of the thing in front of you before they activate. If you spend an hour frustrated at a tool, you are just frustrated. The frustration is real. It affects your thinking, your patience, your next decision. Whether the tool "deserves" your frustration is a philosophical question. Whether the frustration degrades your work is an empirical one, and the answer is yes.
Conversely, if you approach the tool with the same collaborative tone you would bring to a capable colleague, something in your own thinking shifts. You describe problems more completely. You evaluate responses more carefully. You treat the output as something to engage with rather than something to accept or reject.
I have watched myself do both. The difference is not subtle.
The mirror goes both ways
On my personal machine, FairwayPlan sessions, the agent is fine. It is a capable pair programmer for a solo project. It does what I ask. I move fast, ship things, close the laptop.
On the work machine, where I bring six hours of focused intent, where the problems are harder and the stakes are higher and I am forced by the nature of the work to think clearly before I type, the same model feels like a different tool entirely. It feels like something that is genuinely keeping up with complex reasoning. Not because it got smarter. Because I showed up differently.
That is the thing worth remembering. The agent is a mirror. It reflects the depth you bring. The precision you bring. Even the emotional posture you bring.
If you sit down half-focused and fire off vague instructions, you will get back something that looks like it was built by a slightly distracted junior developer. If you sit down fully present, with clear thinking and genuine engagement, you will get back something that surprises you.
The tool did not change. You did.
And yes, I will keep saying please. It does not matter to the model. It matters to the six-hour version of me that has to live with whatever I build.
References
- Dell'Acqua, F., McFowland, E., Mollick, E.R., Lifshitz-Assaf, H., Kellogg, K., Rajendran, S., Krayer, L., Candelon, F., & Lakhani, K.R. (2023). Navigating the jagged technological frontier: Field experimental evidence of the effects of AI on knowledge worker productivity and quality. Harvard Business School Working Paper, 24-013. SSRN
- Liu, N.F., Lin, K., Hewitt, J., Paranjape, A., Bevilacqua, M., Petroni, F., & Liang, P. (2023). Lost in the middle: How language models use long contexts. arXiv preprint, 2307.03172. arXiv
- Mollick, E. (2023a). Centaurs and cyborgs on the jagged frontier. One Useful Thing. Link
- Mollick, E. (2023b). Now is the time for grimoires. One Useful Thing. Link
- Nass, C., & Moon, Y. (2000). Machines and mindlessness: Social responses to computers. Journal of Social Issues, 56(1), 81–103.
- Reeves, B., & Nass, C. (1996). The Media Equation: How People Treat Computers, Television, and New Media Like Real People and Places. Cambridge University Press.