The compression event
I have been working on Ora for roughly two months. Even with a still limited feature set, it already feels like a powerful piece of software: it can move between ASR, a local or cloud LLM, TTS, and a small tool layer that reaches into Mail, Calendar, Reminders, Apple Shortcuts, and memory. On some tasks it already feels more useful than Siri on macOS, not because it is bigger, but because it can actually chain context, language, and actions together.
And yet the reaction I keep having while building it is not, "this is impossibly advanced." It is, "of course this is what software should be heading toward." That is the important shift. The impressive part is no longer that an app can understand ambiguity, remember preferences, and act across multiple systems. The impressive part is when it does all of that reliably enough to feel natural.
That last number matters. GitHub reported that 92% of U.S.-based developers in large companies had already used AI coding tools. That is not a niche edge anymore. It means the ability to build sophisticated software is being distributed faster than most product teams, and certainly most consumers, have fully internalized.
Why the bar moved so quickly
The shift is not just about better models. It is about the stack around the models becoming easier to assemble. In 2024 and 2025, the biggest AI products stopped behaving like novelty chat windows and started behaving like operating assumptions for software.
OpenAI rolled out memory in ChatGPT and then expanded it so the product could build on past conversations and become more tailored over time. Projects pushed this even further by giving users persistent workspaces with files, instructions, and ongoing context. Apple folded ChatGPT into Siri and Writing Tools, while Apple Intelligence itself extends into Shortcuts. That is a very strong signal: context, generation, and action are no longer being treated as specialist features. They are becoming part of the default user environment.
On the builder side, Anthropic introduced a set of agent primitives in one shot: code execution, a Files API, an MCP connector, and prompt caching up to one hour. That matters because it turns large pieces of agent architecture into off-the-shelf capabilities. The implementation burden drops. The expectation burden rises.
What users are now being trained to expect
"Once memory, tool use, and context become default product features, users stop treating them as magic. They start treating them as missing when they are absent."
What the next expectation looks like
If this trend continues, users will stop grading software on whether it has an AI feature and start grading it on whether it behaves like it actually understands the situation. That means at least four things.
1. Personalization becomes table stakes
People will expect software to remember tone, workflow, preferences, recurring tasks, and context. Not in a creepy or opaque way, but in a practical way. Re-explaining yourself every time will feel like a product defect, not a normal limitation.
2. Tools need to act, not just answer
Answering is no longer enough. If the software can understand what you mean but still makes you click through six menus, copy text between windows, and manually translate intent into action, it will feel behind. The center of gravity is moving from "helpful interface" to "capable collaborator."
3. Edge cases become the product
This is the part I care about most. In older software, brittle edges were often tolerated because fixed workflows were simply how software worked. In AI-shaped software, that excuse gets weaker. Users will expect the system to ask a better follow-up, recover from ambiguity, handle partial information, and fail gracefully. If it does not, the experience will feel badly designed, even when the underlying feature list looks impressive.
4. Flexibility will outrank feature count
A smaller tool that adapts well to messy real-world use will beat a larger tool with rigid flows. Ora is a good example of this tension. The current feature set is still narrow compared with the largest assistants, but the value is in the way the pieces combine: speech, reasoning, action, and memory in one loop. That pattern is where the expectation shift lives.
There is no moat in "has AI"
I do not think the durable moat is "we added an LLM." Any frontier model can already help design systems like this surprisingly well. The architecture patterns are public. The infra pieces are getting standardized. The implementation speed is rising. That does not mean product work is easy. It means the differentiation moves somewhere else.
The moat, if there is one, is in taste, product judgment, trust, latency, integration quality, safety boundaries, and how well the software behaves when reality gets messy. The app that wins will not be the app that merely demonstrates intelligence. It will be the app that makes intelligence feel dependable.
That is also why the standard will keep rising. When enough teams can build the first 80%, users will compare products on the remaining 20%: recovery, fit, nuance, and polish under pressure.
What this means for builders
If you are building software right now, I think the main lesson is simple: the definition of good software is changing faster than most product plans are. We should assume our users will compare every new workflow not only to the direct competitors in our category, but to the best AI-shaped experiences they have had anywhere.
That does not mean every app needs to become a general-purpose assistant. It does mean every app will increasingly be judged on whether it can bend around the user instead of forcing the user to bend around it. Memory, flexibility, action, and graceful handling of messy cases will stop being premium features and start becoming baseline quality signals.
A year ago, a solo developer building something like Ora would have sounded improbable. Now it is possible. Soon it will not even sound surprising. That is the real story. The software bar has already moved, and it is still moving up.
Sources and further reading
- GitHubSurvey reveals AI's impact on the developer experience — GitHub reported that 92% of surveyed U.S.-based developers in large companies had used AI coding tools.
- OpenAIMemory and new controls for ChatGPT — Memory turned personalization into a mainstream product expectation instead of a niche experiment.
- OpenAIProjects in ChatGPT — Projects show how persistent files, instructions, and context are becoming normal user-facing workflow primitives.
- AppleApple Intelligence is available today on iPhone, iPad, and Mac and Apple Intelligence — Apple integrated ChatGPT into Siri and Writing Tools, and brought Apple Intelligence models into Shortcuts, which is a strong signal that these capabilities are becoming platform-level expectations.
- AnthropicNew capabilities for building agents on the Anthropic API — code execution, Files API, MCP connector, and one-hour prompt caching all reduce the friction of shipping sophisticated agent systems.