AI won the adoption race in 2026. It hasn’t won people’s trust, and it hasn’t made work lighter. That’s the uncomfortable thread running through Vitaly Friedman’s The State of AI for 2027, a 634-slide talk he gave at Maven.
I went through the whole deck so you don’t have to. It’s part survey data, part pattern library, part warning label. And underneath all the slides sits one argument worth taking seriously: the model is no longer the interesting part. The interesting part is everything we build around it.
The short version
If you only have two minutes, here’s what the deck is saying:
- Adoption is done. 99% of product teams have AI fully built into at least one workflow. Nobody is “piloting” anymore.
- Work got heavier, not lighter. Teams ship faster, but they also spend more time on email, chat, weekends, and cleaning up low-effort “workslop”.
- Trust is falling, at least in the US. The share of Americans who don’t trust AI at all jumped from 27% to 36% in under a year.
- The chatbot is no longer the default. Good AI lives in search boxes, data grids, canvases, voice, and the tools people already use.
- Context, skills, and specs matter more than prompts. Prompt engineering is basically dead. Context engineering replaced it.
- Agents need a leash. Harnesses, guardrails, evals, and adjustable autonomy are what make agents safe enough to ship.
Let’s go through it piece by piece.
The State Of AI 2027
(Storytelling Version)
AI adoption won. The workload didn’t shrink.
The deck opens with State of Product survey results, shown in Atlassian’s framing, and the headline is almost funny: 99% of product teams say AI is out of the pilot stage. 96% say it matches or beats human work in at least one area.
AI also isn’t just a fancy autocomplete anymore. Asked how they see working with AI, 52% of teams called it a task runner that completes multi-step work across tools. 28% see it as a research engine. 13% treat it as an autonomous agent. Only 7% still think of it as a basic assistant.
So far, so good. Then the caveats arrive.
Faster shipping, same old bottleneck
80% of teams say AI helps them ship faster. But customers aren’t getting value any sooner. Why? Because the slow part was never typing code. It was deciding what to build.
69% of PMs say decision-making hasn’t sped up at all. And 77% say executive gut instinct overrides data-driven decisions at least some of the time. You can give a team a rocket engine, but if the steering committee still meets once a month, you won’t go any faster.
There’s a quieter shift too. Only 24% of product teams now lead cross-functional work, down from 47% a year earlier. 89% regularly use AI for work another function used to own, and 67% admit it’s hard to define their own role. Roles aren’t merging. They’re blurring.
The rise of workslop
Here’s the term from the deck that stuck with me: workslop. Kate Niederhoffer, writing in HBR, defines it as low-effort AI output that looks like good work but lacks the substance to be useful. The person who generated it saves ten minutes. The colleague who has to fix it loses an hour.
The numbers are grim. 82% of respondents say teammates regularly ship low-effort AI work and then revise it after feedback. Two-thirds of leaders aren’t doing anything about it, and 39% aren’t even fully aware it exists. Meanwhile, about half of people spend their AI-saved time babysitting agents, re-prompting chats, or retracing an agent’s steps to work out what went wrong. 61% of PMs say AI has created more tech debt.
A US productivity study the deck cites (via ActivTrak, HBR, WSJ and NBC News) puts this in hard numbers:
| What changed after AI | Change |
|---|---|
| Time spent on chat and messaging | +145% |
| Time spent on email | +104% |
| Time spent in business tools | +95% |
| Time working Sundays | +58% |
| Time working Saturdays | +46% |
| Dealing with AI slop (2h+) | +41% |
| Frequency of costly mistakes | +39% |
| Time spent in focus mode | −9% |
The slide’s conclusion is blunt: AI doesn’t reduce work; it intensifies it. Hiten Shah calls this the efficiency trap. Building is fast now. Ownership isn’t.
The trust gap is getting wider
If the productivity data is awkward, the trust data is alarming. Using Morning Consult surveys, the deck shows American sentiment sliding in under a year:
| US adults | Aug 2025 | May 2026 |
|---|---|---|
| Trust AI a lot | 16% | 15% |
| Trust AI some | 28% | 22% |
| Trust AI a little | 29% | 27% |
| Don’t trust AI at all | 27% | 36% |
That’s 63% of Americans who trust AI only a little or not at all. Just 11% think AI should be adopted widely, while 21% say it should be avoided altogether.
A few details from these slides are worth sitting with:
- People trust themselves, and almost nobody else. Asked who can be trusted to use AI responsibly, Americans gave net positive scores only to themselves (+16), family (+7), and friends (+5). AI companies scored −14, large tech −18, and the federal government −28.
- AI is now a “distrusted category”. Out of 198 categories Morning Consult tracks, AI has the 10th highest average distrust, sitting near crypto, sports betting, and dating apps. xAI is the 5th most distrusted brand of all 3,198 tracked.
- Gen Z is the most skeptical. Their net trust score is 4.1, against 17.7 for millennials and 23.7 for people earning $100k or more.
- It’s mostly an English-speaking problem. Globally, trust in ChatGPT and Gemini rose almost everywhere. Gemini jumped 31 points in Vietnam and 29 in Brazil. ChatGPT’s net trust fell in only three markets: the US, Canada, and Australia.
Why does this matter for anyone designing products? Because, as Pavel Samsonov puts it in the deck, the mere presence of the word “AI” can now trigger fear and reduce conversion. Nilay Patel says it more sharply: calling something “AI-generated” is rarely a compliment anymore. Slapping a sparkle icon on a feature used to be marketing. In 2027 it might be a warning sign.
Part of the problem is that models got better in a sneaky way. Hiten Shah notes that strong benchmark scores don’t mean good judgement, and hallucinations are getting more subtle. Fluent, confident, and slightly wrong is harder to catch than obviously wrong. Arvind Narayanan and Sayash Kapoor make the same point: people expect AI in products to behave like software, predictable and accurate, and today’s AI isn’t reliable enough to take the human out of the loop.
The deck even lists the complaints people actually make: it “suddenly imagines things”, “silently assumes things”, “says what I want to hear”, “never asks for missing details”, “responds in big walls of text”. The one positive entry? “Good enough to get started.” That’s damning with faint praise.
AI is no longer just a chat box
Here’s where the deck turns from diagnosis to treatment, and it’s the part I enjoyed most. Friedman’s point is simple: an empty text box is a lazy interface. Austin Z. Henley calls natural language “the lazy UI” because it puts the whole burden on the user to know what to ask and how to ask it.
The better AI products of 2026 have moved on. The deck groups the alternatives into a kind of scaffolding menu:
| Pattern | What it looks like |
|---|---|
| Search omnibox | Type keywords or questions; autocomplete or AI answers appear depending on the query |
| Integrations | AI lives where work already happens, like Jira, Slack or Notion |
| Ambient AI | Sits quietly in the background, summoned on demand with whatever’s on screen |
| Voice onboarding | Gathers context by talking instead of making people sit through tutorials |
| Data layers and grids | Answers come back as tables, filters, and charts you can sort and edit, not walls of text |
| Precision knobs and presets | Sliders and preset prompts that move people between modes quickly and accurately |
| Branching | Drill deeper along paths, adding a custom prompt where needed |
| Workflow builders | Chain inputs and outputs into repeatable, executable flowcharts |
| Canvases | The outcome of a conversation, assembled in one place, instead of a scroll of turns |
| Agent dashboards | A view of tasks in progress, their status, and what needs approval |
Some of the smaller ideas are delightful. Intercom’s “scroll to accept” lets you tell the AI to go ahead just by scrolling past its suggestion (some people even pair it with a foot pedal). Key highlights put a TL;DR at the top of every answer. Auto-summaries play back how the AI understood a document, so you can catch a misunderstanding before it snowballs.
The summary slide for this chapter has a line every product team should tape to their monitor: many slowdowns can be fixed with just enough good ol’ UI. Not every problem needs a smarter model. Sometimes it needs a dropdown. Experts, the deck notes, often don’t want new AI tools at all. They want AI inside Excel.
Prompt engineering is dead. Long live context.
One slide quotes IEEE Spectrum’s Dina Genkina: when you ask a language model to write its own optimal prompt, it almost always beats the best prompt humans found by trial and error. So if the craft of clever prompting is fading, what replaces it?
The deck’s answer comes in three layers.
1. Skills: giving AI a way of thinking
By default, AI takes the shortest path to “done”. It isn’t a mind-reader. To do useful work, it needs to know how you think and decide.
That’s what skills are for. A skill isn’t a reference document. It’s a workflow, a sequence of steps written as a Markdown file that gets loaded into the AI’s context when the situation calls for it. Bundle several skills with tool connections, and you get a plugin tailored to a role. Connectors (via MCP) let the AI reach real apps like Jira or Slack.
Tey Bannerman frames this as guided AI: we pre-write our principles, our context, and how we make decisions, rather than feeding generic input that produces generic output. In his words, we’ve been teaching people the grammar of prompting without the vocabulary of thinking.
2. Design decisions as infrastructure
This part is aimed squarely at design teams. AI output drifts because of tiny inconsistencies that compound: decisions made but never written down, hard-coded values nobody cleaned up, too much faith that the AI will just “get it”.
The fix is to treat design decisions as infrastructure. Every important decision should find its way into a shared skill or spec file that the AI reads. An AI-ready design system, as the deck describes it, has:
- Spec files that document each UI component
- A token layer that lists every token and stays current
- A closed set of variables the AI must choose from
- An audit script that catches what the AI gets wrong
- A sync routine that flags spec files for updates after shipping
Addy Osmani’s line sums it up: a spec that holds up at scale requires real understanding of architecture, edge cases, and failure modes. Spec is product thinking.
3. Context engineering
Context is everything the AI considers when it answers: sources, history, code, the user’s level of expertise. And it’s fragile. A Chroma technical report the deck cites shows performance decaying faster as inputs grow, especially when a question is ambiguous. They call it context rot.
Too little context and you get vague answers or hallucinations. Too much and the model loses focus. Context also isn’t static: it drifts from relevant to partly relevant to useless as a conversation moves, and somebody has to clean it up.
Good context, according to the deck, is carefully orchestrated. It includes the task and background, relevant documents, rules and templates, good and bad examples, conversation history, the tools to use, and clear limits. Addy Osmani describes it as onboarding the AI to be at its best. I like the deck’s own shorthand better: context engineering is information architecture for AI prompts.
Trust is designed, not declared
If there’s a heart to this talk, it’s this chapter. Mary Borysova’s definition sets the tone: trust means believing, despite uncertainty, that a system is competent, predictable, aligned with your goals, and honest about its limits.
Trust doesn’t show up because a company promises good intentions. It builds slowly through reliable interactions, then collapses fast when something breaks. The deck’s practical takeaway: the best way to rebuild trust is to recover quickly.
There’s a subtle point here too. Most AI products shouldn’t want blind faith. Complacent users are a liability. The goal is calibrated trust, where people know when to lean on the AI and when to double-check it.
Borrowing heavily from Buzz Usborne’s work, the deck walks through four forces that decide whether AI gets adopted:
- When adoption stalls. If people must trust the AI before getting any value, they never start. And users are far less forgiving of an AI that acts for them than one that merely suggests.
- Controllability. Salesforce research the deck cites finds that human validation of outputs drives trust more than consistently accurate outputs. People trust what they can query, shape, and override. A good outline they can edit beats a perfect automated answer they can’t.
- Value perception. Powerful tools get abandoned when the effort feels high or unclear. The biggest effort killer is the blank page, the “what do I even type?” paralysis of ask-me-anything interfaces.
- Cost of failure. When AI acts on someone’s behalf, one mistake can wipe out trust built over months, especially when revenue, reputation, or customer relationships are at stake.
The resulting “trust flywheel” ties three things together: trust is the willingness to invest effort, value is the motivation to engage, and effort is the mental energy it costs. Usborne’s summary is the best line in the chapter: trust is earned through interaction, value must be perceived before it’s imagined, and effort must be absorbed rather than exported to users.
What does that look like in an interface? The deck offers several tools:
- Task builders that let people assemble a prompt from atomic building blocks, as Luke Wroblewski describes
- Strategic friction at high-stakes moments, because every automated step that removes a human also removes a natural moment of trust-building
- Reasoning traces that show the AI’s progress step by step, then collapse once the answer arrives
- Confidence scores tied to actions, like “review and approve” or a manual fallback, since a bare percentage rarely helps anyone decide
- Gradual autonomy, where the product unlocks more delegation only after the relationship has earned it
One research quote in this section stopped me. NN/g found that people rarely check AI output rigorously. They judge it by how well it fits what they already believe. That’s exactly why subtle hallucinations are so dangerous, and why design has to do the checking that users won’t.
Harnesses, guardrails and evals: the unglamorous part that matters
This is the most technical chapter, but don’t skip it. It’s where “cool demo” turns into “product people can rely on”.
Guardrails are environments, not rules
The deck reframes guardrails in a way I found genuinely useful. A guardrail isn’t a policy document or a line in a prompt telling the AI what not to do. It’s a protected sandbox. You don’t ask the AI to behave; you limit where it can move and let it do everything it can inside that space.
The harness is the wider system around the model: the tools it can use, how context and memory are handled, guardrails, verification steps, approvals, and recovery loops. The deck breaks a harness into five parts:
- Context engineering (what goes in, what stays out)
- A tool registry with clear boundaries
- Deterministic guardrails like safety checks and tests
- Agent loops (model, tools, results, repeat)
- Verification and ongoing feedback
The principle behind it: we engineer the environment to reduce mistakes, rather than hoping the model makes fewer of them.
Evals: how you know it actually works
AI evals are test suites that track how an AI system behaves over time. They answer the three questions every team eventually asks. Did this change make things better or worse? Is it good enough to ship? Can we catch regressions before users do?
The deck draws a clean line between two things people often confuse. Benchmarks help you choose a model. Product evals tell you whether your product, with your prompts, retrieval, tools, and code, actually works. You need both, for different decisions.
An eval has three ingredients:
| Part | What it does | Rule of thumb from the deck |
|---|---|---|
| Dataset | Input and expected-output test cases | 50–500 cases per capability, plus a definition of success |
| Runner | Sends each case through the pipeline and collects outputs | Run each case several times and track the spread |
| Grader | Scores each output, by human or LLM-as-a-judge | “Eval the eval”: aim for 80–90% agreement with human graders |
AI judges come with their own baggage: position and ordering effects, test cases leaking into training data, saturated scores above 98%, and metric gaming. So a human check stays in the loop.
The smartest advice here is to work bottom-up, not top-down. Instead of starting with generic metrics like “hallucination rate”, sample 50–100 real inputs and outputs, sort the failures into categories, measure how severe each one is, and let your metrics emerge from what you find.
It’s slower at first. It’s also how you find the problems specific to your domain. The deck notes that engineering teams often spend 60–80% of their time on error analysis and evaluation. That’s not overhead. That’s the job.
Agents: from replies to outcomes
Greg Nudelman sums up the difference between AI and AI agents in one word: autonomy. You don’t give an agent precise instructions. You give it a goal, and it figures out the rest, like an ant hill.
The deck lists six ingredients of any agent: a goal, a plan, tools, a loop (act, observe, decide, repeat), memory, and guardrails. With agents, the design focus shifts from the quality of a single answer to the system that produces outcomes.
That shift creates a whole new set of UX problems. Agent tasks can run for minutes, hours, or indefinitely. Many of their steps are invisible. They sometimes act irreversibly, and one wrong action can trigger a chain of others. So the interface has to help people follow along, verify, approve, and step in.
Autonomy should be a dial, not a switch
The deck’s most practical recommendation for agentic products is to make autonomy adjustable:
- Three modes at minimum. Suggest (propose only), confirm (ask before each step), and execute (run automatically with prior permission).
- Per-action autonomy. Set it for each capability, not globally. Creating a draft is harmless. Submitting a report has consequences.
- Start low. Default to the lowest autonomy level and let users raise it as they get comfortable.
- Mix levels. A single product can span a simple assistant, a copilot inside the user’s workflow, a supervised multi-step runner, and fully ambient automation triggered by events.
The security bill comes due
Signal’s president Meredith Whittaker gets one of the starkest slides in the deck. To book a ticket for you, an agent needs your data, your browser, your card number, your calendar, your messaging apps, root permissions, and a path to the cloud. In her words, agents need full, unencrypted root access, and that raises severe privacy and security issues.
Andrej Karpathy’s advice closes the loop: keep agents on the leash. Partial autonomy, a human in the loop, and whenever the output is vague, flag it and ask.
And then the line that will annoy a lot of vendors: most companies don’t need AI agents. Agents are less reliable and more unpredictable. What many teams actually need is simple automation or a well-designed AI workflow. Tom Goodwin adds a sharper organisational warning: you can fit AI into existing jobs or rebuild jobs around AI, but copying old structures and mistakes into a new paradigm rarely works.
What this means if you build AI products
Pull all of this together, and the 2027 picture looks quite different from the hype cycle of a couple of years ago. Here’s how I’d summarise the shift:
| The old assumption | The 2027 reality |
|---|---|
| Add AI and work gets faster | Shipping gets faster; deciding, reviewing and cleaning up get slower |
| A chat box is the AI interface | The best AI hides in search, grids, canvases, voice, and existing tools |
| Better prompts mean better output | Better context, skills, and specs mean better output |
| “Powered by AI” sells | “Powered by AI” can scare people off, especially in the US |
| Accuracy builds trust | Controllability and quick recovery build trust |
| Agents are the end goal | Most teams need a reliable workflow, not an autonomous agent |
| Benchmarks tell you it works | Only product evals on your own data tell you it works |
The deck’s own closing checklist turns this into ten design rules. A few of them are worth repeating word for word, because they’re so concrete:
- AI is a value proposition when it’s mostly reliable.
- The easiest way to add context is with UI controls.
- Users often don’t think about scoping, so suggest it.
- Lower the setup barrier by highlighting missing details.
- Expose prompts as editable blocks people can switch on and off.
- Good AI experiences keep humans in the loop.
- Designing AI is always about designing for trust.
Before building anything, the deck also suggests asking a handful of questions that most AI kickoff meetings skip.
Which features should be AI, and which shouldn’t? What performance threshold will users actually accept? Which AI actions are reversible and which are permanent? How much autonomy should an agent have? And when is human judgement non-negotiable?
That last question might be the most important one. Teams love to say “let’s add an agent” or “let’s use an LLM”. Far fewer stop to decide which parts of a feature should be probabilistic, which must stay deterministic, and where a person has to make the call.
A few caveats before you quote this
This is a talk deck, not a peer-reviewed report, and it’s worth reading it that way.
- It’s a curated collection. Most of the data comes from other sources: the State of Product survey, Morning Consult, an ActivTrak-based productivity study, Salesforce, NN/g, and others. The deck shows the slides but not their methods or sample sizes.
- The trust data is US-heavy. The most dramatic numbers describe American adults. The global picture is far more optimistic, so be careful generalising.
- Survey respondents are product people. Numbers like “99% have integrated AI” describe product teams, not the wider workforce.
- Some slides repeat. In a 634-slide deck, a few quotes and charts show up more than once. The argument doesn’t change because of it, but the deck is longer than its ideas.
None of that weakens the core argument. If anything, the variety of sources pointing in the same direction makes it stronger.
The bottom line
The State of AI for 2027 isn’t really about AI. It’s about design, judgement and trust.
The models will keep improving. That part is almost a given. What the deck makes clear is that better models alone won’t fix workslop, rebuild trust, or stop an agent from booking the wrong flight with your card. Those problems get solved by people who decide what AI should and shouldn’t do, give it the right context, put guardrails around it, test it honestly, and design interfaces that keep humans firmly in control.
Or, as one of the deck’s last slides puts it: the value of any technology lies not in itself, but in the real impact it brings to real people. AI features aren’t very useful if they aren’t used. And in 2027, they won’t be used unless people trust them.
Sources
- Vitaly Friedman, The State of AI for 2027, talk at Maven,(provided PDF)
- Patterns and resources referenced in the deck: AI Design Patterns, Shape of AI, AI UX Patterns, How To Write A Spec For AI Agents, Why Chatbots Are Not The Future