When I first started thinking about Linda, I was not trying to build another chatbot.
I already knew AI could answer questions. It could write a decent response, summarize information, sound friendly, and carry on a conversation. By this point, none of that was particularly impressive to me anymore.
What I wanted to know was whether AI could actually do a job.
Could I create a customer-facing employee for The Knight Emporium who could talk to customers, understand what they wanted, help them find products, answer questions accurately, handle the back-and-forth that happens before a sale, work through pickup, and eventually help move an actual transaction forward?
More importantly, could she do all of that without making things up, promising something the business could not deliver, selling inventory we did not have, changing a price she was not authorized to change, or creating some completely new version of company policy in the middle of a conversation?
That became Linda.
And building her has probably taught me more about practical AI than anything else I have worked on.
A good conversation is the easy part
The first thing I learned is that making an AI sound good is nowhere near the same thing as making it operationally good.
Linda can be warm. She can be conversational. She can explain a product without sounding like somebody copied the description off the box. She can understand that a customer saying “yeah I’ll take it” probably means they want the thing she just offered them.
That is useful, but it is not enough.
A salesperson also has to know whether the item is still available. She has to know the real price. She has to understand which product the customer is referring to when three similar things have been discussed. She has to know whether a hold actually exists, whether payment has cleared, whether pickup is available, and what she is allowed to promise next.
Those are not language problems.
Those are business-state problems.
That distinction completely changed the architecture.
We eventually settled on a pretty simple principle: the model remembers the conversation; the system remembers the business.
Linda can understand what the customer means and decide how to communicate with them. But the durable facts around inventory, orders, reservations, negotiated prices, approvals, and payments live outside of the conversation.
- Postgres owns the business state.
- Stripe owns payment.
- The backend owns the rules and orchestration.
Linda consumes that truth.
She does not create it.
This is where “AI agent” gets real
It is easy to call something an AI agent when the stakes are low.
Give it a list of tasks. Give it some tools. Let it decide which tool to call. Put a nice chat interface around it.
Things get considerably more interesting when a customer is involved.
We had to decide exactly what Linda could and could not do.
There are things I absolutely want her handling independently:
- Search products.
- Explain them.
- Compare verified information.
- Answer common questions.
- Understand intent.
- Guide the customer through the process.
- Keep the conversation moving without asking me for permission every thirty seconds.
There are other things where she does not get to improvise:
- Linda cannot invent inventory.
- She cannot invent a price or promotion.
- She cannot create her own discount because the customer asked nicely.
- She cannot tell someone something is paid when Stripe says it is not.
- She cannot rewrite return policy in the middle of a conversation.
- She cannot quietly change durable business state because that would make the conversation easier.
- She cannot turn “I think that’s the one” into a completed transaction without knowing which product the customer actually means.
That is where Linda stopped being a chatbot project and became an operating-model project.
We have caught some spectacularly small problems that could have become very big problems
One of the most useful parts of building Linda has been seeing how tiny conversational mistakes can create real operational risk.
We found cases where:
- A simple “yes” could potentially be attached to the wrong earlier offer if the conversation had moved on. That sounds minor until the thing being accepted is a price, a reservation, or a purchase.
- Two held products could be similar enough that casual language might identify the wrong one.
- Price-negotiation behavior could interpret a number mentioned in conversation incorrectly if the system did not clearly distinguish the customer’s offer from a product number or some other number in the conversation.
- Linda could understand Spanish perfectly well but part of the transactional confirmation still came back in English.
- She knew the right factual answer but did not combine all of the pieces when a customer asked two things at once.
- Searching for lighting could collide with typo correction and wander toward “Lightning.”
None of those are dramatic science-fiction AI failures.
They are exactly the kind of boring little operational failures that matter when an AI is actually doing work.
And that has probably been one of the biggest lessons for me.
The dangerous AI mistake is not always some giant hallucination.
Sometimes it is an extremely reasonable interpretation of the wrong “yes.”
Verification became non-negotiable
Linda also helped shape how I think about AI governance across everything else I am building.
The system that builds the feature should not be the only system allowed to tell me the feature works.
We have repeatedly had a builder complete something, an independent review find a very specific edge case, the builder fix it, and the verifier go back through it again.
That cycle can be annoying.
It is also the reason some of those problems never made it to a customer.
Our broader operating model eventually became:
- Scope
- Builder
- Independent Verifier
- Closure
A human gate sits where the consequence warrants one.
Linda is one of the clearest examples of why.
A chatbot can tell you that its answer looks right.
A production system needs proof.
This week, for example, we ran a real pickup checkout smoke test through the production path:
- The order was created using the server-calculated total.
- Stripe created the expected unpaid checkout session.
- When that session expired, the order was cancelled.
- The inventory was restored.
That may not sound exciting compared with a flashy AI demo.
I find it extremely exciting.
Because that is the difference between “the AI can talk about buying something” and “the business transaction actually behaves correctly from beginning to end.”
I also had to stop trying to make Linda too smart
This may be the part I did not expect.
There is a temptation when building with AI to keep giving the model more authority because it is capable of handling more.
I have gone in almost the opposite direction.
Linda should be extremely capable where intelligence helps:
- Understanding customers.
- Handling messy language.
- Identifying what somebody is asking for.
- Explaining options.
- Maintaining conversational context.
- Making the interaction feel natural.
But if the answer already exists as a hard business fact, I do not need Linda reasoning her way to it.
If inventory is zero, inventory is zero.
If a payment is unpaid, it is unpaid.
If a hold expires at a certain time, it expires at that time.
If a policy does not allow something, Linda does not get to negotiate a new policy.
That is where one of our other operating principles came from:
AI communicates. Deterministic logic decides.
The more capable Linda becomes, the more important that separation becomes.
The customer should never have to care about any of this
This may be the most important point.
A customer should not have to understand that there is a language model, an orchestration layer, a PostgreSQL database, Stripe, validation rules, tool permissions, or an independent verification process behind Linda.
They should just feel like somebody competent is helping them.
They should be able to:
- Say, “I’m looking for a lamp,” and get useful help.
- Ask whether something is available and get the correct answer.
- Change their mind without breaking the system.
- Ask two questions in the same message without having to learn how the AI wants them phrased.
- Get a human when Linda does not know something or does not have the authority to do something.
That is the standard.
Not “did the chatbot respond?”
Did the customer actually get helped?
Linda is still teaching me things
I am careful about calling AI systems “finished” because I am not sure that word means much here.
Linda has come a long way from the original idea. She is now operating inside a real commerce stack, working against authoritative product and business data, and participating in actual customer and checkout flows.
We have also found enough edge cases along the way that I have absolutely no illusion that giving an AI access to a few tools suddenly makes it an employee.
An employee has:
- A role.
- Authority limits.
- Access to the information required to do the job.
- Escalation paths.
- Accountability for outcomes.
And the company has to create the operating environment that allows that employee to succeed.
AI is no different.
That is probably the biggest thing Linda has taught me.
The future of AI in business is not going to be won by whoever builds the chatbot that sounds the most human.
It is going to be won by whoever figures out how to make AI reliably participate in the business without losing control of the business in the process.
That is a much harder problem.
It is also a hell of a lot more interesting.