Rethinking Software in the Age of AI
Instead of adding AI features to existing applications, let's build persistent intelligence layers that follow users across tools. Read: "Everything Starts Out Looking Like a Toy" #248
Hi, I’m Greg 👋! I write weekly product essays, including system “handshakes”, the expectations for workflow, and the jobs to be done for data. What is Data Operations? was the first post in the series.
This week’s toy: I’m not sure what this is, but it’s a pretty cool combination of retro UX and UI. Edition 248 of this newsletter is here - it’s April 28, 2025.
Thanks for reading! Let me know if there’s a topic you’d like me to cover.
The Big Idea
A short long-form essay about data things
⚙️ Rethinking Software in the Age of AI
We're making the same mistake with AI that early car manufacturers made with automobiles - we're building rehashed versions of existing applications instead of reimagining what's possible.
As Pete Koomen points out in his essay AI Horseless Carriages, today’s AI software too often consists of gluing AI features onto existing UI and UX paradigms rather than thinking about new ways to use these capabilities. We're treating AI like it needs to be used everywhere, regardless of suitability.
When all you have is a hammer, everything looks like a nail.
This isn't just a historical parallel, but an inflection point in software development. Early cars were called "horseless carriages" because people couldn't imagine transportation without horses. Today, we're struggling to imagine software without traditional interfaces and workflows.
We're trying to understand what it means to have AI deeply embedded in our work processes, but we're still seeing through the lens of what we know.
The trap of relying on yesterday
The problem with our current approach is that we're treating AI like a feature rather than a fundamental shift in how software works. Simple AI features like "summarize this" work well for basic tasks but fall short for complex analysis without proper context.
A true AI-first approach will create a persistent intelligence and orchestration layer to follow users across all their tools, adapting to their needs and preferences.
Future software will upgrade that annoying animated paperclip from late 90s Microsoft Word to a personal assistant that actually understands your work. Instead of building AI features into every application, we need to build a context-aware layer that enhances every tool you use.
The traditional approach embeds intelligence in each feature, while the new approach makes intelligence available across your entire toolset.
Setting a new user context
It's now possible to create a fabric of knowledge and context that follows you across tools and helps you to excel wherever you are. Comic book fans might think of this as the amplification that a Kryptonian gets when irradiated by a yellow sun. The things you can do become superhuman (and not just in email).
The next big opportunity in software isn't about building better features. It's about creating a system where default functionality meets personalized context. Every user gets the same core capabilities, but how those capabilities are used and combined becomes unique to each person's workflow and preferences.
The key difference? AI creates a fabric of capabilities that spans all software instantly. Users don't need to learn every feature of every application. They need to establish clear boundaries and policies for how their AI assistant should operate. The focus shifts from learning software to teaching your AI how to work with you.
Where we're going, we don't need roads
As Pete Koomen writes, "When I use AI to build software I feel like I can create almost anything I can imagine very quickly. AI feels like a power tool. It's a lot of fun. Many AI apps don't feel like that. Their AI features feel tacked-on and useless, even counter-productive."
Future interfaces will look like a combination of "standard features" and "configurable features". A standard feature will behave as expected while a configurable feature will take inputs from the user's AI tool context.
This personalization could take many forms. Some users might prefer voice commands, others typing. Some might work best in a notebook-style interface, others directly in the final application. The key is that users won't just use software - they'll shape it to their needs.
In short, the same way people interact with applications today is going to be prevalent in the future. The difference is that it's the user creating an application fabric that establishes an AI and UX context for them across tools, rather than only the product team thinking about that process.
One unexpected outcome: some users will fulfill the product manager role by creating user contexts that other teams can use.
The Path Forward
Moving beyond horseless applications requires three fundamental shifts in how we think about software:
Question Everything
What assumptions about interfaces and workflows are holding us back?
Which patterns are we copying without questioning their relevance?
What constraints can AI help us eliminate?
Start with First Principles
What are we trying to accomplish?
What's the simplest way to get there?
How can AI help us rethink the entire approach?
Embrace the Unfamiliar
Be willing to explore completely new interaction patterns
Accept that some experiments will fail
Look for opportunities to transform workflows across tools
We need to imagine what becomes possible to build when we are co-creating our application experience and building it across tools.
A Call to Action
The age of AI provides an opportunity to rethink how we build and use software.
The question isn't "how can we add AI to our applications?" It's "what kind of applications become possible in the age of AI?"
Let's stop building horseless carriages and start imagining what transportation could be.
What’s the takeaway? Instead of adding AI features to existing applications, we need to build persistent intelligence layers that follow users across tools, adapting to their needs and enabling fundamentally new ways of working. That’s the future of software in the age of AI.
Links for Reading and Sharing
These are links that caught my 👀
1/ AI agents that write help docs - One thing AI does well is summarize content from existing documents. So a great way to use it is to write help docs for a code base, like this Github project Pocketflow. It will still get stuck in some vibecoding tasks, but the point remains: AI can help you understand the code faster.
2/ How long does it take to finish a project? - When engineers get asked this question and respond: “a long time,” one of the reasons is “the problem is not specific enough.” Thinking about the problem like an engineer is one of the best product power-ups you can do because it de-risks the estimation process.
3/ I was promised household robots - simple tasks for humans like opening a jar, picking a grain of rice off the floor, or folding laundry are still really hard for robots. How far away from robots that do things in the house? Maybe we need to reconsider what we expect robots to do. For example, no one imagined robot vacuums … and now they are ubiquitous.
What to do next
Hit reply if you’ve got links to share, data stories, or want to say hello.
The next big thing always starts out being dismissed as a “toy.” - Chris Dixon