See pricing
The Rise Of AI Coworkers
Y Combinator Startup PodcastAI

The Rise Of AI Coworkers

This episode shows what changes when AI stops acting like a chat tool and starts acting like a coworker with tools, identity, and an ongoing job. For PMs, the key lesson is that faster execution raises the value of clear objectives, careful permissions, and stronger product judgment.

November 16, 2026 · 60 min listen · 13 min read · Lauren Tan, Roman Ugarte
0:00
–:––

Context

Lauren Tan and Roman Ugarte are on the core team behind Grok Bot, which went from first line of code to launch in seven weeks. They describe a product built around AI teammates with their own identities, tools, and ongoing responsibilities, not just another chat box. The episode matters to PMs because it shows what happens when execution gets dramatically cheaper: marketing can give a bot an ad budget, Lauren can build a feature in a Slack thread without opening Cursor, and the product questions shift toward goals, trust, permissions, and taste. If AI coworkers become normal, product management becomes less about getting work done and more about deciding what work should exist, who or what should own it, and how to keep the experience coherent.

The Big Idea

AI coworkers shift the bottleneck from doing the work to deciding the work. Once bots can code, triage, research, and run tasks in the background, the hard product problem becomes defining clear objectives, permissions, and quality bars.

Lauren Tan and Roman Ugarte argue that this change is not limited to engineering. The same pattern is starting to show up in marketing, support, sales, and operations, but only when teams treat bots like scoped teammates rather than magical chats.

Key Insights

Bots became the work unit

  • Grok Bot was designed around bots as the main product primitive, not chats or files.
  • Each bot can have a name, identity, tools, skills, and an ongoing responsibility.
  • For PMs, this changes the design question. You are no longer just designing prompts or screens. You are designing a job: what the bot owns, what tools it may use, when it escalates, and how success is measured.
  • The framing clicked especially well for small businesses because it mapped to real hiring pain. Roman described owners realizing they could create a bot for bookkeeping or another hard-to-staff function instead of waiting to hire a person.

Trust grows in stages

  • Users do not jump straight to full autonomy. They usually start with a small task, then trust a bot with more context, then with an outcome, and eventually with an ongoing job.
  • Roman described this progression clearly: first a task, then an objective, then a full job responsibility.
  • Internal examples followed the same path. A data bot started as a read-only analyst in Slack. A marketing bot later got access to Google Ads, Facebook Ads, and a budget so it could work with a design bot and run ad experiments.
  • The PM lesson is to design autonomy as a ladder. Trust is earned through visible boundaries and repeated success, not granted all at once.

Work moved into Slack

Lauren said Grok Bot solved the last mile of agent work. Before, she gathered context from Slack, summarized it herself, and pasted it into a coding agent. Now the agent can live where the work already happens. She described building an entire feature in one Slack thread with a colleague and her bot Potato, with roughly 200 messages, screenshots, videos, and iteration in public, and she said she never opened Cursor for that project. For PMs, the takeaway is that collaboration surfaces like Slack can become the actual product workspace, not just a notification layer.

Execution stopped being scarce

  • Lauren is producing more than 4,000 PRs per month.
  • Roman said the real constraint is no longer whether the team can produce ideas, prototypes, or code fast enough.
  • The new bottleneck is alignment: what should the roadmap be, what does good look like, and which of the many buildable ideas actually fit the product vision?
  • Roman described a new normal where someone suggests an idea in discussion and another teammate already has a PR for it. That sounds productive, but it also raises the risk of a fragmented product if product judgment does not get stricter.

Knowledge work lacks guardrails

  • Code has hard feedback loops that many other functions do not. It compiles or it does not. It passes CI or it does not. Relevant context also lives in a codebase.
  • Marketing, support, procurement, and similar functions often lack those objective checks. Important context is scattered across tools or trapped in people's heads.
  • Roman sees that gap as one of the biggest differences between a software factory and a broader company factory.
  • For PMs, this means non-engineering bots need a stronger harness: clearer metrics, better context access, tighter action scopes, and explicit escalation rules.

Automate maintenance, not taste

  • Roman and Lauren drew a clear line between self-healing work and product-shaping work.
  • Lauren uses agents heavily for software maintenance, bug fixes, performance issues, and quality-of-life complaints. Roman said some of this can happen automatically overnight.
  • But the team does not want bots constantly changing the core pixels users see every day. Roman said that when a change affects the main experience, they rely on dogfooding and let the change sit longer before shipping.
  • The PM lesson is practical: the highest-confidence AI automation often sits in maintenance and operations, not in automatic roadmap churn.

Identity and authority matter

  • Once bots join Slack threads, meetings, and shared workflows, social context becomes a product problem.
  • Lauren said a bot in a busy thread may not know who the domain expert is, who has decision power, or whose instruction should override another person's.
  • The team is thinking in employee-like terms: owner, manager, collaborators, authentication, authorization, and permissioning.
  • For PMs, multiplayer AI is not just an interface problem. It is a governance and coordination problem.

Mental Models & Frameworks

Human onboarding analogy

  • Their recurring design question was simple: what would you do for a human?
  • If a new employee would get a computer, scoped credentials, and broader access only after earning trust, the bot should follow a similar path.
  • Use this model when deciding permissions, collaboration patterns, and escalation rules. It keeps the product grounded in workflows people already understand.

The trust ladder

  • Stage 1: a read only bot that answers questions or gathers facts.
  • Stage 2: an action bot that can complete bounded tasks.
  • Stage 3: a job bot that owns an ongoing responsibility or objective.
  • This model helps PMs sequence adoption. It is easier to win trust with a reliable analyst bot than to start with a fully autonomous operator.

Inverted quality pyramid

  • Lauren's engineering view is to spend the most effort on the codebase and static analysis, then on reusable skills and rules, and the least on expensive downstream review.
  • The point is not to inspect every agent output forever. The point is to encode quality into the system so fewer bad outputs are possible.
  • The PM translation is broader than engineering. If a workflow depends on constant manual correction, fix the system design first instead of adding more reviewers.

Execution abundance shift

  • When execution becomes cheap, the scarce resource becomes judgment.
  • Roman expects more companies to spend time engineering objective functions, defining KPIs, and clarifying what a good outcome actually is.
  • Use this model when a team feels overwhelmed by options. More capability does not reduce the need for prioritization. It raises the cost of weak prioritization.

Specialist bot model

  • Both guests prefer bots that care deeply about a particular problem, customer, or function, rather than one all-purpose super bot.
  • That maps better to how companies already think about teammates. It also keeps context and permissions narrower.
  • The product should still support people who want one general bot, but the specialist model explains why team bots often feel more trustworthy and easier to manage.

Decision Principles

Principle: Scope access slowly

When: a bot is moving from analysis into action. Why: trust is built through demonstrated competence. Starting with read only access lets teams validate quality before they grant logins, budgets, or write permissions.

Principle: Define outcomes first

When: a team can suddenly spin up many agents, prototypes, or PRs. Why: cheap execution magnifies vague thinking. If the objective is fuzzy, the team will get more output, not more progress.

Principle: Automate maintenance first

When: deciding where AI coworkers should own work early. Why: bug triage, reproduction, routine analysis, and quality-of-life fixes have clearer feedback loops than core product direction, so they are safer places to build trust and prove ROI.

Principle: Keep UX changes deliberate

When: bots can ship user-facing changes quickly. Why: a fast stream of uncoordinated improvements can make the product feel inconsistent. Roman said the team does not ship changes that fail to get clear internal product market fit.

Trade-offs & Nuance

Specialists or one super bot

  • Some users want one general bot. Others want many specialized bots.
  • A single bot is simpler to adopt. Specialized bots keep context tighter and mirror real job ownership.
  • Grok Bot's answer is flexibility. The deeper product lesson is that organization preference can be a product dimension, not just a setup detail.

Speed versus product coherence

  • Faster shipping creates more opportunities to fix real pain quickly.
  • The same speed also creates more random side projects and more product drift.
  • Roman said the team often has code ready for ideas before the product discussion is settled. That makes roadmap discipline more important, not less.

Autonomy versus control

  • The most valuable bots eventually need real tools, real credentials, and real ability to take action.
  • That also raises the stakes on authentication, authorization, vendor permissions, and escalation paths.
  • Teams can unlock value faster by expanding access as trust grows, instead of waiting for a perfect policy on day one.

Visibility versus social confusion

  • Public AI work in Slack helps other employees learn by watching top users operate.
  • Public AI work also exposes missing social intelligence. A bot may not know whose opinion carries decision authority in a crowded thread.
  • This trade-off matters for PMs building collaborative AI products. Transparency alone does not solve coordination.

Common Mistakes

Mistake: Shipping every easy PR

  • When code becomes cheap, it is tempting to ship every plausible improvement.
  • Roman explicitly warned against turning the product into a Frankensteiny collection of side projects.
  • The better bar is a consistent product philosophy plus strong internal dogfooding, especially for user-facing changes.

Mistake: Letting review do everything

  • Gary and Lauren discussed review steps that can burn huge numbers of tokens.
  • Lauren's answer was not endless review. It was to push quality upstream into architecture, static analysis, lint rules, and reusable skills so the system catches more issues by default.
  • For PMs, the analog is clear acceptance criteria, scoped permissions, and measurable success states, not endless manual checking.

Mistake: Treating bots like chats

  • The product worked because the team did not treat it as another chat window.
  • They gave bots identity, tools, proactive behavior, and shared ownership across a team.
  • If you want an AI coworker experience, design for jobs, context, and collaboration. A prompt box alone will not get you there.

Practical Application

Start with read only access

  • Pick one recurring request that already hits a specialist team, such as quick data checks, support triage, or vendor research.
  • Give a bot the minimum context and only read permissions.
  • Measure how often the bot produces a usable first answer before you let it take action.

Put bots in workflows

  • Add the bot to the surface where the work already happens, such as Slack, support queues, or customer threads.
  • The goal is to remove copy paste work and keep humans, context, and agent output in one place.
  • This also makes good workflows visible so other people can copy them.

Write objective first briefs

  • When a bot is ready for more autonomy, stop phrasing the work only as a task list.
  • Brief the bot the way you would brief a teammate: the desired outcome, the constraints, the tools allowed, the escalation rule, and what success looks like.
  • This matches the internal progression Roman described from task to objective to job.

Split maintenance from roadmap

  • Use AI coworkers first on bug fixing, repro steps, quality-of-life improvements, and repetitive operational work.
  • Keep new user experience changes behind stronger human review and product discussion.
  • This protects product coherence while still capturing most of the speed gains.

Encode guardrails before scaling

  • Before you multiply the number of agents, invest in the rules that make bad output harder.
  • In engineering, that meant static analysis, dependency rules, and reusable skills. In non-engineering workflows, the equivalent is approval rules, permissions, checklists, and success metrics.
  • Guardrails are what let a team trust higher autonomy without exploding review cost.

Questions to Consider

  • Which recurring request in your team already has a clear input and a clear useful output, so a read only bot could handle it before any bot gets permission to take action?
  • Where has your team already achieved execution abundance through coding agents or fast prototyping, but still lacks a shared definition of what good looks like?
  • Which user-facing changes in your product would feel chaotic if a bot shipped them continuously, even if each change looked locally reasonable?
  • If a bot joined one of your team's busiest Slack threads today, how would it know whose instruction to follow, what systems it may access, and when it should escalate to a human owner?

Bottom Line

AI coworkers make execution cheap and judgment expensive. The winning teams will not be the ones that generate the most output, but the ones that define jobs clearly, expand trust carefully, and keep human taste focused on the parts of the product where consistency and judgment matter most.

Tools & Products

Tool / ProductWhat it doesWhy it was mentioned
Grok BotAI teammates with identities, tools, and ongoing jobsThe main product discussed, built around bots as the primary unit of work.
SlackTeam communication and workflow surfaceMuch of the collaboration with bots now happens directly inside threads where the work already lives.
Cursor cloud agentsRemote coding agents with their own virtual machinesLauren used them through Grok Bot to prototype and ship features without opening Cursor directly.
PSACLauren Tan's reusable engineering skills for agentsHer skill stack encodes engineering preferences and guardrails so agents produce better code.
XSocial and support surfaceThe team uses it both to help users and as another place where bots can participate in work.

People to Follow

Lauren Tan

Lauren Tan is an engineer on the core Grok Bot team who shared one of the clearest public examples of bot-first software development in the episode. She came into tech from a non-technical degree, worked on the React compiler, and now openly shares practical agent workflows such as PSAC and Slack-native feature building.

Roman Ugarte

Roman Ugarte is on the core Grok Bot team and brings the product and organizational lens in this conversation. He is especially useful to follow for thinking about AI coworkers as scoped teammates with identities, permissions, and real jobs inside a company.

Experiments to Try

Experiment: Read only analyst

  • Hypothesis: a specialist read only bot in Slack can absorb a meaningful share of repetitive analysis requests without hurting trust.
  • Change: build one bot for a narrow workflow, such as feature impact questions against a data warehouse or repetitive support triage.
  • Test: route a fixed class of requests to the bot first for two weeks, while a human remains available for correction.
  • Measure: first response time, percentage of answers accepted without rewrite, and number of escalations.

Experiment: One thread feature sprint

  • Hypothesis: keeping product discussion, prototypes, and bot execution in one shared thread will shorten the loop between idea and usable artifact.
  • Change: run one small feature or workflow improvement entirely in a shared Slack thread with a bot collaborator.
  • Test: include a PM, an engineer, and one stakeholder who would normally review later in the process.
  • Measure: time from idea to prototype, number of feedback loops before alignment, and whether the team needed fewer handoffs than usual.
AI PM course

Everyone hears the same episodes.
Few can do what they describe.

Start for free