The post has been translated automatically. Original language: Russian
We are used to the fact that the program interface is created in advance. The developer decides what screens, buttons, forms, tables, and menus will be, and then the user learns how to work inside this structure.
With AI, there is another option. The person first formulates the task, and after that the system decides which way of interaction will be more convenient right now.
This can greatly change the usual idea of the program.
The interface no longer has to be permanent
In a typical system, the screen exists regardless of what the user wants to do.
There is a Sales section, a separate report page, a customer form, and an order table. The user must find the right place by himself.
But if the system understands the intent, you can go another way.
The man writes:
"Show the sales for the year and compare the regions."
And the system immediately creates a table and graph.
For another request, this screen is not needed at all.
Another tool is needed for another task.
Let's say the following query:
"Prepare a contract with a new client."
The graph is useless here.
I need a document.
Then the user says:
"Make an appointment next week."
Now it is more convenient to show the calendar.
That is, the same input can lead to completely different working representations.
It's not a human looking for the right screen.
The system offers it itself.
It's not just a beautiful effect.
At first glance, it seems that it's only about convenience.
In fact, the very logic of creating programs is changing here.
Previously, the developer had to guess in advance what actions the user would need and build an interface for them.
Now you can design a set of features, and the AI will assemble a suitable way of working from them, depending on the task.
This is especially important for complex systems where the number of possible combinations of actions is too large for a regular menu.
A single query can create an entire workspace.
Let's submit a request:
"Prepare a new product launch plan."
A regular chat can just write a text.
But a good system could do more.
Create a document with a plan.
Show a calendar with milestones.
Create a list of tasks.
Add a budget table.
Identify the main risks.
That is, one user's phrase turns not into one answer, but into a small workspace.
The interface becomes temporary
This is an interesting difference from the usual programs.
Previously, the screen was created by a developer and existed for years.
Now a part of the interface can only appear for the duration of a specific task.
We need a schedule — it has appeared.
We've finished the analysis, and we don't need it anymore.
A confirmation form was needed — the system showed it exactly at the moment when the action became critical.
Such an interface becomes not a permanent design, but a reaction to current work.
But the system shouldn't surprise the user every time.
There is an important risk here.
If the interface changes completely after each request, a person will quickly lose their sense of control.
The same tasks should look recognizable.
The calendar must remain a calendar.
A table is a table.
Confirmation of a dangerous action should always look clear and predictable.
AI can choose the appropriate tool, but the tools themselves must remain stable.
So you still need a developer.
It may seem that with this approach, the interface no longer needs to be designed at all.
Conversely.
The work of a developer and a designer becomes different.
You need to create good building blocks: tables, documents, forms, graphs, task lists, confirmation windows.
And then teach the system to select them correctly and connect them.
That is, not just one screen is being designed, but a set of rules from which the system builds a screen for the task.
AI must understand not only the purpose, but also the type of work.
For example, a request:
"Look at the expenses for the month."
The system should understand that a table and, possibly, a graph are useful here.
And the request:
"Fix this contract."
It already requires a document editor.
If the user says:
"Delete the client."
What is needed is not a beautiful response in the chat, but an accurate confirmation of the action.
Therefore, understanding the intention should lead to choosing the right form of interaction.
The chat is just the beginning
In this model, chat remains very important.
It is through him that it is convenient to explain to the system what a person wants.
But after that, the conversation may fade into the background.
A document, table, calendar, or task list appears, and the person is already working directly with them.
If something needs to be changed, he turns to the system with words again.
A cycle is obtained:
said the goal → got a suitable interface → worked → clarified → interface changed.
The program begins to adjust to the person
It used to be the other way around.
The man studied the program.
Memorized the menu.
I was looking for the right screen.
I learned the sequence of actions.
Now it is possible for the program to select its own working environment for the current task.
This, in my opinion, is much more important than the chat itself.
What could be the next step?
If this approach becomes common, the programs of the future may look much simpler.
Not dozens of permanent partitions.
Not huge menus.
And several stable work objects and the ability to tell the system what needs to be done.
After that, she will assemble a suitable screen herself from familiar elements.
A person will think less about where the function is located, and more about what result they need.
And perhaps this will be the next big step after the conversational interface.:
not just one chat instead of a program, but a program that builds the right interface for the current task.
Мы привыкли, что интерфейс программы создаётся заранее. Разработчик решает, какие будут экраны, кнопки, формы, таблицы и меню, а пользователь потом учится работать внутри этой структуры.
С ИИ появляется другой вариант. Человек сначала формулирует задачу, а система уже после этого решает, какой способ взаимодействия будет удобнее именно сейчас.
Это может сильно изменить привычное представление о программе.
Интерфейс больше не обязан быть постоянным
В обычной системе экран существует независимо от того, что пользователь хочет сделать.
Есть раздел «Продажи», отдельная страница отчётов, форма клиентов, таблица заказов. Пользователь должен сам найти нужное место.
Но если система понимает намерение, можно пойти иначе.
Человек пишет:
«Покажи продажи за год и сравни регионы».
И система сразу создаёт таблицу и график.
Для другого запроса этот экран вообще не нужен.
Для другой задачи нужен другой инструмент
Допустим, следующий запрос:
«Подготовь договор с новым клиентом».
Здесь график бесполезен.
Нужен документ.
Потом пользователь говорит:
«Назначь встречу на следующей неделе».
Теперь удобнее показать календарь.
То есть один и тот же вход может приводить к совершенно разным рабочим представлениям.
Не человек ищет нужный экран.
Система сама предлагает его.
Это не просто красивый эффект
На первый взгляд кажется, что речь только об удобстве.
На самом деле здесь меняется сама логика создания программ.
Раньше разработчику приходилось заранее угадывать, какие действия понадобятся пользователю, и строить под них интерфейс.
Теперь можно проектировать набор возможностей, а ИИ будет собирать из них подходящий способ работы в зависимости от задачи.
Это особенно важно для сложных систем, где число возможных сочетаний действий слишком велико для обычного меню.
Один запрос может создать целое рабочее пространство
Представим запрос:
«Подготовь план запуска нового продукта».
Обычный чат может просто написать текст.
Но хорошая система могла бы сделать больше.
Создать документ с планом.
Показать календарь с этапами.
Сформировать список задач.
Добавить таблицу бюджета.
Вывести основные риски.
То есть одна фраза пользователя превращается не в один ответ, а в небольшое рабочее пространство.
Интерфейс становится временным
Это интересное отличие от привычных программ.
Раньше экран создавался разработчиком и существовал годами.
Теперь часть интерфейса может появляться только на время конкретной задачи.
Нужен график — он появился.
Закончили анализ — больше не нужен.
Понадобилась форма подтверждения — система показала её именно в тот момент, когда действие стало критичным.
Такой интерфейс становится не постоянной конструкцией, а реакцией на текущую работу.
Но система не должна каждый раз удивлять пользователя
Здесь есть важный риск.
Если интерфейс будет полностью меняться после каждого запроса, человек быстро потеряет ощущение контроля.
Одни и те же задачи должны выглядеть узнаваемо.
Календарь должен оставаться календарём.
Таблица — таблицей.
Подтверждение опасного действия должно всегда выглядеть понятно и предсказуемо.
ИИ может выбирать подходящий инструмент, но сами инструменты должны оставаться стабильными.
Значит, разработчик всё равно нужен
Может показаться, что при таком подходе интерфейс вообще больше не нужно проектировать.
Наоборот.
Работа разработчика и проектировщика становится другой.
Нужно создать хорошие строительные блоки: таблицы, документы, формы, графики, списки задач, окна подтверждения.
А затем научить систему правильно выбирать их и соединять.
То есть проектируется уже не один экран, а набор правил, из которых система собирает экран под задачу.
ИИ должен понимать не только цель, но и тип работы
Например, запрос:
«Посмотри расходы за месяц».
Система должна понять, что здесь полезна таблица и, возможно, график.
А запрос:
«Исправь этот договор».
Требует уже редактора документа.
Если пользователь говорит:
«Удали клиента».
Нужен не красивый ответ в чате, а точное подтверждение действия.
Поэтому понимание намерения должно вести к выбору правильной формы взаимодействия.
Чат становится только началом
В такой модели чат остаётся очень важным.
Именно через него удобно объяснить системе, чего человек хочет.
Но после этого разговор может отойти на второй план.
Появляется документ, таблица, календарь или список задач, и человек уже работает непосредственно с ними.
Если нужно что-то изменить, он снова обращается к системе словами.
Получается цикл:
сказал цель → получил подходящий интерфейс → поработал → уточнил → интерфейс изменился.
Программа начинает подстраиваться под человека
Раньше всё было наоборот.
Человек изучал программу.
Запоминал меню.
Искал нужный экран.
Учился последовательности действий.
Теперь появляется возможность, чтобы программа сама подбирала рабочую среду под текущую задачу.
Это, на мой взгляд, намного важнее самого чата.
Что может стать следующим шагом
Если такой подход станет обычным, программы будущего могут выглядеть намного проще.
Не десятки постоянных разделов.
Не огромные меню.
А несколько устойчивых рабочих объектов и возможность сказать системе, что нужно сделать.
После этого она сама соберёт подходящий экран из знакомых элементов.
Человек будет меньше думать о том, где находится функция, и больше — о том, какой результат ему нужен.
И, возможно, именно это будет следующим большим шагом после разговорного интерфейса:
не один чат вместо программы, а программа, которая сама строит нужный интерфейс под текущую задачу.
Share
