u/The_NineHertz

Been thinking about this a lot after watching user feedback on a few AI features ship in the last year.

Autocorrect gets a free pass. Everyone knows it screws up, everyone makes jokes about it, nobody uninstalls their keyboard over it. The mental model users have is "this is a helpful tool that occasionally messes up and I'll just fix it." Trust stays intact because the failure mode is obvious and easy to correct.

AI features don't seem to get the same treatment, and I'm trying to figure out why.

The pattern I keep seeing is that an AI feature can be right 95% of the time, but the 5% where it's confidently wrong does disproportionate damage. A summary that misses the key point. A suggested reply that's tonally off. A recommendation that's almost right but reveals the AI didn't actually understand what the user meant. Each individual miss feels small, but users start losing trust in the entire feature, and sometimes the whole app.

A few things I've noticed that seem to matter:

Confidence framing. When the AI hedges ("I think this might be...") users forgive misses. When it presents output flatly as fact, a single wrong answer makes users doubt everything that came before. Autocorrect implicitly hedges by being instantly editable. AI outputs often don't.

Reversibility. Autocorrect is one tap to undo. If your AI feature did something the user has to manually unwind, took an action, sent a message, reorganized something, the trust cost of a mistake is way higher than the value of a correct guess.

Failure visibility. Autocorrect fails in ways the user sees immediately. AI features often fail invisibly, a summary that quietly leaves out something important, a search that surfaces the wrong thing. By the time the user notices, they've already acted on the bad output, and now they're wondering what else they missed.

The "uncanny competence" problem. When an AI feature is good enough that users start trusting it like a colleague, the misses feel like betrayal rather than glitches. It's the same reason a self-driving car making a weird turn freaks people out more than a GPS giving bad directions, the bar is set by perceived intelligence.

What's working for some teams, from what I've seen:

• Showing the AI's "work" so users can sanity check it instead of blindly trusting the output
• Making outputs easy to edit inline rather than requiring a full redo
• Letting users correct the AI and actually using that signal, not just for retraining but to surface that "we heard you" in the UX
• Being honest about uncertainty in the copy, even at the cost of looking less magical

What doesn't work is pretending the AI is more reliable than it is and hoping users don't notice the misses. They notice. They just don't always tell you, they just use the feature less and eventually churn.

The thing I keep coming back to is that AI features probably need a completely different trust model than traditional software. Traditional software either works or it doesn't, and users mostly forgive bugs. AI features work in a fuzzy way, and users don't yet have a stable mental model for what "an AI that's usually right" should feel like. The teams that figure out how to communicate that fuzziness without making the product feel broken are going to win.

The autocorrect analogy is comforting but probably wrong. Autocorrect is a tool. AI features increasingly feel like a collaborator, and people are way harsher on collaborators who get things wrong than on tools that glitch.

Been thinking about this a lot lately and curious how others on this sub are handling it.

A year ago I'd write a bug ticket like I was talking to a teammate. Something like "login is broken on staging, repro from the usual flow, prob related to yesterday's auth PR." My team knew the context, knew what "usual flow" meant, knew which PR I was referencing. Done in 30 seconds, ticket closed in an hour.

Now half the time the first thing that touches my ticket is some AI agent, either Copilot Workspace, a Claude Code session a teammate kicks off, or whatever our PM has wired into Linear this week. And the agent doesn't know what "the usual flow" is. It doesn't know which PR I meant. It will confidently go off and "fix" something that wasn't broken, or open a PR that technically resolves the ticket as written but misses the actual issue entirely.

So I've started writing tickets almost like mini specs. Explicit repro steps. Exact file paths. The expected vs actual behavior spelled out. Links to the relevant commits instead of vague references. Sometimes I even add a "what NOT to change" section because agents love to scope-creep into adjacent files.

The weird part is I'm not sure if this is good or bad. On one hand, my tickets are now genuinely better documented and a new hire could pick them up cold. On the other hand, I'm spending 10 minutes writing a ticket that used to take 30 seconds, and I'm basically doing prompt engineering for a JIRA ticket which feels like a deeply cursed timeline.

A few specific things I'm wrestling with:

• Do you write tickets assuming an agent might pick it up, or do you tag tickets as "agent-eligible" vs "human-only"?
• Has anyone built internal templates or linting for ticket quality now that LLMs read them?
• Are your PMs writing tickets differently, or is this falling entirely on engineers to enforce?
• For those of you on teams that have fully embraced agent-driven work, did ticket quality go up or did everyone just give up and let the agents flail?

Genuinely curious what patterns are emerging. Feels like one of those quiet workflow shifts that nobody is really writing about but everyone is dealing with.

We’ve already moved from command lines → websites → mobile apps → voice assistants.
Now AI is starting to become the “middle layer” between users and software.

So here’s something I’ve been thinking about:

If AI assistants become smart enough to understand intent, context, preferences, and execute tasks across platforms… do we eventually stop needing traditional app interfaces altogether?

For example:

• Instead of opening 5 different apps, users could simply tell an AI what they want.
• The AI handles booking, payments, research, editing, scheduling, customer support, etc. in the background.
• No dashboards. No menus. No endless navigation flows.

In that scenario, apps may become more like “services/APIs behind the scenes” rather than products people directly interact with.

But at the same time:

• Humans still trust visuals, control, and transparency.
• Many experiences (gaming, social media, design, shopping) are heavily interface-driven.
• And companies probably won’t want to lose direct user attention to a universal AI layer.

So now I’m wondering:

Do you think AI could eventually replace traditional app interfaces for most tasks?
Or will interfaces simply evolve instead of disappearing?

I’ve been thinking a lot about how teams are defining SLAs for AI-powered features, especially when the output is inherently probabilistic.

With traditional IT services, it’s straightforward—you can commit to uptime, latency, error rates, etc. But with AI (especially LLM-driven features), things get blurry. You can guarantee response time, sure, but not always correctness or consistency.

For example, in a few use cases I’ve worked on:

• the same input can produce slightly different outputs
• accuracy depends heavily on prompt quality and context
• edge cases can behave unpredictably even after testing
• fixes aren’t always deterministic like regular bug patches

So I’m curious how others are handling this in real client-facing environments:

• Do you define SLAs only around system metrics (latency, availability), or do you include output quality?
• Has anyone successfully set measurable benchmarks for “accuracy” or “reliability”?
• How do you handle situations where the model gives a valid-looking but incorrect response?
• Are you explicitly educating clients about these limitations upfront, or baking buffers into contracts?

Right now, it feels like we’re trying to fit AI into traditional SLA structures that weren’t designed for it.

Would love to hear how people are balancing expectations vs reality in production systems.

Lately I’ve been seeing more teams rely on AI tools like GitHub Copilot and ChatGPT to build real features not just prototypes. In some cases, the output is surprisingly solid, sometimes even cleaner than what a human might write under time pressure.

So here’s what I’m trying to wrap my head around:

If an AI-built system and a human-built system deliver similar performance, reliability, and results, would you actually trust one more than the other?

On paper, “same results” should mean equal trust. But in reality, I feel like trust isn’t just about outcomes it’s about understanding how something was built. With human-written systems, you can usually trace decisions, reasoning, and accountability more clearly. With AI, even if the code works, there’s often that question of “do we fully understand why it works?”

There’s also the long-term angle:

• Maintenance and debugging
• Hidden edge cases
• Security implications

Would you feel comfortable deploying an AI-built system in something critical (like fintech, healthcare, or large-scale infra), assuming it passed all standard tests?

Curious how people here think about this. Is trust purely results-driven, or does the process behind the system still matter more?

As AI systems get more autonomous, it’s getting harder to pinpoint accountability when something goes wrong. If an algorithm makes a harmful decision—whether it’s biased hiring, a faulty medical recommendation, or a financial loss—who should actually be held responsible? The developer who built it, the company that deployed it, or is it unfair to blame humans entirely for something that can learn and evolve beyond its original design? Curious how people here think responsibility should be defined as AI becomes more complex.

.

I’ve been thinking about this…

What if you’re talking to someone and their texts are amazing—thoughtful, funny, emotionally spot-on. Then you find out they’ve been using AI to help write or improve their replies.

Not fully fake, just… enhanced.

Part of me feels it’s no different than overthinking texts or asking a friend what to say. Just a tool to communicate better.

But part of me wonders—am I connecting with them, or with an AI-polished version of them?

And what happens in real life if they’re not the same?

Would this bother you, or is it just the new normal?