An analysis of a five-step evolution story – and why the POS is a perfect stress test for it.
Most predictions about software are made from the comfort of a laptop. Retail is different. A store is physics, money, and law. It has scanners that must beep, payments that must clear, and receipts that must be provable years later. That is why I like using the point of sale (POS) as a stress test for any ‘future of software’ idea. If a vision works at checkout, it will probably work almost anywhere.
A five-step picture of where software might go is a bold and clean storyline: we move from people building apps, to everyone migrating to their own stacks, to programming languages fading away, to apps disappearing, until only AI remains as the universal interface. Below I analyze each step, then I show how an agentic POS architecture could be a realistic bridge between today and that future.
The five steps, unpacked
1) Everyone starts building their own solutions; it is easy, fun, and not expensive.
This is already happening. AI lowers the skill barrier. A business user can describe a workflow and get a working prototype. In retail, this shows up as teams building small tools: store task apps, dashboards, promotion testers, exception handlers. The upside is speed and creativity. The risk is fragmentation – too many small systems with unclear ownership.
2) Everyone moves and migrates to their own solutions, even with old data.
Also plausible, but the pain is real. Migration is not only moving rows from one database to another. It is moving meaning: product identities, history, returns links, audit evidence, customer consent, and retention rules. In regulated environments, ‘we cannot migrate this’ is not a detail – it can be a legal wall. So yes, people will move anyway, but the winners will build strong data contracts, event logs, and archives that survive migration.
3) Programming languages disappear; AI writes machine code directly, killing compilers and interpreters.
This is the most controversial step. Languages are not only for the computer; they are for humans and for proof. Retail systems need to be audited, tested, certified, and explained. Machine code is hard to review and hard to verify. What I do expect is a shift in visibility: languages become less visible to humans, while AI generates the code. But compilers, interpreters, and runtimes may not disappear. They may become more important as verifiers: they enforce safety rules, generate evidence, and produce reproducible builds.
4) Applications disappear; you just tell the AI to do anything the apps did.
The user interface can disappear, yes. We are moving from ‘click the UI’ to ‘describe the intent’. But the functions behind apps – payments, tax calculation, inventory posting, approvals – do not disappear. They become services, rules engines, and transaction kernels. In other words: apps as screens fade, but systems as contracts remain. The store still needs a deterministic record of what happened.
5) Only AI remains; nobody develops anything, we just tell the AI what to do.
AI will become the main orchestrator, but in serious commerce we will still need guardrails: identity, permission, compliance rules, and immutable logs. The future is likely ‘AI everywhere, but not AI for everything’. AI will handle understanding, conversation, and exception handling. Deterministic modules will handle money, law, and proof.
Why the POS is the perfect example
Checkout is where software meets reality. A POS must work in real time, often offline. It must integrate with hardware, payment devices, and country fiscal systems. It must produce evidence that survives audits. If we imagine software turning into AI agents, the POS is exactly where we learn what can be fluid and what must stay strict.
An agentic POS architecture: apps fade, capabilities remain
Here is a practical way to map described vision onto a POS. Instead of one monolithic application, we split the checkout into specialized agents that communicate through a strict protocol. Some parts can be AI-driven. Some parts must remain deterministic.
Imagine four local components running at the cash register (or store edge):
Device and Experience Agent
Controls scanner, printer, cash drawer, customer display, and guides the cashier/customer in natural language. This is where AI shines: it can explain, troubleshoot, and handle messy exceptions.
Transaction Core (Transaction Kernel)
Creates and commits transactions: basket, prices, taxes, discounts, returns, and the immutable event log. This should be deterministic – a state machine with strict rules – because it becomes the legal record.
Payment Agent
Handles authorization/capture/refunds via certified payment SDKs and terminals. AI can assist with the flow, but execution must be safe, tokenized, and PCI-compliant.
Fiscalization / e-Invoice Agent
Applies country rules: signing, QR codes, counters, certificates, reporting and fallbacks. This is proof, not prediction. It must be correct, repeatable, and audit-ready.
All components can speak using an agreed, event-driven protocol: every action carries a transaction ID, an idempotency key (to prevent double charging), timestamps, and signed logs. This is how you get the benefits of agents without turning the POS into a probabilistic gamble.
What this example teaches us about the future
The POS shows why steps 4 and 5 are directionally right, but incomplete. Yes, the application as a screen can disappear. A cashier might simply say: ‘Sell these items, apply 10% loyalty discount, split payment, email receipt.’ The AI can interpret the intent. But underneath, the transaction kernel still must execute a strict sequence and write proof.
This is also why programming languages and compilers are unlikely to vanish entirely. In commerce, we need reproducibility: the same input must produce the same output, months later, under audit. That need for proof pushes us toward verifiable builds, strong typing, test suites, certified modules, and controlled updates. AI will generate more code, but the system will still demand a chain of evidence.
A slightly more realistic version of discussed five steps
If we keep the meaning but adjust it for the realities of retail, money, and regulation, I would rewrite the story like this:
First, everyone builds – because AI makes creation cheap. Second, data portability becomes a competitive weapon, so companies invest in event logs, archives, and clean data contracts. Third, programming languages become less visible because AI writes most of the code, but verification and safety tooling becomes more important, not less. Fourth, apps fade into agent-orchestrated capabilities, while the transaction kernels remain. Fifth, AI becomes the main interface, but the world still runs on deterministic cores for payments, fiscalization, and audit.
What retailers and POS vendors should do now
If you believe this direction is even 30% true, the roadmap is clear. Invest less in monolithic UI changes and more in clean, stable cores: an event-based transaction model, strong identity and permissions, clear integration contracts, offline resilience, and compliance evidence by design. Then let AI sit on top – turning complexity into conversation – without weakening the legal truth of the transaction.
The future will not be ‘no software’. It will be ‘software you do not see’, orchestrated by AI, built on kernels you can trust.