← All posts

Nobody wrote her a manual

Nobody wrote her a manual

Every AI assistant for business software starts with the same chore. Someone has to explain the business to it. Somebody writes up what the screens are for and what the jargon means, and lists which table holds what. Then the assistant is exactly as good as that document, and the document starts going out of date the day it is finished.

The chore usually falls to the people with the least time for it: the two or three who actually know how the company works. And when they leave, what they knew leaves with them.

We wrote before about why ask_ai, the assistant in TSQL.APP, lives inside the Solution's own database, and how SQL Server, not a polite prompt, enforces her limits. This post is about what happens on her first day in an application she has never seen.

Nobody writes her a manual. She reads the application, and she treats anything a person tells her as a claim until the data agrees.

The application is the manual

In most software, what a screen does is buried in compiled code. An assistant cannot read it, so it has to be told.

In TSQL.APP every screen, every field and every button is a row in the database, and a button's behaviour is T-SQL stored right there with it. That changes what an assistant can learn on its own. To find out how this business takes an order, she does not need anyone's summary. She needs:

  1. the screens and buttons, which are rows she can read;
  2. the code behind each button, which tells her which tables it writes to;
  3. the data in those tables, which shows how the business really uses them.

The lessons she is installed with teach method, never content. Nothing in them is about any particular business. One of them goes like this: users talk about screens and buttons, never about tables, so do not guess which table they mean. Travel the buttons and let the application tell you. Her map tool can search inside button code, so "which button writes to the invoice table?" is a question she can answer. No table list can.

Then she reads the data. The code shows what a button can do. The rows show what people actually do with it. That includes the parts nobody would think to write down: the order type that has never been used, the balance that is worked out on the fly instead of stored, the quantity that follows its own rules.

The obvious objection

An assistant that learns on its own sounds like an assistant that makes things up on its own. If no one curates what she knows, what stops a wrong idea from setting in?

Two things. The first is the one from the earlier post: she never stores the structure of the application. She reads it live every time, so her picture of which screens exist cannot go stale. Only meaning gets stored: what a screen is for, and what a term means in this company.

The second is the mechanism this post is really about.

A user's word is a claim, not a fact

Sooner or later someone tells her something. "That status means the goods have left the building." "We never use that field any more." Most systems face a blunt choice at that point. Either they ignore it, or they store it as truth.

She does neither. Here is the rule she works by, word for word, from her own memory in a running Solution:

When a user teaches or corrects something about this Solution, check relevant existing understanding for conflict, then integrate it into the business mind map with appropriate entities, processes, terms, and links. Explicitly label user-reported or not-yet-verified claims as user-reported/open; call them confirmed only when the live app or data supports them. Preserve unresolved questions rather than silently upgrading them to facts.

So her knowledge carries a label: who said it, and whether she has checked it. A user's explanation goes in straight away, because it is useful at once. But it goes in as user-reported. It only becomes confirmed once the application or the data backs it up. If the data says something else, she has a conflict to raise, not a fact to repeat.

This is also why nobody tidies her memory for her. A memory someone edits behind her back looks the same to her as one she verified herself, and she loses the ability to tell them apart. Corrections go to her, in conversation, where they get the same label as everything else.

She comes back with questions

The surest sign that she has understood something is that she can say exactly what she has not understood yet.

At the end of an exploration she does not hand you a confident summary with the gaps smoothed over. She brings a short list of specific questions. What does this abbreviation stand for? Is this price table still in use, now that the code that filled it is commented out? At what point does a document count as final? Each one is a place where the code and the data stopped being able to answer, and only a person can.

That flips who does the work. You no longer write documentation in the hope that it covers what she will need. She tells you what she needs, one question at a time, and each answer lands in her memory as user-reported until the data confirms it.

Asking her cold

The test that matters is not whether she can describe the tables. It is whether a new employee could ask her a real question and get a useful answer.

So we asked her, with nothing set up in advance, the way a new hire would. "I bought something this morning and I want to sell it on this afternoon. How do I record that, ship it and invoice it?" She answered with the real screens and buttons, in order, in the language she was asked in. She warned about the one step where quantities need checking by hand. She pointed out which step needs a role the ordinary user may not have. And she named the one part she was not sure about, rather than guessing.

You can ask her the same way from plain T-SQL:

sql
EXEC dbo.sp_ask_ai N'I bought something this morning and want to sell it on
this afternoon. Which screens and buttons do I use, in which order?';

None of that answer came from a document. It came from the application, read from the inside, by something that had never seen it before.

Why it works here

None of this is a cleverer model. It works because the application was already data before any AI got near it. When screens, buttons and logic live in the database, an assistant can read them for the same reason a report can. When the data sits next to them, she can check what she is told against what actually happens.

The model will change. The fact that the application describes itself will not.

There is documentation and a programming reference online, and you can always book a demo.