While designing an enterprise AI workflow, we discussed whether a business frontend would still be necessary if employees could complete requirements, strategy, candidate evaluation, client materials and feedback through a Feishu bot.
This is more than a choice between a frontend and chat. It asks what AI-native means.
Adding chat to software can replace “Create project” buttons with commands and “Generate report” buttons with requests. Yet users still need to know the features, sequence and instructions for every step. The internal structure has not changed; mouse operations have become chat commands.
That may be conversational UI or AI-enabled software without being AI-native. Perhaps AI-native software should understand people's work rather than merely let people operate software through conversation.
Each native generation changes how a task is accomplished
Ride-hailing did not merely place taxi-company phone numbers in an app. That would still require finding a company, explaining location, checking arrival and paying cash.
It reorganized location, matching, dispatch, pricing, tracking, payment and reviews. Users express a destination while coordination moves behind the system.
Taobao did more than publish a mall's catalog; it reorganized discovery, recommendations, trust, payment protection, merchant operations and logistics. Recruiting software changed posting, sourcing, matching, communication and screening rather than merely digitizing resumes.
Native applications use new technology to redefine how something should be done, not simply replace the entry point.
The internet connected information; mobile enabled services anywhere; AI now enables understanding intent, processing unstructured inputs, organizing tasks and using tools. That is the starting point.
From finding features to understanding goals
Traditional software assumes users know the task and how to operate the system. Capabilities appear as menus, pages, buttons and forms; people translate work into supported operations:
Understand task -> find feature -> open page -> fill fields
-> click -> inspect result -> decide where to go next
The user owns the business goal; software executes explicit instructions.
AI-native changes that division. Users express goals, materials and constraints. The system understands context, discovers gaps, organizes capabilities and advances work:
Express goal -> understand context -> identify missing information
-> use business capabilities -> request key confirmations
-> continue from feedback -> complete and retain lessons
Instead of people understanding and operating software, software understands work and organizes itself. This changes the interaction model, not just the interface.
AI-enabled software, conversational UI and AI-native
AI-enabled software adds functions such as drafting, summaries or recommendations within existing pages and processes.
Conversational UI provides natural-language access to existing functions. It reduces menu-search effort while leaving decomposition, feature choice and progression to the user.
AI-native starts from goals rather than feature names. It must recognize the business setting, current state, missing information, available capabilities, required confirmations and destination for results.
Given a client's emails and chat records with “Please handle this new project,” it should do more than summarize. It should determine whether the project already exists; whether client, product, budget, market and timing are clear; which statements are sourced or inferred; what needs clarification; whether historical context helps; what brief structure is appropriate; who confirms; what follows confirmation; and how corrections and feedback are retained.
Users need not invoke each feature, but decomposition, organization and progression still happen.
Processes move inside the system rather than disappear
Expressing a goal does not remove workflows. Requirements still need confirmation, budgets cannot be invented, client materials need review, decisions need owners and feedback needs recording. Permissions, responsibilities, state and risk remain.
What disappears is the need for users to advance every detail manually. Processes become internal states, rules, tools and confirmation points rather than a sequence of pages.
AI may choose how to collect information and organize tasks without ignoring business constraints:
User-facing: goals, conversation, results, necessary confirmation
System-facing: state, permissions, tools, rules, logs, exceptions
AI-native hides operational complexity, not business responsibility.
Over time, AI may change the process itself
Keeping existing processes describes an initial stage, not necessarily the endpoint. Many steps exist because previous human and software capabilities were limited: converting chats to tables, copying between systems, checking missing fields, notifying owners, classifying feedback and reconstructing lessons from memory.
These are information-processing and coordination costs rather than intrinsic business needs. With understanding, context, tools and anomaly detection, some need not remain separate human tasks.
Evolution may therefore have two stages:
- Let AI handle information processing within current workflows.
- Redesign work around new capabilities and costs.
Like ride-hailing and e-commerce, moving existing work online can eventually create new collaboration methods.
AI-native does not mean one chat box
Chat suits unclear goals, context, clarification, progress queries and simple confirmations. It is not always best for comparing dozens of candidates, bulk price changes, version differences, complex editing or overall project analysis.
Choose interactions dynamically:
Conversation: goals, context, progression
Cards: summaries and simple confirmation
Tables: bulk input, comparison and editing
Dedicated pages: complex editing, version comparison and exceptions
A task can begin in a Feishu bot, use a card for brief confirmation or a temporary workspace for candidate comparison, then return to conversation.
Interfaces remain, but appear when the task needs them rather than serving as mandatory fixed entry points.
Real workflows are the foundation of AI-native
Why map processes, fields and frontends if users should no longer operate them? Because AI must understand a process before hiding it.
A reliable system needs business objects and states, task inputs, confirmed facts versus inference, viewing and editing permissions, available capabilities, reversible and risky actions, failure recovery, result storage and rules for long-term memory.
Without those answers, chat hides confusion. It may generate plausible content without knowing its project, approval state, recipient, next step or how to withdraw an error.
Real workflows are infrastructure. An initial frontend can be an explicit proving ground for objects, state, confirmation and exceptions, collecting AI output, human changes and client feedback. Once validated, capabilities can become tools AI safely calls.
Moving from workflows to AI-native
Four stages can guide enterprise systems.
Stage one: make actual work explicit
Map roles, inputs, outputs, state, review and exceptions. Run a real project through a frontend or low-code tool. The priority is understanding work, not demonstrating model intelligence.
Stage two: turn business capabilities into tools
Project creation, requirements organization, draft storage, review submission, candidate evaluation, client materials and feedback should become independently callable capabilities with explicit boundaries and permissions.
The frontend calls them today; AI can call the same tools later.
Stage three: let AI organize tools and processes
AI selects tools from intent and context, supplies parameters, asks questions and pauses for necessary confirmation. Users need not locate every feature, while the system retains state and responsibility boundaries.
Stage four: redesign the working method
After collecting enough actual-use data, reassess necessary steps, former coordination costs, parallel work and proactive suggestions. AI-native then begins changing organizational work.
The core is a new collaboration model, not autonomy alone
Autonomy, planning and tool calling matter but should not be the only or first enterprise objective. Responsibilities need redesign:
- People express goals, provide judgement and own responsibility.
- AI understands information, organizes tasks and handles uncertainty.
- Business systems maintain state, rules, permissions and consistency.
- Interfaces present information and operations when needed.
- Observability and review make the process understandable and traceable.
Content generation alone leaves coordination to people. Unrestricted operation without permissions, confirmation or traceability becomes a black box.
The aim is AI carrying more understanding and organization while human judgement remains at important points.
A final thought
In the app era, people learned menus and buttons to work. In an AI-native era, they express goals while software understands context, organizes capabilities and requests judgement.
Processes become internal states, rules, tools, memory and confirmation points. Initially AI changes details; later it helps question which steps are business requirements and which were costs imposed by older technology.
AI-native does not eliminate processes. It removes the need for people to operate them manually.
Software enters that era when users express what they want accomplished and the system understands the work, organizes capabilities and carries the process.
Thanks for reading.