Rethinking UX in the Age of Agentic AI (feat. Sai Dhanak)
An AI-native product reimagines consumer software by replacing apps with agent-led interactions, reducing friction, reshaping UX and teams, and showing how software changes when machines do the work.
In this episode, Krish speaks with Sai Dhanak, founder of Deduction, an AI-driven tax platform aimed at simplifying tax preparation for consumers. They discuss the challenges faced by traditional tax preparers, the innovative use of AI in the tax industry, and the importance of user experience in financial services. Sai shares insights on the technology stack behind Deduction, the evolving dynamics of software development teams, and the future of accounting in a rapidly changing landscape.
Most consumer software still follows a familiar script: download an app, learn a new interface, log in once a year, forget your password, repeat. But a new wave of AI-native products is quietly challenging that assumption—not by adding more features, but by removing the interface altogether.
In a recent podcast conversation, one founder outlined a radically simple idea: if AI agents are meant to do work for people, why are we still forcing users to do the work through apps?
That question reshapes everything—from UX decisions to team structure, infrastructure, and even how companies hire.
Podcast
Stop Building Apps. Start Building Agents — on Apple and Spotify.
The Real Problem Isn’t Filing Taxes—It’s Friction
For most consumers, taxes aren’t complicated because the rules are impossible to understand. They’re complicated because the experience is fragmented, slow, and expensive.
Millions of people don’t want to file taxes themselves, yet the traditional alternatives come with tradeoffs:
Weeks of waiting for responses
High preparation costs
Little to no proactive guidance
Worse, the accounting industry itself is shrinking. A majority of tax preparers are nearing retirement, and fewer people are entering the profession. The result is predictable: higher prices, slower service, and burnout on both sides.
Rather than building a better form or dashboard, this new approach reframes the experience entirely—treating tax preparation like an ongoing relationship instead of an annual event .
Why the Interface Starts With Email, Not an App
One of the most counterintuitive decisions discussed was choosing email, text, and phone calls as the primary interface—before web or mobile apps.
The reasoning is deceptively simple:
People already know how to email their accountant
Learning a new UX pattern is friction
Taxes aren’t a daily activity that justify an app
If users only interact three or four times a year, asking them to download, remember, and re-learn an app each time is unnecessary overhead. Forgotten passwords alone account for a huge percentage of customer support requests across consumer software.
Instead, the system behaves like a human accountant would: you email a question, you get an answer. Documents can be uploaded securely through the web when needed, but the default interaction feels familiar and human.
The web interface still exists—but as a lightweight companion, not the center of gravity.
Designing for Agents, Not Users
The deeper insight is philosophical: traditional software assumes the user is doing the work. Agentic systems assume the agent is.
That changes everything.
If an AI agent is responsible for preparing returns, tracking status, flagging issues, and checking in quarterly, the UI doesn’t need to be a control panel. It needs to be a conversation log.
Threads replace dashboards. Decisions replace workflows. Visuals appear only when text isn’t enough—like showing the status of a return as a simple progress line instead of another email explanation.
This isn’t anti-UI. It’s UI minimalism driven by first principles, not aesthetics.
The Hidden Product Challenge: When Simplicity Grows Complex
There’s a tension in this model that’s openly acknowledged.
As conversations grow—dozens of threads, years of decisions, repeated questions—the system risks becoming exactly what it tried to avoid: a full-blown app.
The solution isn’t more screens. It’s better abstraction.
Instead of forcing users to search past conversations, the next step is summarization: decision logs, conclusions already reached, actions already taken. The goal is to prevent users from asking the same question twice—not by hiding information, but by surfacing it at the right moment.
That balance—between conversational freedom and structural clarity—is one of the hardest unsolved problems in agent-driven products.
How AI Changes Team Structure, Not Just Code
The architectural shift doesn’t stop at UX. It reshapes the company itself.
Instead of large teams divided by frontend, backend, and QA, the model now favors:
Fewer, highly capable engineers
Heavy use of AI coding agents
Minimal standalone QA roles
Fewer product managers supporting more engineers
Prototypes are often “vibe-coded” directly by engineers or product leaders. Long PRDs are disappearing, replaced by working software and fast iteration. Code reviews, testing, and even pull request approvals increasingly involve agents—with humans supervising instead of executing every step.
In some cases, more than half of production code is AI-generated.
The bottleneck is no longer typing speed—it’s judgment.
Picking Infrastructure Like a Commodity
Even infrastructure choices reflect this pragmatism. Cloud providers, once deeply strategic decisions, are increasingly treated as interchangeable. The priority is flexibility, cost efficiency, and access to the best AI tools at any given moment.
Different models serve different purposes:
Some are better for reasoning
Others for communication
Others for cost-efficient background tasks
The stack adapts continuously, rather than locking into a single provider philosophy.
A Quiet Shift With Big Implications
What’s striking about this approach is how unflashy it is.
No new buzzwords. No radical UI experiments. No insistence that users change how they behave.
Instead, it asks a more uncomfortable question:
If AI can act like a capable teammate, why are we still designing software like it can’t?
The answer may redefine not just consumer products, but how software companies are built—from interfaces to org charts to the meaning of “doing the work”.
Technical Summary
Agent-native software shifts the core abstraction from user-driven workflows to autonomous task execution. Instead of designing screens that guide humans through step-by-step processes, systems are built around long-lived agents that own objectives, maintain state, and operate asynchronously. Interaction becomes event-driven—via email, chat, or APIs—while threads, memory, and decision logs replace dashboards and forms. Human involvement moves upstream to intent setting and downstream to supervision, exception handling, and final approval.
This architectural shift cascades through the stack. UX becomes a coordination layer rather than a control surface, frontends shrink in importance, and backends prioritize orchestration, evaluation, and auditability. Teams optimize for judgment over implementation, using AI to generate, test, and iterate on code continuously. Product velocity is no longer gated by interface complexity but by how well agents are constrained, observed, and corrected—making reliability, traceability, and alignment first-class engineering concerns.