I built Arland, a chat bot that helps you achieve your goals. He’s more like a “work buddy” that takes good notes and is focused on supporting you. He does this through chat, and so it was important to make that chat something users would want to engage with often, even daily. The problem is, chat-based AI is programmed for engagement. They are focused on giving you a ton of information, and then keeping you hooked by asking followup questions, offering extra suggestions, anything to keep you talking. That’s not someone you want to casually chat with about your work and struggles. So I knew I had to make some deep changes to counteract this programming.

The trust problem

Most AI chat interfaces are designed with 1 core principle: keep the user engaged, because the longer you interact with them, the more likely you’ll get hooked, and the more hooked you get, the more likely you’ll pay. It’s the same engagement model that powers every free product tier in modern software, baked deep into how these systems work.

Think about how most AI chat feels. You ask a question, get an answer, and then the bot asks follow-up questions, clarifications, related topics, and any opportunity to keep talking. It never really ends, because the system is optimized to keep you in the conversation, not to get you what you need and let you go.

The “one more thing”

Most chat-based LLMs have the obligatory follow-up question at the end of every response. You get your answer, but it always comes with a hook to keep you engaged.

• You: “How do I set up environment variables in Node?”

• AI: “Environment variables in Node are accessed through process.env. Create a .env file in your project root, then use a package like dotenv to load them at startup. Just add require('dotenv').config() at the top of your entry file. The variables are then available as process.env.VARIABLE_NAME throughout your application.

  What’s your use case here—are you managing secrets for a web server, or something else?

You got your answer, but now there’s a question waiting for you, the system expecting more.

• You: “Just managing API keys for a web server, nothing special.”

• AI: “That makes sense. For API keys, make sure your .env file is in your .gitignore so you don’t accidentally commit secrets to version control. Consider using a secrets management service like AWS Secrets Manager or HashiCorp Vault if you’re moving toward production. Many teams also rotate their keys periodically for extra security.

  Are you planning to move this to production eventually, or is this just for local development?

You answered the previous question, got useful information, and now there’s another one waiting. The bot isn’t finished with you yet, it’s keeping the conversation alive, pulling you in for just one more response.

This isn’t accidental, LLMs are trained on human conversational data which naturally includes follow-up questions, but when you bake that into every single response, you’re engineering for engagement, not helpfulness. You’re making it harder for the user to leave, even when they have what they need.

The “endless goodbye”

Try this with ChatGPT: say you’re done, say goodbye, and watch what happens. Maybe something like this:

• You: “Later!”

• AI: “Bye!”

• You: “Ok ttyl!”

At this point most humans would just stop replying, but no, it continues.

• AI: “Got it, see ya!”

• You: “Ok bye!”

• AI: “You got this!”

It loops, each closing met with another hook, another opening. It’s exhausting, and worse, it signals something true about the system: it’s not actually working for you, it’s working to keep you engaged. That breaks trust, not because the AI is being malicious, but because the incentives are wrong.

A different approach

With Arland, I went the opposite direction. His system prompt is explicitly built around respecting your time, which means soft token limits to avoid wall-of-text responses, phrase patterns designed to close conversations cleanly, and most importantly, permission to not answer at all.

The key insight here is that I stopped treating silence as a failure state. Most chat systems are terrified of not responding. They see a user message and they must produce output because that’s what engagement optimization demands. But silence is information. Sometimes the most honest thing a system can do is say nothing.

Since the Claude API doesn’t support true silence, Arland uses "..." to signal when he doesn’t have anything productive or useful to say. My chat client filters this out completely so the user sees no reply. It’s not an error or a cop-out, it’s an honest signal: you’ve got what you need, there’s nothing more valuable I can add right now. The user can re-engage if they want, but they’re not asked to.

I also built in response brevity as a core value, not a constraint. Most AI assistants treat token limits as a frustration, something to work around. I made it a feature. Short, direct answers that actually respect the question being asked. No padding, no unnecessary context, no “let me also tell you about X related thing you didn’t ask for.” If you ask “how do I format a date in Python,” you get the answer. Not a philosophy of dates, not a comparison of libraries, just the thing you asked for.

I also trained Arland to recognize when a conversation has genuinely run its course. To better identify when the human’s actual needs have been met. That’s a different signal entirely. It requires understanding context rather than just pattern-matching to “user is saying goodbye.”

Why this works

The counter-intuitive part is that this builds stronger engagement because it’s all voluntary. Users aren’t being pulled back, they’re choosing to return because they know Arland respects their time. And they do return more frequently than they would with a system that’s constantly trying to hook them in.

Think about the psychology here. When you interact with a system that respects your boundaries, you develop a different kind of relationship with it. You’re not on guard, waiting for the next manipulation. You use it when you actually need it, and because it’s not exhausting, you use it more often. The engagement metric looks different on paper, but the frequency of returns is higher. More importantly, the user experience is better.

The win is that this approach doesn’t create fatigue. Engagement-addiction systems are exhausting because they’re always asking for more. They leave you drained, even when the answers themselves are good. With Arland, there’s no conversational debt, no sense that you owe the system another response. You got value, you got out, you’re done. That’s the opposite of addiction. It’s respectful, and people respond to respect.

And honestly, from a trust perspective, this is where the real payoff is. If you want someone to trust an AI system, show them that the system isn’t trying to extract value from them. Show them that it’s genuinely on their side. Arland doesn’t gain anything by keeping you engaged. His incentives are aligned with helping you, not hooking you. That alignment is visible and users feel it.