Software should share the work

The next user experience is people and software sharing responsibility for moving work forward.

For most of software history, the relationship has been simple. A person thinks. The software waits.

The person opens an application, finds a record, interprets what happened, decides what to do, changes the state and tells somebody else. The software stores the result. It may calculate or notify, but people carry the momentum.

This is why a company can own twenty applications and still run through memory, meetings and messages. The CRM knows a deal has stalled, but a manager has to notice. The carrier portal knows a delivery is late, but an operator has to connect it to the customer promise. The finance tool knows an invoice is unusual, but somebody has to find the purchase order and chase an approver.

The software is present. It is not sharing the work.

Imagine the work moving

A temperature sensor reports a failure on a refrigerated delivery.

In the familiar version, an alert enters a dashboard. Someone identifies the vehicle, calls the driver, checks the cargo, searches for a replacement, asks about cost, updates the arrival time and briefs the account team. Every transition depends on a person remembering the next system and colleague.

Now let software carry the routine path. The event joins the delivery record. The system knows which goods are at risk, what the customer was promised, which replacement vehicles are close and what cost requires approval. It finds a viable transfer and prepares one decision.

The duty manager receives the option, cost and customer impact together. After approval, software books the vehicle, updates the arrival estimate, preserves evidence and briefs the account manager. The account manager calls the customer with an answer.

Each person and system carries the part it is suited to carry.

Responsibility becomes the design material

Traditional UX asks whether a person can understand a screen and complete a task. Those questions remain. The deeper question is how responsibility should move.

Who notices the event? What can software do safely? Where does judgment matter? Who has authority? What happens if nobody responds? Which actor receives the work next?

Work can begin with a person and move to software. A warehouse supervisor marks a shipment as damaged; software checks replacement stock and prepares customer communication. Work can begin with software and move to a person. An agent detects an unusual payment and asks finance to decide whether it is fraud or a legitimate exception.

The interface is one moment in that movement. It should appear when a person has something meaningful to contribute.

Protect attention

A manager may receive hundreds of updates in a day. Only a few require judgment. A poor system turns every event into a notification and makes the manager perform the sorting.

A better system understands which decisions can wait, which block other work and which carry enough customer or financial risk to interrupt somebody now. It acts when it has authority, watches when no action is needed and asks when judgment matters.

Priority is therefore more than a sorted list. It is the organisation expressing what it values. A delayed medicine delivery should outrank an internal reporting error. A payment permission should move more carefully than a marketing draft.

When software carries the routine, the interface can become quieter.

A handoff should carry understanding

Most handoffs move responsibility without enough context.

A salesperson writes “finance approval needed.” Finance asks for the contract, margin, payment terms and precedent. The salesperson collects them from several systems. The customer waits.

A useful handoff arrives already understood. The commercial exception is attached to the opportunity. Finance sees the policy, requested departure, expected margin, customer history and reason. The authorised person can decide without starting another investigation.

The same principle applies between software systems. A qualification agent should pass its conclusion and evidence. A pricing service should pass the number and rule. A scheduling system should pass the date and customer constraint.

A handoff without context is a notification. A handoff with context allows the next actor to continue.

Intelligence and authority are different

A junior employee may recognise the right answer without having permission to make it. Software will often be in the same position.

An agent can propose a full customer resolution even when it cannot approve the credit. The manager receives the proposal with the history, policy, cost and reason. The agent contributes understanding. The manager contributes authority. Software executes the approved result.

Proposals let intelligence move without dissolving accountability. Broad ability to contribute does not require broad permission to act.

People must be able to question the rule

Operators discover where software is wrong. They see the harmless exception reviewed every morning and the lead routed to the wrong owner.

Those observations should remain attached to the case. Software can gather similar examples and show how much attention the current rule consumes. A person decides whether the organisation should work differently. The accepted decision becomes code through the second speed of organisational change.

The purpose of shared work is to extend human capacity without hiding human responsibility. Good software knows when to act, ask, wait and hand over. People can intervene and improve the rules.

The question is no longer only how easily someone can operate a tool. It is how well responsibility moves between every person and piece of software involved in the work.